yieldstar 0.1.0-alpha.0 → 0.1.3

package/dist/index.js

@@ -25,8 +25,56 @@ function createLocalSdk(workflowRouter, invoker) {
   };
 }
 // src/exports/sdk-http.ts
-import { deserializeError, isErrorLike } from "serialize-error";
+import { deserializeError as deserializeError2, isErrorLike as isErrorLike2 } from "serialize-error";
 import { randomUUID as randomUUID2 } from "crypto";
+
+// src/internal/serialise.ts
+import {
+  StepDelay,
+  StepError,
+  StepResult,
+  WorkflowResult
+} from "@yieldstar/core";
+import { isErrorLike, serializeError, deserializeError } from "serialize-error";
+function errorWithOriginalStack(error, fn) {
+  const err = new Error(error.message);
+  Error.captureStackTrace(err, fn);
+  err.stack = error.stack;
+  throw err;
+}
+function serializeStepResponse(data) {
+  const replaceErrors = (key, value) => {
+    if (value instanceof Error) {
+      return serializeError(value);
+    }
+    return value;
+  };
+  return JSON.stringify(data, replaceErrors);
+}
+function deserializeStepResponse(jsonString) {
+  const reviveErrors = (key, value) => {
+    if (isErrorLike(value)) {
+      return deserializeError(value);
+    }
+    return value;
+  };
+  const stepResponse = JSON.parse(jsonString, reviveErrors);
+  switch (stepResponse.type) {
+    case "step-error":
+      const { err, ...params } = stepResponse;
+      return new StepError(stepResponse.err, params);
+    case "step-delay":
+      return new StepDelay(stepResponse.resumeIn);
+    case "step-result":
+      return new StepResult(stepResponse.result);
+    case "workflow-result":
+      return new WorkflowResult(stepResponse.result);
+    default:
+      throw new Error("Unknown step result type: " + stepResponse.type);
+  }
+}
+
+// src/exports/sdk-http.ts
 function createHttpSdkFactory(workflowRouter) {
   return (params) => {
     return {
@@ -56,8 +104,8 @@ function createHttpSdkFactory(workflowRouter) {
           body: JSON.stringify({ executionId })
         });
         const json = await result.json();
-        if (isErrorLike(json)) {
-          throw deserializeError(json);
+        if (isErrorLike2(json)) {
+          throw errorWithOriginalStack(deserializeError2(json), this.triggerAndWait);
         }
         return json;
       }
@@ -84,46 +132,6 @@ var isIterable = (i) => {
   return typeof i === "object" && i != null && Symbol.iterator in i;
 };
 
-// src/internal/serialise.ts
-import { serializeError, deserializeError as deserializeError2, isErrorLike as isErrorLike2 } from "serialize-error";
-import {
-  StepDelay,
-  StepError,
-  StepResult,
-  WorkflowResult
-} from "@yieldstar/core";
-function serialize(data) {
-  const replaceErrors = (key, value) => {
-    if (value instanceof Error) {
-      return serializeError(value);
-    }
-    return value;
-  };
-  return JSON.stringify(data, replaceErrors);
-}
-function deserialize(jsonString) {
-  const reviveErrors = (key, value) => {
-    if (isErrorLike2(value)) {
-      return deserializeError2(value);
-    }
-    return value;
-  };
-  const stepResponse = JSON.parse(jsonString, reviveErrors);
-  switch (stepResponse.type) {
-    case "step-error":
-      const { err, ...params } = stepResponse;
-      return new StepError(stepResponse.err, params);
-    case "step-delay":
-      return new StepDelay(stepResponse.resumeIn);
-    case "step-result":
-      return new StepResult(stepResponse.result);
-    case "workflow-result":
-      return new WorkflowResult(stepResponse.result);
-    default:
-      throw new Error("Unknown step result type: " + stepResponse.type);
-  }
-}
-
 // src/internal/step-runner.ts
 import {
   StepKey,
@@ -132,6 +140,7 @@ import {
   StepDelay as StepDelay2,
   StepCacheCheck
 } from "@yieldstar/core";
+var stepRunner = { run, delay, poll };
 async function* run(arg1, arg2) {
   let key = null;
   let fn;
@@ -209,7 +218,6 @@ async function* poll(arg1, arg2, arg3) {
     yield* run(task);
   }
 }
-var stepRunner = { run, delay, poll };
 
 // src/exports/workflow.ts
 import {
@@ -224,8 +232,8 @@ import {
 } from "@yieldstar/core";
 function createWorkflow(workflowFn) {
   return async function* workflowGenerator(params) {
-    const workflowIterator = workflowFn(stepRunner);
-    const { executionId, heapClient } = params;
+    const { executionId, heapClient, logger } = params;
+    const workflowIterator = workflowFn(stepRunner, logger);
     let keylessStepIndex = -1;
     let iteratorResult = null;
     let nextIteratorResult = null;
@@ -246,7 +254,7 @@ function createWorkflow(workflowFn) {
         stepKey = iteratorResult.value.key;
       } else {
         keylessStepIndex++;
-        stepKey = `\$\$step-index-${keylessStepIndex}\$\$`;
+        stepKey = `$$step-index-${keylessStepIndex}$$`;
       }
       let cached = await heapClient.readStep({
         executionId,
@@ -268,14 +276,15 @@ function createWorkflow(workflowFn) {
         stepResponse = iteratorResult.value;
       }
       if (stepResponse instanceof StepCacheCheck2) {
-        const cachedResponse = cached ? deserialize(cached.stepResponseJson) : null;
+        const cachedResponse = cached ? deserializeStepResponse(cached.stepResponseJson) : null;
         iteratorResult = await workflowIterator.next(cachedResponse);
         stepResponse = iteratorResult.value;
       } else if (!(stepResponse instanceof WorkflowResult2)) {
         throw new Error("Step runners must yield a CacheCheck object");
       }
       if (isIterable(stepResponse)) {
-        console.log("[ERR] Steps must be yielded using yield*\n");
+        console.log(`[ERR] Steps must be yielded using yield*
+`);
         stepResponse = new StepInvalid;
       } else if (!(stepResponse instanceof StepResponse3)) {
         console.log(`[ERR] Iterators should yield a StepResponse. Got ${JSON.stringify(stepResponse)}`);
@@ -288,7 +297,7 @@ function createWorkflow(workflowFn) {
           stepKey,
           stepAttempt,
           stepDone: !needsRetry,
-          stepResponseJson: serialize(stepResponse)
+          stepResponseJson: serializeStepResponse(stepResponse)
         });
       }
       if (stepResponse instanceof WorkflowResult2) {

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "yieldstar",
-  "version": "0.1.0-alpha.0",
+  "version": "0.1.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "src/index.ts",
+  "scripts": {
+    "build": "bun build src/index.ts --outfile dist/index.js --target bun --packages=external"
+  },
   "dependencies": {
     "serialize-error": "^11.0.3"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@yieldstar/core": "0.1.0"
-  },
-  "scripts": {
-    "build": "bun build src/index.ts --outfile dist/index.js --target bun --packages=external"
+    "@yieldstar/core": "workspace:*",
+    "pino": "^9.6.0"
   }
-}
+}

package/src/exports/sdk-http.ts

@@ -4,6 +4,7 @@ import type {
 } from "@yieldstar/core";
 import { deserializeError, isErrorLike } from "serialize-error";
 import { randomUUID } from "node:crypto";
+import { errorWithOriginalStack } from "../internal/serialise";
 
 export function createHttpSdkFactory<W extends WorkflowRouter>(
   workflowRouter: W
@@ -57,7 +58,10 @@ export function createHttpSdkFactory<W extends WorkflowRouter>(
         const json = await result.json();
 
         if (isErrorLike(json)) {
-          throw deserializeError(json);
+          throw errorWithOriginalStack(
+            deserializeError(json),
+            this.triggerAndWait
+          );
         }
 
         return json as Promise<WorkflowGeneratorReturnType<W[K]>>;

package/src/exports/workflow.ts

@@ -1,7 +1,11 @@
+import type { Logger } from "pino";
 import type { WorkflowGenerator } from "@yieldstar/core";
 import type { StepRunner } from "../internal/step-runner";
 import { isIterable } from "../internal/utils";
-import { deserialize, serialize } from "../internal/serialise";
+import {
+  deserializeStepResponse,
+  serializeStepResponse,
+} from "../internal/serialise";
 import { stepRunner } from "../internal/step-runner";
 import {
   StepResponse,
@@ -14,7 +18,10 @@ import {
   WorkflowResult,
 } from "@yieldstar/core";
 
-export type WorkflowFn<T> = (step: StepRunner) => AsyncGenerator<any, T>;
+export type WorkflowFn<T> = (
+  step: StepRunner,
+  logger: Logger
+) => AsyncGenerator<any, T>;
 
 export function createWorkflow<T>(
   workflowFn: WorkflowFn<T>
@@ -25,8 +32,8 @@ export function createWorkflow<T>(
    * @yields {StepResponse}
    */
   return async function* workflowGenerator(params) {
-    const workflowIterator = workflowFn(stepRunner);
-    const { executionId, heapClient } = params;
+    const { executionId, heapClient, logger } = params;
+    const workflowIterator = workflowFn(stepRunner, logger);
 
     let keylessStepIndex = -1;
     let iteratorResult: IteratorResult<any> | null = null;
@@ -115,7 +122,7 @@ export function createWorkflow<T>(
        */
       if (stepResponse instanceof StepCacheCheck) {
         const cachedResponse = cached
-          ? deserialize(cached.stepResponseJson)
+          ? deserializeStepResponse(cached.stepResponseJson)
           : null;
         iteratorResult = await workflowIterator.next(cachedResponse);
         stepResponse = iteratorResult.value;
@@ -159,7 +166,7 @@ export function createWorkflow<T>(
           stepKey,
           stepAttempt,
           stepDone: !needsRetry,
-          stepResponseJson: serialize(stepResponse),
+          stepResponseJson: serializeStepResponse(stepResponse),
         });
       }
 

package/src/internal/serialise.ts

@@ -1,4 +1,3 @@
-import { serializeError, deserializeError, isErrorLike } from "serialize-error";
 import {
   StepDelay,
   StepError,
@@ -6,8 +5,16 @@ import {
   StepResponse,
   WorkflowResult,
 } from "@yieldstar/core";
+import { isErrorLike, serializeError, deserializeError } from "serialize-error";
 
-export function serialize(data: StepResponse): string {
+export function errorWithOriginalStack(error: Error, fn: Function) {
+  const err = new Error(error.message);
+  Error.captureStackTrace(err, fn);
+  err.stack = error.stack;
+  throw err;
+}
+
+export function serializeStepResponse(data: StepResponse): string {
   const replaceErrors = (key: string, value: any) => {
     if (value instanceof Error) {
       return serializeError(value);
@@ -18,7 +25,7 @@ export function serialize(data: StepResponse): string {
   return JSON.stringify(data, replaceErrors);
 }
 
-export function deserialize(jsonString: string): StepResponse {
+export function deserializeStepResponse(jsonString: string): StepResponse {
   const reviveErrors = (key: string, value: any) => {
     if (isErrorLike(value)) {
       return deserializeError(value);