@gravito/flux 3.0.2 → 4.0.0

package/dist/{chunk-4DXCQ6CL.js → chunk-JUCSCBHA.js}

@@ -1,117 +1,17 @@
 import {
-  BunSQLiteStorage
-} from "./chunk-NAIVO7RR.js";
-
-// src/errors.ts
-var FluxErrorCode = /* @__PURE__ */ ((FluxErrorCode2) => {
-  FluxErrorCode2["WORKFLOW_NOT_FOUND"] = "WORKFLOW_NOT_FOUND";
-  FluxErrorCode2["WORKFLOW_INVALID_INPUT"] = "WORKFLOW_INVALID_INPUT";
-  FluxErrorCode2["WORKFLOW_DEFINITION_CHANGED"] = "WORKFLOW_DEFINITION_CHANGED";
-  FluxErrorCode2["WORKFLOW_NAME_MISMATCH"] = "WORKFLOW_NAME_MISMATCH";
-  FluxErrorCode2["INVALID_STATE_TRANSITION"] = "INVALID_STATE_TRANSITION";
-  FluxErrorCode2["WORKFLOW_NOT_SUSPENDED"] = "WORKFLOW_NOT_SUSPENDED";
-  FluxErrorCode2["INVALID_STEP_INDEX"] = "INVALID_STEP_INDEX";
-  FluxErrorCode2["STEP_TIMEOUT"] = "STEP_TIMEOUT";
-  FluxErrorCode2["STEP_NOT_FOUND"] = "STEP_NOT_FOUND";
-  FluxErrorCode2["CONCURRENT_MODIFICATION"] = "CONCURRENT_MODIFICATION";
-  FluxErrorCode2["EMPTY_WORKFLOW"] = "EMPTY_WORKFLOW";
-  FluxErrorCode2["NO_RECOVERY_ACTION"] = "NO_RECOVERY_ACTION";
-  FluxErrorCode2["INVALID_JSON_POINTER"] = "INVALID_JSON_POINTER";
-  FluxErrorCode2["INVALID_PATH_TRAVERSAL"] = "INVALID_PATH_TRAVERSAL";
-  FluxErrorCode2["CANNOT_REPLACE_ROOT"] = "CANNOT_REPLACE_ROOT";
-  FluxErrorCode2["CANNOT_REMOVE_ROOT"] = "CANNOT_REMOVE_ROOT";
-  return FluxErrorCode2;
-})(FluxErrorCode || {});
-var FluxError = class extends Error {
-  /**
-   * Creates a new FluxError.
-   *
-   * @param message - Human-readable error description.
-   * @param code - Machine-readable error code.
-   * @param context - Additional metadata related to the error.
-   */
-  constructor(message, code, context) {
-    super(message);
-    this.code = code;
-    this.context = context;
-    this.name = "FluxError";
-  }
-};
-function workflowNotFound(id) {
-  return new FluxError(`Workflow not found: ${id}`, "WORKFLOW_NOT_FOUND" /* WORKFLOW_NOT_FOUND */, {
-    workflowId: id
-  });
-}
-function invalidStateTransition(from, to) {
-  return new FluxError(
-    `Invalid state transition: ${from} \u2192 ${to}`,
-    "INVALID_STATE_TRANSITION" /* INVALID_STATE_TRANSITION */,
-    { from, to }
-  );
-}
-function invalidInput(workflowName) {
-  return new FluxError(
-    `Invalid input for workflow "${workflowName}"`,
-    "WORKFLOW_INVALID_INPUT" /* WORKFLOW_INVALID_INPUT */,
-    { workflowName }
-  );
-}
-function workflowNameMismatch(expected, received) {
-  return new FluxError(
-    `Workflow name mismatch: ${received} !== ${expected}`,
-    "WORKFLOW_NAME_MISMATCH" /* WORKFLOW_NAME_MISMATCH */,
-    { expected, received }
-  );
-}
-function workflowDefinitionChanged() {
-  return new FluxError(
-    "Workflow definition changed; operation is not safe",
-    "WORKFLOW_DEFINITION_CHANGED" /* WORKFLOW_DEFINITION_CHANGED */
-  );
-}
-function workflowNotSuspended(status) {
-  return new FluxError(
-    `Workflow is not suspended (status: ${status})`,
-    "WORKFLOW_NOT_SUSPENDED" /* WORKFLOW_NOT_SUSPENDED */,
-    { status }
-  );
-}
-function stepNotFound(step) {
-  return new FluxError(`Step not found: ${step}`, "STEP_NOT_FOUND" /* STEP_NOT_FOUND */, { step });
-}
-function invalidStepIndex(index) {
-  return new FluxError(`Invalid step index: ${index}`, "INVALID_STEP_INDEX" /* INVALID_STEP_INDEX */, { index });
-}
-function emptyWorkflow(workflowName) {
-  return new FluxError(`Workflow "${workflowName}" has no steps`, "EMPTY_WORKFLOW" /* EMPTY_WORKFLOW */, {
-    workflowName
-  });
-}
-function noRecoveryAction(stepName) {
-  return new FluxError(
-    `No recovery action registered for step: ${stepName}`,
-    "NO_RECOVERY_ACTION" /* NO_RECOVERY_ACTION */,
-    { stepName }
-  );
-}
-function invalidJsonPointer(path) {
-  return new FluxError(`Invalid JSON Pointer: ${path}`, "INVALID_JSON_POINTER" /* INVALID_JSON_POINTER */, {
-    path
-  });
-}
-function invalidPathTraversal(segment, current) {
-  return new FluxError(
-    `Cannot access property '${segment}' on ${current}`,
-    "INVALID_PATH_TRAVERSAL" /* INVALID_PATH_TRAVERSAL */,
-    { segment, currentType: typeof current }
-  );
-}
-function cannotReplaceRoot() {
-  return new FluxError("Cannot replace root object", "CANNOT_REPLACE_ROOT" /* CANNOT_REPLACE_ROOT */);
-}
-function cannotRemoveRoot() {
-  return new FluxError("Cannot remove root object", "CANNOT_REMOVE_ROOT" /* CANNOT_REMOVE_ROOT */);
-}
+  BunSQLiteStorage,
+  FluxError,
+  emptyWorkflow,
+  invalidInput,
+  invalidStateTransition,
+  invalidStepIndex,
+  noRecoveryAction,
+  stepNotFound,
+  workflowDefinitionChanged,
+  workflowNameMismatch,
+  workflowNotFound,
+  workflowNotSuspended
+} from "./chunk-UZKSACBE.js";
 
 // src/builder/WorkflowBuilder.ts
 var WorkflowBuilder = class {
@@ -1544,7 +1444,11 @@ function resetHistoryFrom(ctx, startIndex) {
     entry.status = "pending";
     entry.startedAt = void 0;
     entry.completedAt = void 0;
+    entry.suspendedAt = void 0;
+    entry.compensatedAt = void 0;
+    entry.waitingFor = void 0;
     entry.duration = void 0;
+    entry.output = void 0;
     entry.error = void 0;
     entry.retries = 0;
   }
@@ -1954,6 +1858,7 @@ var RollbackManager = class {
       error: originalError.message
     });
     let compensatedCount = 0;
+    let skippedCount = 0;
     for (let i = failedAtIndex - 1; i >= 0; i--) {
       const step = definition.steps[i];
       let execution = currentCtx.history[i];
@@ -1988,11 +1893,36 @@ var RollbackManager = class {
       } catch (err) {
         const error = err instanceof Error ? err : new Error(String(err));
         const action = this.recoveryManager.getAction(step.name);
+        if (action?.type === "retry") {
+          const retryResult = await new CompensationRetryPolicy({
+            ...this.retryPolicy.getConfig(),
+            maxAttempts: action.maxAttempts ?? this.retryPolicy.getConfig().maxAttempts
+          }).execute(async () => {
+            await step.compensate?.(currentCtx);
+          });
+          if (retryResult.success) {
+            execution = { ...execution, status: "compensated", compensatedAt: /* @__PURE__ */ new Date() };
+            currentCtx = updateWorkflowContext(currentCtx, {
+              history: currentCtx.history.map((h, idx) => idx === i ? execution : h)
+            });
+            compensatedCount++;
+            await this.traceEmitter.stepCompensate(currentCtx, step.name, i);
+            currentCtx = await this.persist(currentCtx);
+            continue;
+          }
+        }
         if (action?.type === "skip") {
+          execution = { ...execution, status: "completed", error: error.message };
+          currentCtx = updateWorkflowContext(currentCtx, {
+            history: currentCtx.history.map((h, idx) => idx === i ? execution : h)
+          });
+          currentCtx = await this.persist(currentCtx);
+          skippedCount++;
           continue;
         }
         if (action?.type === "abort") {
           currentCtx = updateWorkflowContext(currentCtx, { status: "compensation_failed" });
+          currentCtx = await this.persist(currentCtx);
           await this.traceEmitter.emit({
             type: "workflow:error",
             timestamp: Date.now(),
@@ -2005,6 +1935,7 @@ var RollbackManager = class {
         }
         await this.recoveryManager.notifyRecoveryNeeded(currentCtx, step.name, error);
         currentCtx = updateWorkflowContext(currentCtx, { status: "compensation_failed" });
+        currentCtx = await this.persist(currentCtx);
         await this.traceEmitter.emit({
           type: "workflow:error",
           timestamp: Date.now(),
@@ -2017,7 +1948,7 @@ var RollbackManager = class {
       }
       currentCtx = await this.persist(currentCtx);
     }
-    if (compensatedCount > 0) {
+    if (compensatedCount > 0 || skippedCount > 0) {
       currentCtx = updateWorkflowContext(currentCtx, { status: "rolled_back" });
       await this.traceEmitter.emit({
         type: "workflow:rollback_complete",
@@ -2712,7 +2643,14 @@ var FluxEngine = class {
     }
     ctx = updateWorkflowContext(ctx, {
       history: ctx.history.map(
-        (h, i) => i === idx ? { ...h, status: "completed", completedAt: /* @__PURE__ */ new Date(), output: payload } : h
+        (h, i) => i === idx ? {
+          ...h,
+          status: "completed",
+          completedAt: /* @__PURE__ */ new Date(),
+          suspendedAt: void 0,
+          waitingFor: void 0,
+          output: payload
+        } : h
       )
     });
     await this.traceEmitter.emit({
@@ -2831,7 +2769,7 @@ var PostgreSQLStorage = class {
    */
   constructor(options = {}) {
     this.options = options;
-    this.tableName = options.tableName ?? "flux_workflows";
+    this.tableName = validateSqlIdentifier(options.tableName ?? "flux_workflows", "tableName");
   }
   /**
    * Initializes the database connection pool and schema.
@@ -3056,20 +2994,36 @@ var PostgreSQLStorage = class {
     await this.pool.query("VACUUM ANALYZE");
   }
 };
+function validateSqlIdentifier(value, field) {
+  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+    throw new FluxError(
+      `Invalid ${field}: "${value}". Only letters, numbers, and underscores are allowed.`,
+      "WORKFLOW_INVALID_INPUT" /* WORKFLOW_INVALID_INPUT */,
+      { field, value }
+    );
+  }
+  return value;
+}
 
 // src/trace/JsonFileTraceSink.ts
-import { appendFile, mkdir, writeFile } from "fs/promises";
+import { mkdir } from "fs/promises";
 import { dirname } from "path";
+import { getDefaultRuntimeAdapter } from "@gravito/core";
 var JsonFileTraceSink = class {
   path;
   ready;
+  fileSink = null;
+  buffer = [];
+  bufferSize;
+  adapter = getDefaultRuntimeAdapter();
   /**
-   * Creates a new JSON file trace sink.
+   * Creates a new JSON file trace sink with buffering support.
    *
    * @param options - Configuration options for the sink.
    */
   constructor(options) {
     this.path = options.path;
+    this.bufferSize = options.bufferSize ?? 50;
     this.ready = this.init(options.reset ?? true);
   }
   /**
@@ -3080,14 +3034,22 @@ var JsonFileTraceSink = class {
    */
   async init(reset) {
     await mkdir(dirname(this.path), { recursive: true });
-    if (reset) {
-      await writeFile(this.path, "", "utf8");
+    if (this.adapter.createFileSink) {
+      this.fileSink = await this.adapter.createFileSink?.(this.path);
+    }
+    if (reset && !this.fileSink) {
+      if (this.adapter.writeFile) {
+        await this.adapter.writeFile(this.path, "");
+      }
+    } else if (reset && this.fileSink) {
+      this.fileSink.write("");
     }
   }
   /**
    * Appends a trace event to the file in NDJSON format.
    *
-   * Waits for initialization to complete before writing.
+   * Events are buffered and written in batches using FileSink
+   * for improved I/O efficiency. Waits for initialization to complete before writing.
    *
    * @param event - The trace event to record.
    * @throws {Error} If writing to the file fails.
@@ -3104,8 +3066,48 @@ var JsonFileTraceSink = class {
    */
   async emit(event) {
     await this.ready;
-    await appendFile(this.path, `${JSON.stringify(event)}
-`, "utf8");
+    const eventLine = `${JSON.stringify(event)}
+`;
+    if (this.fileSink) {
+      this.buffer.push(eventLine);
+      if (this.buffer.length >= this.bufferSize) {
+        await this.flushBuffer();
+      }
+    } else {
+      if (this.adapter.appendFile) {
+        await this.adapter.appendFile(this.path, eventLine);
+      }
+    }
+  }
+  /**
+   * Flushes buffered events to disk.
+   *
+   * This is called automatically when the buffer reaches the configured size.
+   * Can also be called manually to ensure all events are written.
+   *
+   * @throws {Error} If flushing fails.
+   */
+  async flushBuffer() {
+    if (!this.fileSink || this.buffer.length === 0) {
+      return;
+    }
+    const content = this.buffer.join("");
+    this.fileSink.write(content);
+    this.buffer = [];
+    await this.fileSink.flush();
+  }
+  /**
+   * Closes the sink and flushes any remaining buffered events.
+   *
+   * Should be called before process exit to ensure all events are persisted.
+   *
+   * @throws {Error} If closing or flushing fails.
+   */
+  async close() {
+    await this.flushBuffer();
+    if (this.fileSink) {
+      await this.fileSink.end();
+    }
   }
 };
 
@@ -3423,6 +3425,16 @@ var OrbitFlux = class _OrbitFlux {
     };
     this.engine = new FluxEngine(engineConfig);
     core.container.instance(exposeAs, this.engine);
+    const health = core.container.make("health");
+    if (health) {
+      const engine = this.engine;
+      health.register("flux", async () => ({
+        status: engine ? "healthy" : "unhealthy",
+        details: {
+          storage: typeof storage === "string" ? storage : "custom"
+        }
+      }));
+    }
     core.logger.info(
       `[OrbitFlux] Initialized (Storage: ${typeof storage === "string" ? storage : "custom"})`
     );
@@ -3450,22 +3462,6 @@ var OrbitFlux = class _OrbitFlux {
 };
 
 export {
-  FluxErrorCode,
-  FluxError,
-  workflowNotFound,
-  invalidStateTransition,
-  invalidInput,
-  workflowNameMismatch,
-  workflowDefinitionChanged,
-  workflowNotSuspended,
-  stepNotFound,
-  invalidStepIndex,
-  emptyWorkflow,
-  noRecoveryAction,
-  invalidJsonPointer,
-  invalidPathTraversal,
-  cannotReplaceRoot,
-  cannotRemoveRoot,
   WorkflowBuilder,
   createWorkflow,
   BatchExecutor,
@@ -3483,4 +3479,4 @@ export {
   FluxSilentLogger,
   OrbitFlux
 };
-//# sourceMappingURL=chunk-4DXCQ6CL.js.map
+//# sourceMappingURL=chunk-JUCSCBHA.js.map