feat: add create workflow run error server action catch, redirect workflow parse error, add key revoked col

web/src/server/createRun.ts

@@ -6,102 +6,101 @@ import { ComfyAPI_Run } from "@/types/ComfyAPI_Run";
 import { eq } from "drizzle-orm";
 import { revalidatePath } from "next/cache";
 import "server-only";
+import { withServerPromise } from "./withServerPromise";
 
-export async function createRun(
-  origin: string,
-  workflow_version_id: string,
-  machine_id: string,
-  inputs?: Record<string, string>
-) {
-  const machine = await db.query.machinesTable.findFirst({
-    where: eq(workflowRunsTable.id, machine_id),
-  });
-
-  if (!machine) {
-    throw new Error("Machine not found");
-    // return new Response("Machine not found", {
-    //   status: 404,
-    // });
-  }
-
-  const workflow_version_data =
-    // workflow_version_id
-    //   ?
-    await db.query.workflowVersionTable.findFirst({
-      where: eq(workflowRunsTable.id, workflow_version_id),
+export const createRun = withServerPromise(
+  async (
+    origin: string,
+    workflow_version_id: string,
+    machine_id: string,
+    inputs?: Record<string, string>,
+  ) => {
+    const machine = await db.query.machinesTable.findFirst({
+      where: eq(workflowRunsTable.id, machine_id),
     });
-  // : workflow_version != undefined
-  // ? await db.query.workflowVersionTable.findFirst({
-  //     where: and(
-  //       eq(workflowVersionTable.version, workflow_version),
-  //       eq(workflowVersionTable.workflow_id)
-  //     ),
-  //   })
-  // : null;
-  if (!workflow_version_data) {
-    throw new Error("Workflow version not found");
-    // return new Response("Workflow version not found", {
-    //   status: 404,
-    // });
-  }
 
-  const comfyui_endpoint = `${machine.endpoint}/comfyui-deploy/run`;
-
-  const workflow_api = workflow_version_data.workflow_api;
-
-  // Replace the inputs
-  if (inputs && workflow_api) {
-    for (const key in inputs) {
-      Object.entries(workflow_api).forEach(([_, node]) => {
-        if (node.inputs["input_id"] === key) {
-          node.inputs["input_id"] = inputs[key];
-        }
-      });
+    if (!machine) {
+      throw new Error("Machine not found");
+      // return new Response("Machine not found", {
+      //   status: 404,
+      // });
     }
-  }
 
-  const body = {
-    workflow_api: workflow_api,
-    status_endpoint: `${origin}/api/update-run`,
-    file_upload_endpoint: `${origin}/api/file-upload`,
-  };
-  // console.log(body);
-  const bodyJson = JSON.stringify(body);
-  // console.log(bodyJson);
+    const workflow_version_data =
+      // workflow_version_id
+      //   ?
+      await db.query.workflowVersionTable.findFirst({
+        where: eq(workflowRunsTable.id, workflow_version_id),
+      });
+    // : workflow_version != undefined
+    // ? await db.query.workflowVersionTable.findFirst({
+    //     where: and(
+    //       eq(workflowVersionTable.version, workflow_version),
+    //       eq(workflowVersionTable.workflow_id)
+    //     ),
+    //   })
+    // : null;
+    if (!workflow_version_data) {
+      throw new Error("Workflow version not found");
+      // return new Response("Workflow version not found", {
+      //   status: 404,
+      // });
+    }
 
-  // Sending to comfyui
-  const _result = await fetch(comfyui_endpoint, {
-    method: "POST",
-    body: bodyJson,
-    cache: "no-store",
-  });
+    const comfyui_endpoint = `${machine.endpoint}/comfyui-deploy/run`;
 
-  if (!_result.ok) {
-    throw new Error(`Error creating run, ${_result.statusText}`);
-  }
+    const workflow_api = workflow_version_data.workflow_api;
 
-  console.log(_result);
+    // Replace the inputs
+    if (inputs && workflow_api) {
+      for (const key in inputs) {
+        Object.entries(workflow_api).forEach(([_, node]) => {
+          if (node.inputs["input_id"] === key) {
+            node.inputs["input_id"] = inputs[key];
+          }
+        });
+      }
+    }
 
-  const result = await ComfyAPI_Run.parseAsync(await _result.json());
+    const body = {
+      workflow_api: workflow_api,
+      status_endpoint: `${origin}/api/update-run`,
+      file_upload_endpoint: `${origin}/api/file-upload`,
+    };
+    // console.log(body);
+    const bodyJson = JSON.stringify(body);
+    // console.log(bodyJson);
 
-  console.log(result);
+    // Sending to comfyui
+    const _result = await fetch(comfyui_endpoint, {
+      method: "POST",
+      body: bodyJson,
+      cache: "no-store",
+    });
 
-  // Add to our db
-  const workflow_run = await db
-    .insert(workflowRunsTable)
-    .values({
-      id: result.prompt_id,
-      workflow_id: workflow_version_data.workflow_id,
-      workflow_version_id: workflow_version_data.id,
-      workflow_inputs: inputs,
-      machine_id,
-    })
-    .returning();
+    if (!_result.ok) {
+      throw new Error(`Error creating run, ${_result.statusText}`);
+    }
 
-  revalidatePath(`/${workflow_version_data.workflow_id}`);
+    const result = await ComfyAPI_Run.parseAsync(await _result.json());
 
-  return {
-    workflow_run_id: workflow_run[0].id,
-    message: "Successfully workflow run",
-  };
-}
+    // Add to our db
+    const workflow_run = await db
+      .insert(workflowRunsTable)
+      .values({
+        id: result.prompt_id,
+        workflow_id: workflow_version_data.workflow_id,
+        workflow_version_id: workflow_version_data.id,
+        workflow_inputs: inputs,
+        machine_id,
+      })
+      .returning();
+
+    revalidatePath(`/${workflow_version_data.workflow_id}`);
+
+    return {
+      workflow_run_id: workflow_run[0].id,
+      message: "Successfully workflow run",
+    };
+  },
+);

web/src/server/curdApiKeys.ts

@@ -29,7 +29,7 @@ export async function addNewAPIKey(name: string) {
   if (orgId) {
     token = jwt.sign(
       { user_id: userId, org_id: orgId },
-      process.env.JWT_SECRET!
+      process.env.JWT_SECRET!,
     );
   } else {
     token = jwt.sign({ user_id: userId }, process.env.JWT_SECRET!);
@@ -57,12 +57,20 @@ export async function deleteAPIKey(id: string) {
 
   if (orgId) {
     await db
-      .delete(apiKeyTable)
+      .update(apiKeyTable)
+      .set({
+        revoked: true,
+        updated_at: new Date(),
+      })
       .where(and(eq(apiKeyTable.id, id), eq(apiKeyTable.org_id, orgId)))
       .execute();
   } else {
     await db
-      .delete(apiKeyTable)
+      .update(apiKeyTable)
+      .set({
+        revoked: true,
+        updated_at: new Date(),
+      })
       .where(and(eq(apiKeyTable.id, id), eq(apiKeyTable.user_id, userId)))
       .execute();
   }
@@ -77,13 +85,21 @@ export async function getAPIKeys() {
 
   if (orgId) {
     return await db.query.apiKeyTable.findMany({
-      where: eq(apiKeyTable.org_id, orgId),
+      where: and(eq(apiKeyTable.org_id, orgId), eq(apiKeyTable.revoked, false)),
       orderBy: desc(apiKeyTable.created_at),
     });
   } else {
     return await db.query.apiKeyTable.findMany({
-      where: eq(apiKeyTable.user_id, userId),
+      where: and(eq(apiKeyTable.user_id, userId), eq(apiKeyTable.revoked, false)),
       orderBy: desc(apiKeyTable.created_at),
     });
   }
 }
+
+export async function isKeyRevoked(key: string) {
+  const revokedKey = await db.query.apiKeyTable.findFirst({
+    where: and(eq(apiKeyTable.key, key), eq(apiKeyTable.revoked, true)),
+  });
+
+  return revokedKey !== undefined;
+}

web/src/server/withServerPromise.ts

@@ -0,0 +1,12 @@
+export async function wrapServerPromise<T>(result: Promise<T>) {
+  return result.catch((error) => {
+    return {
+      error: error.message,
+    };
+  });
+}
+export function withServerPromise<T extends (...args: any[]) => Promise<any>>(
+  fn: T
+): (...args: Parameters<T>) => Promise<ReturnType<T> | { error: string; }> {
+  return (...args: Parameters<T>) => wrapServerPromise(fn(...args));
+}