@gravito/flux 3.0.2 → 3.0.3

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

@@ -1,6 +1,6 @@
 import {
   BunSQLiteStorage
-} from "./chunk-NAIVO7RR.js";
+} from "./chunk-EZGSU6AW.js";
 
 // src/errors.ts
 var FluxErrorCode = /* @__PURE__ */ ((FluxErrorCode2) => {
@@ -1544,7 +1544,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 +1958,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 +1993,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 +2035,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 +2048,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 +2743,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 +2869,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 +3094,34 @@ 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 Error(
+      `Invalid ${field}: "${value}". Only letters, numbers, and underscores are allowed.`
+    );
+  }
+  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 +3132,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 +3164,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();
+    }
   }
 };
 
@@ -3483,4 +3583,4 @@ export {
   FluxSilentLogger,
   OrbitFlux
 };
-//# sourceMappingURL=chunk-4DXCQ6CL.js.map
+//# sourceMappingURL=chunk-M2ZRQRF4.js.map