@classytic/streamline 1.0.0

package/dist/errors-BqunvWPz.mjs

@@ -0,0 +1,129 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/utils/errors.ts
+var errors_exports = /* @__PURE__ */ __exportAll({
+	DataCorruptionError: () => DataCorruptionError,
+	ErrorCode: () => ErrorCode,
+	InvalidStateError: () => InvalidStateError,
+	MaxRetriesExceededError: () => MaxRetriesExceededError,
+	StepNotFoundError: () => StepNotFoundError,
+	StepTimeoutError: () => StepTimeoutError,
+	WorkflowError: () => WorkflowError,
+	WorkflowNotFoundError: () => WorkflowNotFoundError
+});
+/**
+* Custom error classes with rich context for better debugging
+*/
+/**
+* Standardized error codes for programmatic error handling.
+* Use these codes to handle specific error conditions in your application.
+*
+* @example
+* ```typescript
+* try {
+*   await workflow.resume(runId);
+* } catch (err) {
+*   if (err.code === ErrorCode.WORKFLOW_NOT_FOUND) {
+*     // Handle missing workflow
+*   }
+* }
+* ```
+*/
+const ErrorCode = {
+	WORKFLOW_NOT_FOUND: "WORKFLOW_NOT_FOUND",
+	WORKFLOW_ALREADY_COMPLETED: "WORKFLOW_ALREADY_COMPLETED",
+	WORKFLOW_CANCELLED: "WORKFLOW_CANCELLED",
+	STEP_NOT_FOUND: "STEP_NOT_FOUND",
+	STEP_TIMEOUT: "STEP_TIMEOUT",
+	STEP_FAILED: "STEP_FAILED",
+	INVALID_STATE: "INVALID_STATE",
+	INVALID_TRANSITION: "INVALID_TRANSITION",
+	DATA_CORRUPTION: "DATA_CORRUPTION",
+	VALIDATION_ERROR: "VALIDATION_ERROR",
+	MAX_RETRIES_EXCEEDED: "MAX_RETRIES_EXCEEDED",
+	EXECUTION_ABORTED: "EXECUTION_ABORTED"
+};
+var WorkflowError = class extends Error {
+	code;
+	constructor(message, code, context) {
+		super(message);
+		this.context = context;
+		this.name = "WorkflowError";
+		this.code = code;
+	}
+	toString() {
+		const contextStr = Object.entries(this.context).map(([key, value]) => `${key}=${value}`).join(", ");
+		return `${this.name} [${this.code}]: ${this.message} (${contextStr})`;
+	}
+};
+var StepNotFoundError = class extends WorkflowError {
+	constructor(stepId, workflowId, availableSteps) {
+		super(`Step "${stepId}" not found in workflow "${workflowId}". Available steps: ${availableSteps.join(", ")}`, ErrorCode.STEP_NOT_FOUND, {
+			stepId,
+			workflowId,
+			availableSteps
+		});
+		this.name = "StepNotFoundError";
+	}
+};
+var WorkflowNotFoundError = class extends WorkflowError {
+	constructor(runId) {
+		super(`Workflow run "${runId}" not found in database`, ErrorCode.WORKFLOW_NOT_FOUND, { runId });
+		this.name = "WorkflowNotFoundError";
+	}
+};
+var InvalidStateError = class extends WorkflowError {
+	constructor(action, currentState, expectedStates, context) {
+		super(`Cannot ${action} - workflow is in state "${currentState}". Expected one of: ${expectedStates.join(", ")}`, ErrorCode.INVALID_STATE, {
+			action,
+			currentState,
+			expectedStates,
+			...context
+		});
+		this.name = "InvalidStateError";
+	}
+};
+var StepTimeoutError = class extends WorkflowError {
+	constructor(stepId, timeoutMs, runId) {
+		super(`Step "${stepId}" exceeded timeout of ${timeoutMs}ms`, ErrorCode.STEP_TIMEOUT, {
+			stepId,
+			timeoutMs,
+			runId
+		});
+		this.name = "StepTimeoutError";
+	}
+};
+var DataCorruptionError = class extends WorkflowError {
+	constructor(reason, context) {
+		super(`Data corruption detected: ${reason}`, ErrorCode.DATA_CORRUPTION, context);
+		this.name = "DataCorruptionError";
+	}
+};
+var MaxRetriesExceededError = class extends WorkflowError {
+	constructor(stepId, attempts, runId) {
+		super(`Step "${stepId}" failed after ${attempts} attempts`, ErrorCode.MAX_RETRIES_EXCEEDED, {
+			stepId,
+			attempts,
+			runId
+		});
+		this.name = "MaxRetriesExceededError";
+	}
+};
+
+//#endregion
+export { StepNotFoundError as a, WorkflowNotFoundError as c, MaxRetriesExceededError as i, errors_exports as l, ErrorCode as n, StepTimeoutError as o, InvalidStateError as r, WorkflowError as s, DataCorruptionError as t };

package/dist/events-B5aTz7kD.mjs

@@ -0,0 +1,28 @@
+import { EventEmitter } from "events";
+
+//#region src/core/events.ts
+/**
+* Type-safe event bus with explicit payload types
+*/
+var WorkflowEventBus = class extends EventEmitter {
+	emit(event, payload) {
+		return super.emit(event, payload);
+	}
+	on(event, listener) {
+		return super.on(event, listener);
+	}
+	once(event, listener) {
+		return super.once(event, listener);
+	}
+	off(event, listener) {
+		return super.off(event, listener);
+	}
+};
+/**
+* Global event bus for cross-container event aggregation.
+* Use with createContainer({ eventBus: 'global' }) for telemetry integration.
+*/
+const globalEventBus = new WorkflowEventBus();
+
+//#endregion
+export { globalEventBus as n, WorkflowEventBus as t };

package/dist/events-C0sZINZq.d.mts

@@ -0,0 +1,92 @@
+import { EventEmitter } from "events";
+
+//#region src/core/events.d.ts
+/**
+ * Typed event payloads for type-safe event handling
+ */
+interface BaseEventPayload {
+  runId: string;
+  timestamp?: Date;
+}
+interface StepEventPayload extends BaseEventPayload {
+  stepId: string;
+  attempt?: number;
+}
+interface StepCompletedPayload extends StepEventPayload {
+  data?: unknown;
+}
+interface StepFailedPayload extends StepEventPayload {
+  error: Error;
+}
+interface StepRetryPayload extends StepEventPayload {
+  maxRetries: number;
+  retryAfter: Date;
+}
+interface WorkflowCompletedPayload extends BaseEventPayload {
+  data?: unknown;
+}
+interface WorkflowFailedPayload extends BaseEventPayload {
+  error: Error | {
+    message: string;
+    code?: string;
+  };
+}
+interface WorkflowResumedPayload extends BaseEventPayload {
+  stepId?: string;
+  data?: unknown;
+}
+interface EngineErrorPayload {
+  runId?: string;
+  error: Error;
+  context: string;
+}
+/**
+ * Event name to payload type mapping
+ */
+interface EventPayloadMap {
+  'step:started': StepEventPayload;
+  'step:completed': StepCompletedPayload;
+  'step:failed': StepFailedPayload;
+  'step:waiting': StepEventPayload & {
+    data?: unknown;
+  };
+  'step:skipped': StepEventPayload;
+  'step:retry-scheduled': StepRetryPayload;
+  'workflow:started': BaseEventPayload;
+  'workflow:completed': WorkflowCompletedPayload;
+  'workflow:failed': WorkflowFailedPayload;
+  'workflow:waiting': BaseEventPayload & {
+    data?: unknown;
+  };
+  'workflow:resumed': WorkflowResumedPayload;
+  'workflow:cancelled': BaseEventPayload;
+  'workflow:recovered': BaseEventPayload;
+  'workflow:retry': BaseEventPayload;
+  'engine:error': EngineErrorPayload;
+  'scheduler:error': EngineErrorPayload;
+  'scheduler:circuit-open': {
+    error: Error;
+    context: string;
+  };
+}
+type WorkflowEventName = keyof EventPayloadMap;
+/**
+ * Type-safe event bus with explicit payload types
+ */
+declare class WorkflowEventBus extends EventEmitter {
+  emit<K extends WorkflowEventName>(event: K, payload: EventPayloadMap[K]): boolean;
+  emit(event: string, payload: unknown): boolean;
+  on<K extends WorkflowEventName>(event: K, listener: (payload: EventPayloadMap[K]) => void): this;
+  on(event: string, listener: (payload: unknown) => void): this;
+  once<K extends WorkflowEventName>(event: K, listener: (payload: EventPayloadMap[K]) => void): this;
+  once(event: string, listener: (payload: unknown) => void): this;
+  off<K extends WorkflowEventName>(event: K, listener: (payload: EventPayloadMap[K]) => void): this;
+  off(event: string, listener: (payload: unknown) => void): this;
+}
+/**
+ * Global event bus for cross-container event aggregation.
+ * Use with createContainer({ eventBus: 'global' }) for telemetry integration.
+ */
+declare const globalEventBus: WorkflowEventBus;
+//#endregion
+export { WorkflowEventName as n, globalEventBus as r, WorkflowEventBus as t };