remove symlink to nitro-v2

Author: atinux

workbench/nitro-v2/server/api/trigger.post.ts

@@ -1,7 +1,7 @@
 import { defineEventHandler, getRequestURL, readRawBody } from 'h3';
 import { start } from 'workflow/api';
 import { hydrateWorkflowArguments } from 'workflow/internal/serialization';
-import { allWorkflows } from '../_workflows.js';
+import { allWorkflows } from '../../_workflows.js';
 
 export default defineEventHandler(async (event) => {
   const url = getRequestURL(event);

workbench/nuxt/server/api

@@ -0,0 +1,9 @@
+// THIS FILE IS JUST FOR TESTING HMR AS AN ENTRY NEEDS
+// TO IMPORT THE WORKFLOWS TO DISCOVER THEM AND WATCH
+
+import * as workflows from '../../workflows/3_streams.js';
+
+export default async ({ req }: { req: Request }) => {
+  console.log(workflows);
+  return Response.json('hello world');
+};

workbench/nuxt/server/api/chat.post.ts

@@ -0,0 +1,26 @@
+import { defineEventHandler, readRawBody } from 'h3';
+import { getHookByToken, resumeHook } from 'workflow/api';
+
+export default defineEventHandler(async (event) => {
+  const body = await readRawBody(event);
+  const { token, data } = JSON.parse(body as string);
+
+  let hook: Awaited<ReturnType<typeof getHookByToken>>;
+  try {
+    hook = await getHookByToken(token);
+    console.log('hook', hook);
+  } catch (error) {
+    console.log('error during getHookByToken', error);
+    // TODO: `WorkflowAPIError` is not exported, so for now
+    // we'll return 404 assuming it's the "invalid" token test case
+    return Response.json(null, { status: 404 });
+  }
+
+  await resumeHook(hook.token, {
+    ...data,
+    // @ts-expect-error metadata is not typed
+    customData: hook.metadata?.customData,
+  });
+
+  return Response.json(hook);
+});

workbench/nuxt/server/api/hook.post.ts

@@ -0,0 +1,82 @@
+import { defineEventHandler, getRequestURL } from 'h3';
+import { getRun } from 'workflow/api';
+
+export default defineEventHandler(async (event) => {
+  const url = getRequestURL(event);
+  const runId = url.searchParams.get('runId');
+  if (!runId) {
+    return new Response('No runId provided', { status: 400 });
+  }
+
+  const outputStreamParam = url.searchParams.get('output-stream');
+  if (outputStreamParam) {
+    const namespace = outputStreamParam === '1' ? undefined : outputStreamParam;
+    const run = getRun(runId);
+    const stream = run.getReadable({
+      namespace,
+    });
+    // Add JSON framing to the stream, wrapping binary data in base64
+    const streamWithFraming = new TransformStream({
+      transform(chunk, controller) {
+        const data =
+          chunk instanceof Uint8Array
+            ? { data: Buffer.from(chunk).toString('base64') }
+            : chunk;
+        controller.enqueue(`${JSON.stringify(data)}\n`);
+      },
+    });
+    return new Response(stream.pipeThrough(streamWithFraming), {
+      headers: {
+        'Content-Type': 'application/octet-stream',
+      },
+    });
+  }
+
+  try {
+    const run = getRun(runId);
+    const returnValue = await run.returnValue;
+    console.log('Return value:', returnValue);
+    return returnValue instanceof ReadableStream
+      ? new Response(returnValue, {
+          headers: {
+            'Content-Type': 'application/octet-stream',
+          },
+        })
+      : Response.json(returnValue);
+  } catch (error) {
+    if (error instanceof Error) {
+      if (error.name === 'WorkflowRunNotCompletedError') {
+        return Response.json(
+          {
+            ...error,
+            name: error.name,
+            message: error.message,
+          },
+          { status: 202 }
+        );
+      }
+
+      if (error.name === 'WorkflowRunFailedError') {
+        return Response.json(
+          {
+            ...error,
+            name: error.name,
+            message: error.message,
+          },
+          { status: 400 }
+        );
+      }
+    }
+
+    console.error(
+      'Unexpected error while getting workflow return value:',
+      error
+    );
+    return Response.json(
+      {
+        error: 'Internal server error',
+      },
+      { status: 500 }
+    );
+  }
+});

workbench/nuxt/server/api/trigger.get.ts

@@ -0,0 +1,62 @@
+import { defineEventHandler, getRequestURL, readRawBody } from 'h3';
+import { start } from 'workflow/api';
+import { hydrateWorkflowArguments } from 'workflow/internal/serialization';
+import { allWorkflows } from '../../_workflows.js';
+
+export default defineEventHandler(async (event) => {
+  const url = getRequestURL(event);
+
+  const workflowFile =
+    url.searchParams.get('workflowFile') || 'workflows/99_e2e.ts';
+  if (!workflowFile) {
+    return new Response('No workflowFile query parameter provided', {
+      status: 400,
+    });
+  }
+  const workflows = allWorkflows[workflowFile as keyof typeof allWorkflows];
+  if (!workflows) {
+    return new Response(`Workflow file "${workflowFile}" not found`, {
+      status: 400,
+    });
+  }
+
+  const workflowFn = url.searchParams.get('workflowFn') || 'simple';
+  if (!workflowFn) {
+    return new Response('No workflow query parameter provided', {
+      status: 400,
+    });
+  }
+  const workflow = workflows[workflowFn as keyof typeof workflows];
+  if (!workflow) {
+    return new Response(`Workflow "${workflowFn}" not found`, { status: 400 });
+  }
+
+  let args: any[] = [];
+
+  // Args from query string
+  const argsParam = url.searchParams.get('args');
+  if (argsParam) {
+    args = argsParam.split(',').map((arg) => {
+      const num = parseFloat(arg);
+      return Number.isNaN(num) ? arg.trim() : num;
+    });
+  } else {
+    // Args from body
+    const body = await readRawBody(event);
+    if (body) {
+      args = hydrateWorkflowArguments(JSON.parse(body), globalThis);
+    } else {
+      args = [42];
+    }
+  }
+  console.log(`Starting "${workflowFn}" workflow with args: ${args}`);
+
+  try {
+    const run = await start(workflow as any, args as any);
+    console.log('Run:', run);
+    return Response.json(run);
+  } catch (err) {
+    console.error(`Failed to start!!`, err);
+    throw err;
+  }
+});