@brandboostinggmbh/observable-workflows 0.20.0-beta.4 → 0.20.0-beta.6

package/dist/index.d.ts

@@ -14,14 +14,15 @@ declare function createStepContext(context: StepContextOptions): Promise<{
  * This function is idempotent and can be safely run multiple times.
  *
  * @param db - D1Database instance
+ * @param retryConfig - Optional retry configuration for D1 operations
  */
-declare function ensureTables(db: D1Database): Promise<void>;
+declare function ensureTables(db: D1Database, retryConfig?: RetryConfig): Promise<void>;
 //#endregion
 //#region src/observableWorkflows/helperFunctions.d.ts
 /**
  * Configuration for retry behavior on D1 operations
  */
-interface RetryConfig$1 {
+interface RetryConfig {
   /** Maximum number of retry attempts (default: 3) */
   maxAttempts?: number;
   /** Initial delay in milliseconds (default: 100) */
@@ -49,7 +50,7 @@ interface RetryConfig$1 {
  * )
  * ```
  */
-declare function retryD1Operation<T>(operation: () => Promise<T>, config?: RetryConfig$1): Promise<T>;
+declare function retryD1Operation<T>(operation: () => Promise<T>, config?: RetryConfig): Promise<T>;
 declare function finalizeWorkflowRecord(options: InternalWorkflowContextOptions, {
   workflowStatus,
   endTime,
@@ -61,43 +62,8 @@ declare function finalizeWorkflowRecord(options: InternalWorkflowContextOptions,
   instanceId: string;
   result?: any;
 }): Promise<D1Result<Record<string, unknown>>>;
-/**
- * Insert a new workflow record into the database.
- * Optionally creates workflow dependencies atomically in the same transaction.
- *
- * @example
- * ```typescript
- * // Create a workflow with dependencies
- * await insertWorkflowRecord(context, {
- *   instanceId: 'workflow-c',
- *   workflowType: 'process-data',
- *   workflowName: 'Data Processing',
- *   workflowMetadata: {},
- *   input: { data: 'value' },
- *   workflowStatus: 'pending',
- *   startTime: Date.now(),
- *   tenantId: 'tenant-1',
- *   dependencies: [
- *     { instanceId: 'workflow-a' },
- *     { instanceId: 'workflow-b' }
- *   ] // This workflow depends on A and B
- * })
- * ```
- */
-declare function insertWorkflowRecord(options: InternalWorkflowContextOptions, {
-  instanceId,
-  workflowType,
-  workflowName,
-  workflowMetadata,
-  input,
-  workflowStatus,
-  startTime,
-  endTime,
-  parentInstanceId,
-  tenantId,
-  triggerId,
-  dependencies
-}: {
+/** Parameters for preparing workflow insert statements */
+interface PrepareWorkflowInsertParams {
   /** Unique identifier for this workflow instance */
   instanceId: string;
   /** Type/category of the workflow */
@@ -122,11 +88,36 @@ declare function insertWorkflowRecord(options: InternalWorkflowContextOptions, {
   triggerId?: string | null;
   /**
    * Optional array of workflow dependencies that this workflow depends on.
-   * When provided, dependency relationships are created atomically with the workflow insert.
-   * This ensures that the workflow and all its dependencies are created in a single transaction.
+   * When provided, dependency insert statements are included in the returned statements array.
    */
   dependencies?: Array<WorkflowDependency>;
-}): Promise<{
+}
+/** Result from preparing workflow insert statements */
+
+/**
+ * Insert a new workflow record into the database.
+ * Optionally creates workflow dependencies atomically in the same transaction.
+ *
+ * @example
+ * ```typescript
+ * // Create a workflow with dependencies
+ * await insertWorkflowRecord(context, {
+ *   instanceId: 'workflow-c',
+ *   workflowType: 'process-data',
+ *   workflowName: 'Data Processing',
+ *   workflowMetadata: {},
+ *   input: { data: 'value' },
+ *   workflowStatus: 'pending',
+ *   startTime: Date.now(),
+ *   tenantId: 'tenant-1',
+ *   dependencies: [
+ *     { instanceId: 'workflow-a' },
+ *     { instanceId: 'workflow-b' }
+ *   ] // This workflow depends on A and B
+ * })
+ * ```
+ */
+declare function insertWorkflowRecord(options: InternalWorkflowContextOptions, params: PrepareWorkflowInsertParams): Promise<{
   success: boolean;
   meta: any;
 }>;
@@ -231,6 +222,7 @@ declare function workflowTableRowToWorkflowRun({
 }): Promise<WorkflowRun>;
 declare function updateWorkflowName(context: {
   D1: D1Database;
+  retryConfig?: RetryConfig;
 }, instanceId: string, newWorkflowName: string): Promise<D1Result<Record<string, unknown>>>;
 /**
  * Update workflow fields by instanceId. Only provided fields will be updated.
@@ -441,6 +433,8 @@ type StepContextOptions = {
   reuseSuccessfulSteps?: boolean;
   /** Optional external blob storage for large data that exceeds D1 size limits */
   externalBlobStorage?: ExternalBlobStorage;
+  /** Optional retry configuration for D1 operations */
+  retryConfig?: RetryConfig;
 };
 type ConsoleWrapper = {
   log: (message?: any, ...optionalParams: any[]) => void;
@@ -637,18 +631,6 @@ type ExternalBlobStorage = {
   get: (id: string) => Promise<string>;
   delete: (...keys: string[]) => Promise<number>;
 };
-type RetryConfig = {
-  /** Maximum number of retry attempts (default: 3) */
-  maxAttempts?: number;
-  /** Initial delay in milliseconds (default: 100) */
-  initialDelayMs?: number;
-  /** Maximum delay in milliseconds (default: 5000) */
-  maxDelayMs?: number;
-  /** Multiplier for exponential backoff (default: 2) */
-  backoffMultiplier?: number;
-  /** Whether to add jitter to delays (default: true) */
-  useJitter?: boolean;
-};
 type WorkflowContextOptions = {
   D1: D1Database;
   idFactory?: () => string;
@@ -774,6 +756,7 @@ declare const createCleanupManager: (context: {
   tenantId: string;
   serializer?: Serializer;
   externalBlobStorage?: ExternalBlobStorage;
+  retryConfig?: RetryConfig;
 }) => {
   countAffectedWorkflows: (config: DeleteConfig, limit: number) => Promise<{
     count: number;
@@ -820,6 +803,7 @@ declare const createLogAccessor: (context: {
   tenantId: string;
   serializer?: Serializer;
   externalBlobStorage?: ExternalBlobStorage;
+  retryConfig?: RetryConfig;
 }) => {
   listSteps: {
     (limit: number, offset: number, instanceId?: string): Promise<Step[]>;

package/dist/index.js

@@ -2,8 +2,8 @@
 /**
 * Detect the current schema version for each table
 */
-async function detectSchemaVersion(db) {
-	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first());
+async function detectSchemaVersion(db, retryConfig) {
+	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first(), retryConfig);
 	let workflowTable = "missing";
 	if (workflowTableInfo) {
 		const hasInputRef = workflowTableInfo.sql.includes("inputRef");
@@ -16,7 +16,7 @@ async function detectSchemaVersion(db) {
 		else if (!hasInputRef && inputHasNotNull) workflowTable = "v1";
 		else workflowTable = "v1";
 	}
-	const stepTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='StepTable'`).first());
+	const stepTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='StepTable'`).first(), retryConfig);
 	let stepTable = "missing";
 	if (stepTableInfo) {
 		const hasResultRef = stepTableInfo.sql.includes("resultRef");
@@ -26,7 +26,7 @@ async function detectSchemaVersion(db) {
 		else if (hasResultRef && hasErrorRef) stepTable = "v2";
 		else stepTable = "v1";
 	}
-	const logTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='LogTable'`).first());
+	const logTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='LogTable'`).first(), retryConfig);
 	let logTable = "missing";
 	if (logTableInfo) {
 		const hasStepTableCascadeFK = logTableInfo.sql.includes("FOREIGN KEY (instanceId, stepName) REFERENCES StepTable(instanceId, stepName) ON DELETE CASCADE");
@@ -34,7 +34,7 @@ async function detectSchemaVersion(db) {
 		if (hasStepTableCascadeFK && hasWorkflowTableFK) logTable = "v5";
 		else logTable = "v1";
 	}
-	const workflowPropertiesInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowProperties'`).first());
+	const workflowPropertiesInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowProperties'`).first(), retryConfig);
 	let workflowProperties = "missing";
 	if (workflowPropertiesInfo) workflowProperties = "v1";
 	const workflowDependenciesInfo = await db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowDependencies'`).first();
@@ -52,8 +52,8 @@ async function detectSchemaVersion(db) {
 * Migrate WorkflowTable from V1 to V2 schema
 * Adds inputRef column and makes input nullable
 */
-async function migrateWorkflowTableV1ToV2(db) {
-	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first());
+async function migrateWorkflowTableV1ToV2(db, retryConfig) {
+	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first(), retryConfig);
 	const hasInputRef = workflowTableInfo.sql.includes("inputRef");
 	const inputHasNotNull = workflowTableInfo.sql.includes("input TEXT NOT NULL");
 	if (!hasInputRef || inputHasNotNull) await retryD1Operation(() => db.batch([
@@ -78,14 +78,14 @@ async function migrateWorkflowTableV1ToV2(db) {
         FROM WorkflowTable`),
 		db.prepare(`DROP TABLE WorkflowTable`),
 		db.prepare(`ALTER TABLE WorkflowTable_new RENAME TO WorkflowTable`)
-	]));
+	]), retryConfig);
 }
 /**
 * Migrate WorkflowTable from V2/V3 to V4 schema
 * Adds triggerId column with UNIQUE constraint
 */
-async function migrateWorkflowTableV2V3ToV4(db) {
-	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first());
+async function migrateWorkflowTableV2V3ToV4(db, retryConfig) {
+	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first(), retryConfig);
 	const hasTriggerId = workflowTableInfo.sql.includes("triggerId");
 	if (!hasTriggerId) await retryD1Operation(() => db.batch([
 		db.prepare(`CREATE TABLE WorkflowTable_new (
@@ -111,21 +111,21 @@ async function migrateWorkflowTableV2V3ToV4(db) {
         FROM WorkflowTable`),
 		db.prepare(`DROP TABLE WorkflowTable`),
 		db.prepare(`ALTER TABLE WorkflowTable_new RENAME TO WorkflowTable`)
-	]));
+	]), retryConfig);
 }
 /**
 * Migrate WorkflowTable from V4 to V6 schema
 * Adds result and resultRef columns for external storage support
 */
-async function migrateWorkflowTableV4ToV6(db) {
-	const workflowTableInfo = await db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first();
+async function migrateWorkflowTableV4ToV6(db, retryConfig) {
+	const workflowTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='WorkflowTable'`).first(), retryConfig);
 	const hasResultRef = workflowTableInfo.sql.includes("resultRef");
-	if (!hasResultRef) await db.batch([db.prepare(`ALTER TABLE WorkflowTable ADD COLUMN result TEXT`), db.prepare(`ALTER TABLE WorkflowTable ADD COLUMN resultRef TEXT`)]);
+	if (!hasResultRef) await retryD1Operation(() => db.batch([db.prepare(`ALTER TABLE WorkflowTable ADD COLUMN result TEXT`), db.prepare(`ALTER TABLE WorkflowTable ADD COLUMN resultRef TEXT`)]), retryConfig);
 }
 /**
 * Create or migrate WorkflowTable to the latest schema
 */
-async function migrateWorkflowTable(db, currentVersion) {
+async function migrateWorkflowTable(db, currentVersion, retryConfig) {
 	if (currentVersion === "missing") {
 		await retryD1Operation(() => db.prepare(`CREATE TABLE WorkflowTable (
           instanceId TEXT NOT NULL,
@@ -144,29 +144,29 @@ async function migrateWorkflowTable(db, currentVersion) {
           triggerId TEXT,
           PRIMARY KEY (instanceId),
           UNIQUE (triggerId)
-        )`).run());
+        )`).run(), retryConfig);
 		return;
 	}
 	if (currentVersion === "v1") {
-		await migrateWorkflowTableV1ToV2(db);
-		await migrateWorkflowTableV2V3ToV4(db);
-		await migrateWorkflowTableV4ToV6(db);
+		await migrateWorkflowTableV1ToV2(db, retryConfig);
+		await migrateWorkflowTableV2V3ToV4(db, retryConfig);
+		await migrateWorkflowTableV4ToV6(db, retryConfig);
 		return;
 	}
 	if (currentVersion === "v2") {
-		await migrateWorkflowTableV2V3ToV4(db);
-		await migrateWorkflowTableV4ToV6(db);
+		await migrateWorkflowTableV2V3ToV4(db, retryConfig);
+		await migrateWorkflowTableV4ToV6(db, retryConfig);
 		return;
 	}
 	if (currentVersion === "v4") {
-		await migrateWorkflowTableV4ToV6(db);
+		await migrateWorkflowTableV4ToV6(db, retryConfig);
 		return;
 	}
 }
 /**
 * Create or migrate StepTable to the latest schema
 */
-async function migrateStepTable(db, currentVersion) {
+async function migrateStepTable(db, currentVersion, retryConfig) {
 	if (currentVersion === "missing") {
 		await retryD1Operation(() => db.prepare(`CREATE TABLE StepTable (
           instanceId TEXT NOT NULL,
@@ -182,21 +182,21 @@ async function migrateStepTable(db, currentVersion) {
           tenantId TEXT NOT NULL,
           PRIMARY KEY (instanceId, stepName),
           FOREIGN KEY (instanceId) REFERENCES WorkflowTable(instanceId) ON DELETE CASCADE
-        )`).run());
+        )`).run(), retryConfig);
 		return;
 	}
 	if (currentVersion === "v1") {
-		const stepTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='StepTable'`).first());
+		const stepTableInfo = await retryD1Operation(() => db.prepare(`SELECT sql FROM sqlite_master WHERE type='table' AND name='StepTable'`).first(), retryConfig);
 		const hasResultRef = stepTableInfo.sql.includes("resultRef");
 		const hasErrorRef = stepTableInfo.sql.includes("errorRef");
-		if (!hasResultRef) await retryD1Operation(() => db.prepare(`ALTER TABLE StepTable ADD COLUMN resultRef TEXT`).run());
-		if (!hasErrorRef) await retryD1Operation(() => db.prepare(`ALTER TABLE StepTable ADD COLUMN errorRef TEXT`).run());
+		if (!hasResultRef) await retryD1Operation(() => db.prepare(`ALTER TABLE StepTable ADD COLUMN resultRef TEXT`).run(), retryConfig);
+		if (!hasErrorRef) await retryD1Operation(() => db.prepare(`ALTER TABLE StepTable ADD COLUMN errorRef TEXT`).run(), retryConfig);
 	}
 }
 /**
 * Create or migrate LogTable to the latest schema
 */
-async function migrateLogTable(db, currentVersion) {
+async function migrateLogTable(db, currentVersion, retryConfig) {
 	if (currentVersion === "missing") {
 		await retryD1Operation(() => db.prepare(`CREATE TABLE LogTable (
           instanceId TEXT NOT NULL,
@@ -208,14 +208,14 @@ async function migrateLogTable(db, currentVersion) {
           tenantId TEXT NOT NULL,
           FOREIGN KEY (instanceId, stepName) REFERENCES StepTable(instanceId, stepName) ON DELETE CASCADE DEFERRABLE INITIALLY DEFERRED,
           FOREIGN KEY (instanceId) REFERENCES WorkflowTable(instanceId) ON DELETE CASCADE
-        )`).run());
+        )`).run(), retryConfig);
 		return;
 	}
 }
 /**
 * Create or migrate WorkflowProperties table to the latest schema
 */
-async function migrateWorkflowPropertiesTable(db, currentVersion) {
+async function migrateWorkflowPropertiesTable(db, currentVersion, retryConfig) {
 	if (currentVersion === "missing") {
 		await retryD1Operation(() => db.prepare(`CREATE TABLE WorkflowProperties (
           instanceId TEXT NOT NULL,
@@ -226,16 +226,16 @@ async function migrateWorkflowPropertiesTable(db, currentVersion) {
           PRIMARY KEY (instanceId, key),
           FOREIGN KEY (instanceId) REFERENCES WorkflowTable(instanceId)
           ON DELETE CASCADE
-        )`).run());
+        )`).run(), retryConfig);
 		return;
 	}
 }
 /**
 * Create or migrate WorkflowDependencies table to the latest schema
 */
-async function migrateWorkflowDependenciesTable(db, currentVersion) {
+async function migrateWorkflowDependenciesTable(db, currentVersion, retryConfig) {
 	if (currentVersion === "missing") {
-		await db.prepare(`CREATE TABLE WorkflowDependencies (
+		await retryD1Operation(() => db.prepare(`CREATE TABLE WorkflowDependencies (
           dependencyWorkflowId TEXT NOT NULL,
           dependentWorkflowId TEXT NOT NULL,
           tenantId TEXT NOT NULL,
@@ -243,15 +243,15 @@ async function migrateWorkflowDependenciesTable(db, currentVersion) {
           PRIMARY KEY (dependencyWorkflowId, dependentWorkflowId),
           FOREIGN KEY (dependencyWorkflowId) REFERENCES WorkflowTable(instanceId) ON DELETE CASCADE,
           FOREIGN KEY (dependentWorkflowId) REFERENCES WorkflowTable(instanceId) ON DELETE CASCADE
-        )`).run();
+        )`).run(), retryConfig);
 		return;
 	}
 }
 /**
 * Create necessary indexes
 */
-async function createIndexes(db) {
-	const existingIndexes = await retryD1Operation(() => db.prepare(`SELECT name FROM sqlite_master WHERE type='index' AND name LIKE 'idx_%'`).all());
+async function createIndexes(db, retryConfig) {
+	const existingIndexes = await retryD1Operation(() => db.prepare(`SELECT name FROM sqlite_master WHERE type='index' AND name LIKE 'idx_%'`).all(), retryConfig);
 	const existingIndexNames = new Set(existingIndexes.results?.map((row) => row.name) || []);
 	const indexes = [
 		{
@@ -341,23 +341,24 @@ async function createIndexes(db) {
 	];
 	const preparedStatements = [];
 	for (const index of indexes) if (!existingIndexNames.has(index.name)) preparedStatements.push(db.prepare(index.sql));
-	if (preparedStatements.length > 0) await retryD1Operation(() => db.batch(preparedStatements));
+	if (preparedStatements.length > 0) await retryD1Operation(() => db.batch(preparedStatements), retryConfig);
 }
 /**
 * Main migration function that ensures all tables exist and are up-to-date.
 * This function is idempotent and can be safely run multiple times.
 *
 * @param db - D1Database instance
+* @param retryConfig - Optional retry configuration for D1 operations
 */
-async function ensureTables(db) {
-	await retryD1Operation(() => db.prepare(`PRAGMA foreign_keys = ON`).run());
-	const schemaVersion = await detectSchemaVersion(db);
-	await migrateWorkflowTable(db, schemaVersion.workflowTable);
-	await migrateStepTable(db, schemaVersion.stepTable);
-	await migrateLogTable(db, schemaVersion.logTable);
-	await migrateWorkflowPropertiesTable(db, schemaVersion.workflowProperties);
-	await migrateWorkflowDependenciesTable(db, schemaVersion.workflowDependencies);
-	await createIndexes(db);
+async function ensureTables(db, retryConfig) {
+	await retryD1Operation(() => db.prepare(`PRAGMA foreign_keys = ON`).run(), retryConfig);
+	const schemaVersion = await detectSchemaVersion(db, retryConfig);
+	await migrateWorkflowTable(db, schemaVersion.workflowTable, retryConfig);
+	await migrateStepTable(db, schemaVersion.stepTable, retryConfig);
+	await migrateLogTable(db, schemaVersion.logTable, retryConfig);
+	await migrateWorkflowPropertiesTable(db, schemaVersion.workflowProperties, retryConfig);
+	await migrateWorkflowDependenciesTable(db, schemaVersion.workflowDependencies, retryConfig);
+	await createIndexes(db, retryConfig);
 }
 
 //#endregion
@@ -397,12 +398,12 @@ function sleep(ms) {
 }
 /**
 * Retry a D1 operation with exponential backoff for transient network errors
-* 
+*
 * @param operation - The async operation to retry
 * @param config - Retry configuration options
 * @returns The result of the operation
 * @throws The last error if all retry attempts fail
-* 
+*
 * @example
 * ```typescript
 * const result = await retryD1Operation(
@@ -436,11 +437,60 @@ async function finalizeWorkflowRecord(options, { workflowStatus, endTime, instan
 		const { data: resultData, externalRef: resultRef } = await serializeWithExternalStorage(result, options.serializer, options.externalBlobStorage);
 		return retryD1Operation(() => options.D1.prepare(`UPDATE WorkflowTable
             SET workflowStatus = ?, endTime = ?, result = ?, resultRef = ?
-            WHERE instanceId = ?`).bind(workflowStatus, endTime, resultData, resultRef, instanceId).run());
+            WHERE instanceId = ?`).bind(workflowStatus, endTime, resultData, resultRef, instanceId).run(), options.retryConfig);
 	}
 	return retryD1Operation(() => options.D1.prepare(`UPDATE WorkflowTable
             SET workflowStatus = ?, endTime = ?
-            WHERE instanceId = ?`).bind(workflowStatus, endTime, instanceId).run());
+            WHERE instanceId = ?`).bind(workflowStatus, endTime, instanceId).run(), options.retryConfig);
+}
+/**
+* Prepare D1 statements for inserting a workflow record and its dependencies.
+* This function handles input serialization (including external blob storage for large inputs)
+* and returns prepared statements that can be executed individually or batched with other statements.
+*
+* This is an internal helper used by `insertWorkflowRecord` and `enqueueWorkflowBatch` to enable
+* efficient batching of multiple workflow inserts into a single D1 batch operation.
+*
+* @param options - The internal workflow context options containing D1, serializer, etc.
+* @param params - The workflow record parameters
+* @returns Object containing prepared statements, instanceId, and workflowType
+*
+* @example
+* ```typescript
+* // Prepare statements for multiple workflows, then batch execute
+* const prepared = await Promise.all([
+*   prepareWorkflowInsertStatements(options, workflow1Params),
+*   prepareWorkflowInsertStatements(options, workflow2Params),
+* ])
+* const allStatements = prepared.flatMap(p => p.statements)
+* await options.D1.batch(allStatements)
+* ```
+*
+* @internal
+*/
+async function prepareWorkflowInsertStatements(options, { instanceId, workflowType, workflowName, workflowMetadata, input, workflowStatus, startTime, endTime, parentInstanceId, tenantId, triggerId, dependencies }) {
+	const { data: inputData, externalRef: inputRef } = await serializeWithExternalStorage(input, options.serializer, options.externalBlobStorage);
+	const insertWorkflowStatement = options.D1.prepare(`INSERT INTO WorkflowTable
+        (instanceId, workflowType, workflowName, workflowMetadata, input, inputRef, tenantId, workflowStatus, startTime, endTime, parentInstanceId, triggerId)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, workflowType, workflowName, options.serializer.serialize(workflowMetadata), inputData, inputRef, tenantId, workflowStatus, startTime, endTime ?? null, parentInstanceId ?? null, triggerId ?? null);
+	if (!dependencies || dependencies.length === 0) return {
+		statements: [insertWorkflowStatement],
+		instanceId,
+		workflowType
+	};
+	const createdAt = Date.now();
+	const dependencyStatements = dependencies.map((dep) => prepareWorkflowDependencyStatement({
+		D1: options.D1,
+		dependencyWorkflowId: dep.instanceId,
+		dependentWorkflowId: instanceId,
+		tenantId,
+		createdAt
+	}));
+	return {
+		statements: [insertWorkflowStatement, ...dependencyStatements],
+		instanceId,
+		workflowType
+	};
 }
 /**
 * Insert a new workflow record into the database.
@@ -465,27 +515,16 @@ async function finalizeWorkflowRecord(options, { workflowStatus, endTime, instan
 * })
 * ```
 */
-async function insertWorkflowRecord(options, { instanceId, workflowType, workflowName, workflowMetadata, input, workflowStatus, startTime, endTime, parentInstanceId, tenantId, triggerId, dependencies }) {
-	const { data: inputData, externalRef: inputRef } = await serializeWithExternalStorage(input, options.serializer, options.externalBlobStorage);
-	const insertWorkflowStatement = options.D1.prepare(`INSERT INTO WorkflowTable
-        (instanceId, workflowType, workflowName, workflowMetadata, input, inputRef, tenantId, workflowStatus, startTime, endTime, parentInstanceId, triggerId)
-        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, workflowType, workflowName, options.serializer.serialize(workflowMetadata), inputData, inputRef, tenantId, workflowStatus, startTime, endTime ?? null, parentInstanceId ?? null, triggerId ?? null);
-	if (!dependencies || dependencies.length === 0) {
-		const result = await retryD1Operation(() => insertWorkflowStatement.run());
+async function insertWorkflowRecord(options, params) {
+	const { statements } = await prepareWorkflowInsertStatements(options, params);
+	if (statements.length === 1) {
+		const result = await retryD1Operation(() => statements[0].run(), options.retryConfig);
 		return {
 			success: result.success,
 			meta: result.meta
 		};
 	}
-	const createdAt = Date.now();
-	const dependencyStatements = dependencies.map((dep) => prepareWorkflowDependencyStatement({
-		D1: options.D1,
-		dependencyWorkflowId: dep.instanceId,
-		dependentWorkflowId: instanceId,
-		tenantId,
-		createdAt
-	}));
-	const results = await retryD1Operation(() => options.D1.batch([insertWorkflowStatement, ...dependencyStatements]));
+	const results = await retryD1Operation(() => options.D1.batch(statements), options.retryConfig);
 	const allSucceeded = results.every((result) => result.success);
 	return {
 		success: allSucceeded,
@@ -495,10 +534,10 @@ async function insertWorkflowRecord(options, { instanceId, workflowType, workflo
 function insertStepRecordFull(context, { instanceId, name, status, metadata, startTime, endTime, result, error, resultRef, errorRef }) {
 	return retryD1Operation(() => context.D1.prepare(`INSERT INTO StepTable
             (instanceId, stepName, stepStatus, stepMetadata, startTime, endTime, result, error, resultRef, errorRef, tenantId)
-            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, name, status, metadata, startTime, endTime, result, error, resultRef ?? null, errorRef ?? null, context.tenantId).run());
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, name, status, metadata, startTime, endTime, result, error, resultRef ?? null, errorRef ?? null, context.tenantId).run(), context.retryConfig);
 }
 async function getStepRecord(context, stepName, instanceId) {
-	const existingStep = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM StepTable WHERE instanceId = ? AND stepName = ? AND tenantId = ?`).bind(instanceId, stepName, context.tenantId).first());
+	const existingStep = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM StepTable WHERE instanceId = ? AND stepName = ? AND tenantId = ?`).bind(instanceId, stepName, context.tenantId).first(), context.retryConfig);
 	const row = existingStep;
 	if (row) {
 		const result = await deserializeWithExternalStorage(row.result, row.resultRef, context.serializer, context.externalBlobStorage);
@@ -574,7 +613,7 @@ function pushLogToDB(options, { instanceId, stepName, message, timestamp, type,
 	const truncatedMessage = truncateLogMessage(message);
 	return retryD1Operation(() => options.D1.prepare(`INSERT INTO LogTable
            (instanceId, stepName, log, timestamp, type, logOrder, tenantId)
-           VALUES (?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, stepName, truncatedMessage, timestamp, type, logOrder, tenantId).run());
+           VALUES (?, ?, ?, ?, ?, ?, ?)`).bind(instanceId, stepName, truncatedMessage, timestamp, type, logOrder, tenantId).run(), options.retryConfig);
 }
 var LogBatcher = class {
 	batch = [];
@@ -614,7 +653,7 @@ var LogBatcher = class {
                  (instanceId, stepName, log, timestamp, type, logOrder, tenantId)
                  VALUES (?, ?, ?, ?, ?, ?, ?)`).bind(entry.instanceId, entry.stepName, entry.message, entry.timestamp, entry.type, entry.logOrder, entry.tenantId));
 				return await this.options.D1.batch(statements);
-			});
+			}, this.options.retryConfig);
 		} catch (error) {
 			console.error("Batch log insert failed, falling back to individual inserts:", error);
 			await Promise.all(logsToFlush.map((entry) => pushLogToDB(this.options, entry)));
@@ -744,7 +783,7 @@ async function workflowTableRowToWorkflowRun({ row, serializer, externalBlobStor
 async function updateWorkflowName(context, instanceId, newWorkflowName) {
 	return await retryD1Operation(() => context.D1.prepare(`UPDATE WorkflowTable
           SET workflowName = ?
-          WHERE instanceId = ?`).bind(newWorkflowName, instanceId).run());
+          WHERE instanceId = ?`).bind(newWorkflowName, instanceId).run(), context.retryConfig);
 }
 /**
 * Update workflow fields by instanceId. Only provided fields will be updated.
@@ -821,7 +860,7 @@ async function updateWorkflow(context, instanceId, updates) {
 	};
 	bindings.push(instanceId);
 	const sql = `UPDATE WorkflowTable SET ${setClauses.join(", ")} WHERE instanceId = ?`;
-	return await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings).run());
+	return await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings).run(), context.retryConfig);
 }
 /**
 * Serialize a workflow property value for storage
@@ -856,7 +895,7 @@ async function upsertWorkflowProperty({ context, instanceId, key, value, tenantI
 	const { serializedValue, valueType } = serializeWorkflowPropertyValue(value);
 	const res = await retryD1Operation(() => context.D1.prepare(`INSERT OR REPLACE INTO WorkflowProperties
           (instanceId, key, value, valueType, tenantId)
-          VALUES (?, ?, ?, ?, ?)`).bind(instanceId, key, serializedValue, valueType, tenantId).run());
+          VALUES (?, ?, ?, ?, ?)`).bind(instanceId, key, serializedValue, valueType, tenantId).run(), context.retryConfig);
 	if (res.error) {
 		console.error("Error inserting workflow property:", res.error);
 		return false;
@@ -917,7 +956,7 @@ async function createWorkflowDependency({ context, dependencyWorkflowId, depende
 		dependencyWorkflowId,
 		dependentWorkflowId,
 		tenantId
-	}).run());
+	}).run(), context.retryConfig);
 }
 /**
 * Create multiple workflow dependencies in a single transaction.
@@ -950,7 +989,7 @@ async function createWorkflowDependencies({ context, dependencies, tenantId }) {
 		tenantId,
 		createdAt
 	}));
-	return await retryD1Operation(() => context.D1.batch(statements));
+	return await retryD1Operation(() => context.D1.batch(statements), context.retryConfig);
 }
 /**
 * Delete a specific workflow dependency relationship.
@@ -968,7 +1007,7 @@ async function createWorkflowDependencies({ context, dependencies, tenantId }) {
 */
 async function deleteWorkflowDependency({ context, dependencyWorkflowId, dependentWorkflowId, tenantId }) {
 	return await retryD1Operation(() => context.D1.prepare(`DELETE FROM WorkflowDependencies
-          WHERE dependencyWorkflowId = ? AND dependentWorkflowId = ? AND tenantId = ?`).bind(dependencyWorkflowId, dependentWorkflowId, tenantId).run());
+          WHERE dependencyWorkflowId = ? AND dependentWorkflowId = ? AND tenantId = ?`).bind(dependencyWorkflowId, dependentWorkflowId, tenantId).run(), context.retryConfig);
 }
 
 //#endregion
@@ -996,7 +1035,7 @@ const createCleanupManager = (context) => {
         AND workflowStatus IN (${statusPlaceholders})
       ORDER BY instanceId
       LIMIT ?
-    `).bind(context.tenantId, config.deleteWorkflowsOlderThanDays, ...statuses, limit).all());
+    `).bind(context.tenantId, config.deleteWorkflowsOlderThanDays, ...statuses, limit).all(), context.retryConfig);
 		return result.results;
 	};
 	const getAffectedSteps = async (config, limit) => {
@@ -1015,7 +1054,7 @@ const createCleanupManager = (context) => {
         LIMIT ?
       )
       ORDER BY s.instanceId, s.stepName
-    `).bind(context.tenantId, config.deleteWorkflowsOlderThanDays, ...statuses, limit).all());
+    `).bind(context.tenantId, config.deleteWorkflowsOlderThanDays, ...statuses, limit).all(), context.retryConfig);
 		return result.results;
 	};
 	const collectExternalStorageKeys = (workflows, steps) => {
@@ -1068,7 +1107,7 @@ const createCleanupManager = (context) => {
 		}
 		if (deletedWorkflows.length > 0) {
 			console.log(`Proceeding to delete workflows from the database...`);
-			await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run());
+			await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run(), context.retryConfig);
 			let totalDeletedCount = 0;
 			for (let i = 0; i < deletedWorkflows.length; i += 100) {
 				const batch = deletedWorkflows.slice(i, i + 100);
@@ -1076,7 +1115,7 @@ const createCleanupManager = (context) => {
 				const result = await retryD1Operation(() => context.D1.prepare(`
           DELETE FROM WorkflowTable 
           WHERE instanceId IN (${workflowIds})
-        `).bind(...batch.map((w) => w.instanceId)).run());
+        `).bind(...batch.map((w) => w.instanceId)).run(), context.retryConfig);
 				totalDeletedCount += result.meta.changes || 0;
 			}
 			return {
@@ -1092,7 +1131,7 @@ const createCleanupManager = (context) => {
 		};
 	};
 	const cleanupOrphanedSteps = async (config, limit) => {
-		await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run());
+		await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run(), context.retryConfig);
 		const orphanedSteps = await retryD1Operation(() => context.D1.prepare(`
       SELECT s.instanceId, s.stepName, s.errorRef, s.resultRef
       FROM StepTable s
@@ -1103,7 +1142,7 @@ const createCleanupManager = (context) => {
         )
       ORDER BY s.instanceId, s.stepName
       LIMIT ?
-    `).bind(context.tenantId, context.tenantId, limit).all());
+    `).bind(context.tenantId, context.tenantId, limit).all(), context.retryConfig);
 		const orphanedStepResults = orphanedSteps.results;
 		let deletedExternalStorageKeysCount = 0;
 		if (config.deleteRefsFromExternalStorage && context.externalBlobStorage && orphanedStepResults.length > 0) {
@@ -1123,7 +1162,7 @@ const createCleanupManager = (context) => {
           DELETE FROM StepTable 
           WHERE tenantId = ?
             AND instanceId IN (${instanceIds})
-        `).bind(context.tenantId, ...batch.map((s) => s.instanceId)).run());
+        `).bind(context.tenantId, ...batch.map((s) => s.instanceId)).run(), context.retryConfig);
 				totalDeletedSteps += deletedStepsResult.meta.changes || 0;
 			}
 			return {
@@ -1139,7 +1178,7 @@ const createCleanupManager = (context) => {
 		};
 	};
 	const cleanupOrphanedLogs = async (limit) => {
-		await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run());
+		await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run(), context.retryConfig);
 		const deletedLogsResult = await retryD1Operation(() => context.D1.prepare(`
       DELETE FROM LogTable
       WHERE tenantId = ?
@@ -1155,7 +1194,7 @@ const createCleanupManager = (context) => {
           ))
         )
       LIMIT ?
-    `).bind(context.tenantId, context.tenantId, context.tenantId, limit).run());
+    `).bind(context.tenantId, context.tenantId, context.tenantId, limit).run(), context.retryConfig);
 		return { deletedOrphanedLogs: deletedLogsResult.meta.changes || 0 };
 	};
 	return {
@@ -1343,7 +1382,7 @@ const createLogAccessor = (context) => {
 		const limitClause = limit !== void 0 && actualOffset !== void 0 ? "LIMIT ? OFFSET ?" : "";
 		const sql = `SELECT * FROM StepTable ${whereClause} ORDER BY startTime ASC ${limitClause}`;
 		if (limit !== void 0 && actualOffset !== void 0) bindings.push(limit, actualOffset);
-		result = await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings).all());
+		result = await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings).all(), context.retryConfig);
 		if (result.results) {
 			const steps = await Promise.all(result.results.map(async (row) => {
 				let deserializedResult = null;
@@ -1370,7 +1409,7 @@ const createLogAccessor = (context) => {
 	const listWorkflows = async (limit, offset, filter, options) => {
 		const { sql, bindings } = buildFilteredWorkflowQuery(filter, { ignoreTenant: options?.ignoreTenant });
 		if (options?.debugLogs) console.log("listWorkflows SQL:", sql, "Bindings:", JSON.stringify(bindings));
-		const result = await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings, limit, offset).all());
+		const result = await retryD1Operation(() => context.D1.prepare(sql).bind(...bindings, limit, offset).all(), context.retryConfig);
 		if (options?.debugLogs) console.log("listWorkflows SQL Query executed");
 		if (result.results) {
 			const workflows = await Promise.all(result.results.map((row) => workflowTableRowToWorkflowRun({
@@ -1387,7 +1426,7 @@ const createLogAccessor = (context) => {
 				for (let i = 0; i < instanceIds.length; i += BATCH_SIZE) {
 					const batchIds = instanceIds.slice(i, i + BATCH_SIZE);
 					const placeholders = batchIds.map(() => "?").join(", ");
-					const propertiesResult = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowProperties WHERE instanceId IN (${placeholders})`).bind(...batchIds).all());
+					const propertiesResult = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowProperties WHERE instanceId IN (${placeholders})`).bind(...batchIds).all(), context.retryConfig);
 					if (propertiesResult.results) for (const row of propertiesResult.results) {
 						const property = {
 							key: row.key,
@@ -1411,7 +1450,7 @@ const createLogAccessor = (context) => {
 					const dependenciesResult = await retryD1Operation(() => context.D1.prepare(`SELECT w.*, wd.createdAt, wd.dependentWorkflowId
                        FROM WorkflowDependencies wd
                        JOIN WorkflowTable w ON wd.dependencyWorkflowId = w.instanceId
-                       WHERE wd.dependentWorkflowId IN (${placeholders})`).bind(...batchIds).all());
+                       WHERE wd.dependentWorkflowId IN (${placeholders})`).bind(...batchIds).all(), context.retryConfig);
 					if (dependenciesResult.results) for (const row of dependenciesResult.results) {
 						const depWorkflow = await workflowTableRowToWorkflowRun({
 							row,
@@ -1441,7 +1480,7 @@ const createLogAccessor = (context) => {
 					const dependentsResult = await retryD1Operation(() => context.D1.prepare(`SELECT w.*, wd.createdAt, wd.dependencyWorkflowId
                        FROM WorkflowDependencies wd
                        JOIN WorkflowTable w ON wd.dependentWorkflowId = w.instanceId
-                       WHERE wd.dependencyWorkflowId IN (${placeholders})`).bind(...batchIds).all());
+                       WHERE wd.dependencyWorkflowId IN (${placeholders})`).bind(...batchIds).all(), context.retryConfig);
 					if (dependentsResult.results) for (const row of dependentsResult.results) {
 						const depWorkflow = await workflowTableRowToWorkflowRun({
 							row,
@@ -1466,7 +1505,7 @@ const createLogAccessor = (context) => {
 		return [];
 	};
 	const getWorkflowByParentId = async (parentInstanceId) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE parentInstanceId = ? AND tenantId = ?`).bind(parentInstanceId, context.tenantId).all());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE parentInstanceId = ? AND tenantId = ?`).bind(parentInstanceId, context.tenantId).all(), context.retryConfig);
 		if (result.results) {
 			const workflows = await Promise.all(result.results.map((row) => workflowTableRowToWorkflowRun({
 				row,
@@ -1478,7 +1517,7 @@ const createLogAccessor = (context) => {
 		return null;
 	};
 	const getWorkflowByTriggerId = async (triggerId) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE triggerId = ? AND tenantId = ?`).bind(triggerId, context.tenantId).first());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE triggerId = ? AND tenantId = ?`).bind(triggerId, context.tenantId).first(), context.retryConfig);
 		if (result) {
 			const workflow = await workflowTableRowToWorkflowRun({
 				row: result,
@@ -1490,12 +1529,12 @@ const createLogAccessor = (context) => {
 		return null;
 	};
 	const getWorkflowTypesByTenantId = async (tenantId) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT DISTINCT workflowType FROM WorkflowTable WHERE tenantId = ?`).bind(tenantId).all());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT DISTINCT workflowType FROM WorkflowTable WHERE tenantId = ?`).bind(tenantId).all(), context.retryConfig);
 		if (!result.results) return [];
 		return result.results.map((row) => row.workflowType);
 	};
 	const getWorkflowProperties = async (instanceId) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowProperties WHERE instanceId = ?`).bind(instanceId).all());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowProperties WHERE instanceId = ?`).bind(instanceId).all(), context.retryConfig);
 		if (!result.results) return [];
 		return result.results.map((row) => ({
 			key: row.key,
@@ -1505,7 +1544,7 @@ const createLogAccessor = (context) => {
 	};
 	/** This function gets the basic data of a workflow, without populating any of it's complex fields */
 	const getWorkflowShallow = async (instanceId, options) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE instanceId = ? AND tenantId = ?`).bind(instanceId, context.tenantId).first());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM WorkflowTable WHERE instanceId = ? AND tenantId = ?`).bind(instanceId, context.tenantId).first(), context.retryConfig);
 		if (!result) return null;
 		const workflow = await workflowTableRowToWorkflowRun({
 			row: result,
@@ -1536,7 +1575,7 @@ const createLogAccessor = (context) => {
 			retryWorkflow.isRetryOf = workflow;
 		});
 		workflow.isRetryOf = parentWorkflow;
-		const allLogs = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM LogTable WHERE instanceId = ? ORDER BY timestamp ASC, logOrder ASC`).bind(instanceId).all());
+		const allLogs = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM LogTable WHERE instanceId = ? ORDER BY timestamp ASC, logOrder ASC`).bind(instanceId).all(), context.retryConfig);
 		const logs = allLogs.results?.map((logRow) => ({
 			instanceId: logRow.instanceId,
 			stepName: logRow.stepName,
@@ -1555,7 +1594,7 @@ const createLogAccessor = (context) => {
 			const dependenciesResult = await retryD1Operation(() => context.D1.prepare(`SELECT w.*, wd.createdAt 
                    FROM WorkflowDependencies wd
                    JOIN WorkflowTable w ON wd.dependencyWorkflowId = w.instanceId
-                   WHERE wd.dependentWorkflowId = ? AND wd.tenantId = ?`).bind(instanceId, context.tenantId).all());
+                   WHERE wd.dependentWorkflowId = ? AND wd.tenantId = ?`).bind(instanceId, context.tenantId).all(), context.retryConfig);
 			if (dependenciesResult.results) workflow.dependencies = await Promise.all(dependenciesResult.results.map(async (row) => {
 				const depWorkflow = await workflowTableRowToWorkflowRun({
 					row,
@@ -1574,7 +1613,7 @@ const createLogAccessor = (context) => {
 			const dependentsResult = await retryD1Operation(() => context.D1.prepare(`SELECT w.*, wd.createdAt 
                    FROM WorkflowDependencies wd
                    JOIN WorkflowTable w ON wd.dependentWorkflowId = w.instanceId
-                   WHERE wd.dependencyWorkflowId = ? AND wd.tenantId = ?`).bind(instanceId, context.tenantId).all());
+                   WHERE wd.dependencyWorkflowId = ? AND wd.tenantId = ?`).bind(instanceId, context.tenantId).all(), context.retryConfig);
 			if (dependentsResult.results) workflow.dependents = await Promise.all(dependentsResult.results.map(async (row) => {
 				const depWorkflow = await workflowTableRowToWorkflowRun({
 					row,
@@ -1592,7 +1631,7 @@ const createLogAccessor = (context) => {
 		return workflow;
 	};
 	const getStep = async (instanceId, stepName) => {
-		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM StepTable WHERE instanceId = ? AND stepName = ? AND tenantId = ?`).bind(instanceId, stepName, context.tenantId).all());
+		const result = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM StepTable WHERE instanceId = ? AND stepName = ? AND tenantId = ?`).bind(instanceId, stepName, context.tenantId).all(), context.retryConfig);
 		if (!result.results || result.results.length === 0) return null;
 		const row = result.results[0];
 		if (!row) return null;
@@ -1609,7 +1648,7 @@ const createLogAccessor = (context) => {
 			error: deserializedError,
 			logs: []
 		};
-		const logResult = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM LogTable WHERE instanceId = ? AND stepName = ? ORDER BY logOrder ASC`).bind(instanceId, stepName).all());
+		const logResult = await retryD1Operation(() => context.D1.prepare(`SELECT * FROM LogTable WHERE instanceId = ? AND stepName = ? ORDER BY logOrder ASC`).bind(instanceId, stepName).all(), context.retryConfig);
 		if (logResult.results) step.logs = logResult.results.map((logRow) => ({
 			instanceId: logRow.instanceId,
 			stepName: logRow.stepName,
@@ -1623,7 +1662,7 @@ const createLogAccessor = (context) => {
 		const result = await retryD1Operation(() => context.D1.prepare(`
       SELECT DISTINCT key, valueType FROM WorkflowProperties
       WHERE tenantId = ? AND (? IS NULL OR instanceId = ?)  
-      `).bind(context.tenantId, instanceId ?? null, instanceId ?? null).all());
+      `).bind(context.tenantId, instanceId ?? null, instanceId ?? null).all(), context.retryConfig);
 		console.log(`debug getPropertiesKeys: ${JSON.stringify(result)}`);
 		if (!result.results) return [];
 		return result.results.map((row) => ({
@@ -1689,7 +1728,7 @@ const createLogAccessor = (context) => {
       ${whereClause}
       GROUP BY workflowType
       ORDER BY workflowCount DESC
-    `).bind(...bindings).all());
+    `).bind(...bindings).all(), context.retryConfig);
 		if (!result.results) return [];
 		return result.results.map((row) => ({
 			workflowType: row.workflowType,
@@ -1783,68 +1822,79 @@ function createQueueWorkflowContext(options) {
 			queueIdentifier: options.queueIdentifier
 		});
 	};
+	/**
+	* Enqueue multiple workflows in a single batch operation.
+	*
+	* This method is optimized for efficiency: it prepares all workflow insert statements
+	* in parallel (which may involve external blob storage for large inputs), then executes
+	* them in a single D1 batch operation, followed by a single queue batch send.
+	*
+	* **Network requests:** 2 + M, where M is the number of workflows with large inputs
+	* that require external blob storage.
+	*
+	* **D1 batch limit:** Cloudflare D1 has a limit of ~100 statements per batch.
+	* If you have many workflows with dependencies, this limit may be exceeded.
+	* For very large batches, consider splitting into smaller chunks.
+	*
+	* @param workflows - Array of workflow items to enqueue
+	* @returns Array of scheduled workflow stubs in the same order as inputs
+	*/
 	const enqueueWorkflowBatch = async (workflows) => {
-		const results = await Promise.all(workflows.map(async ({ workflow, tenantId, input, initialName, dependencies }) => {
+		const startTime = Date.now();
+		console.log(`enqueueWorkflowBatch: Starting batch of ${workflows.length} workflows`);
+		const preparedWorkflows = await Promise.all(workflows.map(async ({ workflow, tenantId, input, initialName, dependencies }) => {
 			const instanceId = idFactory();
 			const triggerId = idFactory();
-			const startTime = Date.now();
-			if (dependencies && dependencies.length > 0) {
-				await insertWorkflowRecord(internalContext, {
-					instanceId,
-					workflowType: workflow.workflowType,
-					workflowName: initialName,
-					workflowMetadata: workflow.metadata,
-					input,
-					workflowStatus: "waiting",
-					startTime,
-					endTime: null,
-					parentInstanceId: void 0,
-					tenantId,
-					triggerId,
-					dependencies
-				});
-				return {
-					instanceId,
-					workflowType: workflow.workflowType,
-					shouldQueue: false,
-					queueMessage: null
-				};
-			} else {
-				await insertWorkflowRecord(internalContext, {
-					instanceId,
-					workflowType: workflow.workflowType,
-					workflowName: initialName,
-					workflowMetadata: workflow.metadata,
-					input,
-					workflowStatus: "scheduled",
-					startTime,
-					endTime: null,
-					parentInstanceId: void 0,
-					tenantId,
-					triggerId
-				});
-				return {
-					instanceId,
-					workflowType: workflow.workflowType,
-					shouldQueue: true,
-					queueMessage: {
-						type: "workflow-run",
-						workflowType: workflow.workflowType,
-						workflowName: initialName,
-						input,
-						tenantId,
-						triggerId,
-						queueIdentifier: options.queueIdentifier,
-						scheduledInstanceId: instanceId
-					}
-				};
-			}
+			const hasDependencies = dependencies && dependencies.length > 0;
+			const prepared = await prepareWorkflowInsertStatements(internalContext, {
+				instanceId,
+				workflowType: workflow.workflowType,
+				workflowName: initialName,
+				workflowMetadata: workflow.metadata,
+				input,
+				workflowStatus: hasDependencies ? "waiting" : "scheduled",
+				startTime,
+				endTime: null,
+				parentInstanceId: void 0,
+				tenantId,
+				triggerId,
+				dependencies
+			});
+			return {
+				...prepared,
+				tenantId,
+				triggerId,
+				initialName,
+				shouldQueue: !hasDependencies
+			};
 		}));
-		const messagesToQueue = results.filter((r) => r.shouldQueue && r.queueMessage).map((r) => ({ body: r.queueMessage }));
-		if (messagesToQueue.length > 0) await options.QUEUE.sendBatch(messagesToQueue);
-		return results.map((r) => ({
-			instanceId: r.instanceId,
-			workflowType: r.workflowType
+		const workflowsWithDeps = preparedWorkflows.filter((p) => !p.shouldQueue).length;
+		const workflowsWithoutDeps = preparedWorkflows.filter((p) => p.shouldQueue).length;
+		console.log(`enqueueWorkflowBatch: Prepared ${preparedWorkflows.length} workflows (${workflowsWithoutDeps} to queue, ${workflowsWithDeps} waiting on dependencies)`);
+		const allStatements = preparedWorkflows.flatMap((p) => p.statements);
+		if (allStatements.length > 0) {
+			console.log(`enqueueWorkflowBatch: Executing D1 batch with ${allStatements.length} statements`);
+			await retryD1Operation(() => options.D1.batch(allStatements), options.retryConfig);
+		}
+		const messagesToQueue = preparedWorkflows.filter((p) => p.shouldQueue).map((p) => ({ body: {
+			type: "workflow-run",
+			workflowType: p.workflowType,
+			workflowName: p.initialName,
+			input: workflows.find((w) => w.workflow.workflowType === p.workflowType && w.initialName === p.initialName)?.input,
+			tenantId: p.tenantId,
+			triggerId: p.triggerId,
+			queueIdentifier: options.queueIdentifier,
+			scheduledInstanceId: p.instanceId
+		} }));
+		if (messagesToQueue.length > 0) {
+			console.log(`enqueueWorkflowBatch: Sending ${messagesToQueue.length} messages to queue`);
+			await options.QUEUE.sendBatch(messagesToQueue);
+		}
+		const elapsed = Date.now() - startTime;
+		console.log(`enqueueWorkflowBatch: Completed in ${elapsed}ms`);
+		return preparedWorkflows.map((p) => ({
+			instanceId: p.instanceId,
+			workflowType: p.workflowType
 		}));
 	};
 	const handleWorkflowQueueMessage = async ({ message, env, workflowResolver }) => {
@@ -1877,7 +1927,8 @@ function createQueueWorkflowContext(options) {
 			D1: options.D1,
 			externalBlobStorage: options.externalBlobStorage,
 			serializer: internalContext.serializer,
-			tenantId: "unknown"
+			tenantId: "unknown",
+			retryConfig: options.retryConfig
 		});
 		const waitingWorkflows = await logAccessor.listWorkflows(250, 0, { workflowStatus: "waiting" }, {
 			ignoreTenant: true,
@@ -1924,7 +1975,7 @@ function createQueueWorkflowContext(options) {
 async function createStepContext(context) {
 	const instanceId = context.instanceId;
 	const reuseSuccessfulSteps = context.reuseSuccessfulSteps ?? true;
-	await ensureTables(context.D1);
+	await ensureTables(context.D1, context.retryConfig);
 	const step = async (step$1, callback) => {
 		const stepNameParam = typeof step$1 === "string" ? step$1 : step$1.name;
 		const stepMetadataParam = typeof step$1 === "string" ? void 0 : step$1.metadata;
@@ -2004,7 +2055,7 @@ async function createStepContext(context) {
 			const stepError$1 = null;
 			await retryD1Operation(() => context.D1.prepare(`UPDATE StepTable
           SET stepStatus = ?, endTime = ?, result = ?, error = ?, resultRef = ?, errorRef = ?
-          WHERE instanceId = ? AND stepName = ?`).bind(stepStatus$1, endTime, resultData, stepError$1, resultRef, null, instanceId, stepName).run());
+          WHERE instanceId = ? AND stepName = ?`).bind(stepStatus$1, endTime, resultData, stepError$1, resultRef, null, instanceId, stepName).run(), context.retryConfig);
 			await logBatcher.destroy();
 			return result;
 		} catch (error) {
@@ -2014,7 +2065,7 @@ async function createStepContext(context) {
 			const { data: errorData, externalRef: errorRef } = await serializeWithExternalStorage(error, context.serializer, context.externalBlobStorage);
 			await retryD1Operation(() => context.D1.prepare(`UPDATE StepTable
           SET stepStatus = ?, endTime = ?, result = ?, error = ?, resultRef = ?, errorRef = ?
-          WHERE instanceId = ? AND stepName = ?`).bind(stepStatus$1, endTime, stepResult$1, errorData, null, errorRef, instanceId, stepName).run());
+          WHERE instanceId = ? AND stepName = ?`).bind(stepStatus$1, endTime, stepResult$1, errorData, null, errorRef, instanceId, stepName).run(), context.retryConfig);
 			await logBatcher.destroy();
 			throw error;
 		}
@@ -2033,14 +2084,15 @@ function createWorkflowContext(options) {
 	};
 	const call = async ({ workflow, input, workflowName, tenantId, parentInstanceId, reuseSuccessfulSteps, triggerId, scheduledInstanceId }) => {
 		if (!ensuredTables) {
-			await ensureTables(options.D1);
+			await ensureTables(options.D1, options.retryConfig);
 			ensuredTables = true;
 		}
 		const logAccessor = createLogAccessor({
 			D1: internalContext.D1,
 			externalBlobStorage: internalContext.externalBlobStorage,
 			serializer: internalContext.serializer,
-			tenantId
+			tenantId,
+			retryConfig: options.retryConfig
 		});
 		if (scheduledInstanceId) {
 			const existingWorkflow = await logAccessor.getWorkflowShallow(scheduledInstanceId);
@@ -2096,7 +2148,8 @@ function createWorkflowContext(options) {
 			idFactory: internalContext.idFactory,
 			parentInstanceId,
 			reuseSuccessfulSteps,
-			externalBlobStorage: options.externalBlobStorage
+			externalBlobStorage: options.externalBlobStorage,
+			retryConfig: options.retryConfig
 		});
 		try {
 			const result = await workflow._callback(input, {
@@ -2116,7 +2169,10 @@ function createWorkflowContext(options) {
 					}
 				},
 				async setWorkflowName(newName) {
-					await updateWorkflowName({ D1: options.D1 }, instanceId, newName);
+					await updateWorkflowName({
+						D1: options.D1,
+						retryConfig: options.retryConfig
+					}, instanceId, newName);
 				},
 				async setWorkflowProperty(key, value) {
 					await upsertWorkflowProperty({
@@ -2166,10 +2222,10 @@ function createWorkflowContext(options) {
 	};
 	const retry = async ({ workflow, retryInstanceId, triggerId, retryOptions }) => {
 		if (!ensuredTables) {
-			await ensureTables(options.D1);
+			await ensureTables(options.D1, options.retryConfig);
 			ensuredTables = true;
 		}
-		const oldRun = await retryD1Operation(() => options.D1.prepare(`SELECT input, workflowName, tenantId, inputRef FROM WorkflowTable WHERE instanceId = ? `).bind(retryInstanceId).first());
+		const oldRun = await retryD1Operation(() => options.D1.prepare(`SELECT input, workflowName, tenantId, inputRef FROM WorkflowTable WHERE instanceId = ? `).bind(retryInstanceId).first(), options.retryConfig);
 		const oldWorkflowName = oldRun?.workflowName;
 		const tenantId = oldRun?.tenantId;
 		if (!tenantId) throw new Error(`No tenantId found for instanceId ${retryInstanceId}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brandboostinggmbh/observable-workflows",
-  "version": "0.20.0-beta.4",
+  "version": "0.20.0-beta.6",
   "description": "My awesome typescript library",
   "type": "module",
   "license": "MIT",
@@ -53,7 +53,7 @@
     "test": "vitest run",
     "typecheck": "tsc --noEmit",
     "format": "prettier --cache --write .",
-    "release": "bumpp && pnpm publish",
-    "release:beta": "bumpp --preid beta && pnpm publish --tag beta"
+    "release": "npm login && bumpp && pnpm publish",
+    "release:beta": "npm login && bumpp --preid beta && pnpm publish --tag beta"
   }
 }