workplane 0.2.0 → 0.3.1

package/dist/server.js

@@ -1,9 +1,126 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../dbos/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DbosWorkflows: () => DbosWorkflows,
+  createDbosWorkflows: () => createDbosWorkflows
+});
+import { DBOS } from "@dbos-inc/dbos-sdk";
+function createDbosWorkflows(store) {
+  return new DbosWorkflows(store);
+}
+var DbosWorkflows;
+var init_src = __esm({
+  "../dbos/src/index.ts"() {
+    "use strict";
+    DbosWorkflows = class {
+      registered;
+      constructor(store) {
+        const createTask = DBOS.registerWorkflow(
+          async (input) => DBOS.runStep(() => store.createTask(input), { name: "store-create-task" }),
+          { name: "createTaskWorkflow" }
+        );
+        const retryTask = DBOS.registerWorkflow(
+          async (taskId) => DBOS.runStep(() => store.retryTask(taskId), { name: "store-retry-task" }),
+          { name: "retryTaskWorkflow" }
+        );
+        const cancelTask = DBOS.registerWorkflow(
+          async (taskId) => DBOS.runStep(() => store.cancelTask(taskId), { name: "store-cancel-task" }),
+          { name: "cancelTaskWorkflow" }
+        );
+        const updateRunStatus = DBOS.registerWorkflow(
+          async (runId, status, error) => DBOS.runStep(() => store.updateRunStatus(runId, status, error), { name: "store-update-run-status" }),
+          { name: "updateRunStatusWorkflow" }
+        );
+        const appendRunLogs = DBOS.registerWorkflow(
+          async (runId, logs) => DBOS.runStep(() => store.appendRunLogs(runId, logs), { name: "store-append-run-logs" }),
+          { name: "appendRunLogsWorkflow" }
+        );
+        const createArtifact = DBOS.registerWorkflow(
+          async (runId, input) => DBOS.runStep(() => store.createArtifact(runId, input), { name: "store-create-artifact" }),
+          { name: "createArtifactWorkflow" }
+        );
+        const appendInputEvent = DBOS.registerWorkflow(
+          async (runId, input) => DBOS.runStep(() => store.appendInputEvent(runId, input), { name: "store-append-input-event" }),
+          { name: "appendInputEventWorkflow" }
+        );
+        const markInputDelivered = DBOS.registerWorkflow(
+          async (runId, sequence) => DBOS.runStep(() => store.markInputDelivered(runId, sequence), { name: "store-mark-input-delivered" }),
+          { name: "markInputDeliveredWorkflow" }
+        );
+        this.registered = {
+          createTask,
+          retryTask,
+          cancelTask,
+          updateRunStatus,
+          appendRunLogs,
+          createArtifact,
+          appendInputEvent,
+          markInputDelivered
+        };
+      }
+      async launch(options) {
+        DBOS.setConfig({
+          name: options.appName,
+          systemDatabaseUrl: options.systemDatabaseUrl
+        });
+        await DBOS.launch({
+          conductorKey: options.conductorKey,
+          conductorURL: options.conductorUrl
+        });
+      }
+      async shutdown() {
+        await DBOS.shutdown();
+      }
+      async createTask(input) {
+        const handle = await DBOS.startWorkflow(this.registered.createTask)(input);
+        return handle.getResult();
+      }
+      async retryTask(taskId) {
+        const handle = await DBOS.startWorkflow(this.registered.retryTask)(taskId);
+        return handle.getResult();
+      }
+      async cancelTask(taskId) {
+        const handle = await DBOS.startWorkflow(this.registered.cancelTask)(taskId);
+        return handle.getResult();
+      }
+      async updateRunStatus(runId, status, error) {
+        const handle = await DBOS.startWorkflow(this.registered.updateRunStatus)(runId, status, error);
+        return handle.getResult();
+      }
+      async appendRunLogs(runId, logs) {
+        const handle = await DBOS.startWorkflow(this.registered.appendRunLogs)(runId, logs);
+        return handle.getResult();
+      }
+      async createArtifact(runId, input) {
+        const handle = await DBOS.startWorkflow(this.registered.createArtifact)(runId, input);
+        return handle.getResult();
+      }
+      async appendInputEvent(runId, input) {
+        const handle = await DBOS.startWorkflow(this.registered.appendInputEvent)(runId, input);
+        return handle.getResult();
+      }
+      async markInputDelivered(runId, sequence) {
+        const handle = await DBOS.startWorkflow(this.registered.markInputDelivered)(runId, sequence);
+        await handle.getResult();
+      }
+    };
+  }
+});
 
 // ../server/src/index.ts
 import { createServer } from "http";
 import { URL } from "url";
-import { DBOS as DBOS2 } from "@dbos-inc/dbos-sdk";
 import { ZodError } from "zod";
 
 // ../core/src/config.ts
@@ -476,68 +593,37 @@ var PgStore = class {
   }
 };
 
-// ../server/src/workflows.ts
-import { DBOS } from "@dbos-inc/dbos-sdk";
-function registerWorkflows(store) {
-  const createTask = DBOS.registerWorkflow(
-    async (input) => DBOS.runStep(() => store.createTask(input), {
-      name: "store-create-task"
-    }),
-    { name: "createTaskWorkflow" }
-  );
-  const retryTask = DBOS.registerWorkflow(
-    async (taskId) => DBOS.runStep(() => store.retryTask(taskId), {
-      name: "store-retry-task"
-    }),
-    { name: "retryTaskWorkflow" }
-  );
-  const cancelTask = DBOS.registerWorkflow(
-    async (taskId) => DBOS.runStep(() => store.cancelTask(taskId), {
-      name: "store-cancel-task"
-    }),
-    { name: "cancelTaskWorkflow" }
-  );
-  const updateRunStatus = DBOS.registerWorkflow(
-    async (runId, status, error) => DBOS.runStep(() => store.updateRunStatus(runId, status, error), {
-      name: "store-update-run-status"
-    }),
-    { name: "updateRunStatusWorkflow" }
-  );
-  const appendRunLogs = DBOS.registerWorkflow(
-    async (runId, logs) => DBOS.runStep(() => store.appendRunLogs(runId, logs), {
-      name: "store-append-run-logs"
-    }),
-    { name: "appendRunLogsWorkflow" }
-  );
-  const createArtifact = DBOS.registerWorkflow(
-    async (runId, input) => DBOS.runStep(() => store.createArtifact(runId, input), {
-      name: "store-create-artifact"
-    }),
-    { name: "createArtifactWorkflow" }
-  );
-  const appendInputEvent = DBOS.registerWorkflow(
-    async (runId, input) => DBOS.runStep(() => store.appendInputEvent(runId, input), {
-      name: "store-append-input-event"
-    }),
-    { name: "appendInputEventWorkflow" }
-  );
-  const markInputDelivered = DBOS.registerWorkflow(
-    async (runId, sequence) => DBOS.runStep(() => store.markInputDelivered(runId, sequence), {
-      name: "store-mark-input-delivered"
-    }),
-    { name: "markInputDeliveredWorkflow" }
-  );
-  return {
-    createTask,
-    retryTask,
-    cancelTask,
-    updateRunStatus,
-    appendRunLogs,
-    createArtifact,
-    appendInputEvent,
-    markInputDelivered
-  };
-}
+// ../server/src/workflows-vanilla.ts
+var VanillaWorkflows = class {
+  constructor(store) {
+    this.store = store;
+  }
+  store;
+  createTask(input) {
+    return this.store.createTask(input);
+  }
+  retryTask(taskId) {
+    return this.store.retryTask(taskId);
+  }
+  cancelTask(taskId) {
+    return this.store.cancelTask(taskId);
+  }
+  updateRunStatus(runId, status, error) {
+    return this.store.updateRunStatus(runId, status, error);
+  }
+  appendRunLogs(runId, logs) {
+    return this.store.appendRunLogs(runId, logs);
+  }
+  createArtifact(runId, input) {
+    return this.store.createArtifact(runId, input);
+  }
+  appendInputEvent(runId, input) {
+    return this.store.appendInputEvent(runId, input);
+  }
+  markInputDelivered(runId, sequence) {
+    return this.store.markInputDelivered(runId, sequence);
+  }
+};
 
 // ../server/src/validation.ts
 import { z as z2 } from "zod";
@@ -753,22 +839,26 @@ function writeJson(res, statusCode, payload) {
   res.setHeader("content-type", "application/json");
   res.end(json);
 }
+async function buildWorkflows(store, config) {
+  if (process.env.WORKPLANE_USE_DBOS === "true") {
+    const { createDbosWorkflows: createDbosWorkflows2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+    const dbos = createDbosWorkflows2(store);
+    await dbos.launch({
+      appName: process.env.DBOS_APPLICATION_NAME ?? "workplane-server",
+      systemDatabaseUrl: config.databaseUrl,
+      conductorKey: process.env.DBOS_CONDUCTOR_KEY,
+      conductorUrl: process.env.DBOS_CONDUCTOR_URL
+    });
+    return { workflows: dbos, shutdown: () => dbos.shutdown() };
+  }
+  return { workflows: new VanillaWorkflows(store), shutdown: async () => {
+  } };
+}
 async function main() {
   const config = loadServerConfig();
   const pool = getPool(config.databaseUrl);
   const store = new PgStore(pool);
-  const workflows = registerWorkflows(store);
-  const appName = process.env.DBOS_APPLICATION_NAME ?? "workplane-server";
-  const conductorKey = process.env.DBOS_CONDUCTOR_KEY;
-  const conductorUrl = process.env.DBOS_CONDUCTOR_URL;
-  DBOS2.setConfig({
-    name: appName,
-    systemDatabaseUrl: config.databaseUrl
-  });
-  await DBOS2.launch({
-    conductorKey,
-    conductorURL: conductorUrl
-  });
+  const { workflows, shutdown: shutdownWorkflows } = await buildWorkflows(store, config);
   const server = createServer(async (req, res) => {
     try {
       if (!req.url || !req.method) {
@@ -788,13 +878,12 @@ async function main() {
       if (req.method === "POST" && url.pathname === "/tasks") {
         const body = await readJson(req);
         const validated = validateCreateTaskInput(body);
-        const handle = await DBOS2.startWorkflow(workflows.createTask)({
+        const task = await workflows.createTask({
           kind: validated.kind,
           adapter: validated.adapter,
           payload: validated.payload,
           requires: validated.requires ?? []
         });
-        const task = await handle.getResult();
         writeJson(res, 201, task);
         return;
       }
@@ -816,8 +905,7 @@ async function main() {
       }
       if (req.method === "POST" && /^\/tasks\/[^/]+\/retry$/.test(url.pathname)) {
         const taskId = url.pathname.split("/")[2];
-        const handle = await DBOS2.startWorkflow(workflows.retryTask)(taskId);
-        const task = await handle.getResult();
+        const task = await workflows.retryTask(taskId);
         if (!task) {
           writeJson(res, 409, { error: "task is not retryable" });
           return;
@@ -827,8 +915,7 @@ async function main() {
       }
       if (req.method === "POST" && /^\/tasks\/[^/]+\/cancel$/.test(url.pathname)) {
         const taskId = url.pathname.split("/")[2];
-        const handle = await DBOS2.startWorkflow(workflows.cancelTask)(taskId);
-        const task = await handle.getResult();
+        const task = await workflows.cancelTask(taskId);
         if (!task) {
           writeJson(res, 409, { error: "task is not cancellable" });
           return;
@@ -881,8 +968,7 @@ async function main() {
       if (req.method === "POST" && /^\/runs\/[^/]+\/status$/.test(url.pathname)) {
         const runId = url.pathname.split("/")[2];
         const body = await readJson(req);
-        const handle = await DBOS2.startWorkflow(workflows.updateRunStatus)(runId, body.status, body.error);
-        const run = await handle.getResult();
+        const run = await workflows.updateRunStatus(runId, body.status, body.error);
         if (!run) {
           writeJson(res, 404, { error: "run not found" });
           return;
@@ -893,16 +979,14 @@ async function main() {
       if (req.method === "POST" && /^\/runs\/[^/]+\/logs$/.test(url.pathname)) {
         const runId = url.pathname.split("/")[2];
         const body = await readJson(req);
-        const handle = await DBOS2.startWorkflow(workflows.appendRunLogs)(runId, body.logs ?? []);
-        const inserted = await handle.getResult();
+        const inserted = await workflows.appendRunLogs(runId, body.logs ?? []);
         writeJson(res, 200, { inserted });
         return;
       }
       if (req.method === "POST" && /^\/runs\/[^/]+\/artifacts$/.test(url.pathname)) {
         const runId = url.pathname.split("/")[2];
         const body = await readJson(req);
-        const handle = await DBOS2.startWorkflow(workflows.createArtifact)(runId, body);
-        const artifact = await handle.getResult();
+        const artifact = await workflows.createArtifact(runId, body);
         writeJson(res, 201, artifact);
         return;
       }
@@ -919,8 +1003,7 @@ async function main() {
         }
         const body = await readJson(req);
         const validated = validateInputEvent(body);
-        const handle = await DBOS2.startWorkflow(workflows.appendInputEvent)(runId, validated);
-        const event = await handle.getResult();
+        const event = await workflows.appendInputEvent(runId, validated);
         writeJson(res, 201, event);
         return;
       }
@@ -935,8 +1018,7 @@ async function main() {
         const parts = url.pathname.split("/");
         const runId = parts[2];
         const sequence = Number(parts[4]);
-        const handle = await DBOS2.startWorkflow(workflows.markInputDelivered)(runId, sequence);
-        await handle.getResult();
+        await workflows.markInputDelivered(runId, sequence);
         writeJson(res, 200, { ok: true });
         return;
       }
@@ -959,7 +1041,7 @@ async function main() {
 `);
   });
   const shutdown = async () => {
-    await DBOS2.shutdown();
+    await shutdownWorkflows();
     await pool.end();
     server.close();
     process.exit(0);