@brandboostinggmbh/observable-workflows 0.19.0-beta.4 → 0.20.0-beta.5

package/README.md

@@ -358,6 +358,48 @@ The library provides comprehensive error handling:
 - **Workflow Failures**: Marked with appropriate status and error information
 - **Retry Logic**: Failed workflows can be retried with step result reuse
 - **Validation**: Input validation and type checking
+- **Automatic D1 Retry**: Built-in retry logic with exponential backoff for transient D1 network errors
+
+### D1 Network Error Retry
+
+The library automatically retries D1 database operations that fail due to transient network errors (e.g., "D1_ERROR: Network connection lost"). This makes workflows more resilient to temporary network issues.
+
+**Default Retry Configuration:**
+- Maximum retry attempts: 3
+- Initial delay: 100ms
+- Maximum delay: 5000ms
+- Exponential backoff multiplier: 2
+- Jitter: Enabled
+
+**Custom Retry Configuration:**
+
+You can customize the retry behavior when creating the workflow context:
+
+```typescript
+const workflowContext = createWorkflowContext({
+  D1: env.D1,
+  retryConfig: {
+    maxAttempts: 5,        // Retry up to 5 times
+    initialDelayMs: 200,   // Start with 200ms delay
+    maxDelayMs: 10000,     // Cap delay at 10 seconds
+    backoffMultiplier: 3,  // Triple the delay each time
+    useJitter: true,       // Add randomization to prevent thundering herd
+  },
+})
+```
+
+**Manual Retry for Custom Operations:**
+
+You can also use the retry utility directly for custom D1 operations:
+
+```typescript
+import { retryD1Operation } from '@brandboostinggmbh/observable-workflows'
+
+const result = await retryD1Operation(
+  () => db.prepare("SELECT * FROM custom_table").first(),
+  { maxAttempts: 3, initialDelayMs: 100 }
+)
+```
 
 ## Best Practices
 

package/dist/index.d.ts

@@ -14,10 +14,43 @@ 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 {
+  /** 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;
+}
+/**
+ * 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(
+ *   () => db.prepare("SELECT * FROM table").first(),
+ *   { maxAttempts: 5, initialDelayMs: 200 }
+ * )
+ * ```
+ */
+declare function retryD1Operation<T>(operation: () => Promise<T>, config?: RetryConfig): Promise<T>;
 declare function finalizeWorkflowRecord(options: InternalWorkflowContextOptions, {
   workflowStatus,
   endTime,
@@ -199,6 +232,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.
@@ -409,6 +443,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;
@@ -610,6 +646,8 @@ type WorkflowContextOptions = {
   idFactory?: () => string;
   serializer?: Serializer;
   externalBlobStorage?: ExternalBlobStorage;
+  /** Optional retry configuration for D1 operations (defaults: maxAttempts: 3, initialDelayMs: 100, maxDelayMs: 5000, backoffMultiplier: 2, useJitter: true) */
+  retryConfig?: RetryConfig;
 };
 type InternalWorkflowContextOptions = WorkflowContextOptions & Required<Pick<WorkflowContextOptions, 'serializer' | 'idFactory'>>;
 type WorkflowContextInstance = {
@@ -728,6 +766,7 @@ declare const createCleanupManager: (context: {
   tenantId: string;
   serializer?: Serializer;
   externalBlobStorage?: ExternalBlobStorage;
+  retryConfig?: RetryConfig;
 }) => {
   countAffectedWorkflows: (config: DeleteConfig, limit: number) => Promise<{
     count: number;
@@ -774,6 +813,7 @@ declare const createLogAccessor: (context: {
   tenantId: string;
   serializer?: Serializer;
   externalBlobStorage?: ExternalBlobStorage;
+  retryConfig?: RetryConfig;
 }) => {
   listSteps: {
     (limit: number, offset: number, instanceId?: string): Promise<Step[]>;
@@ -906,4 +946,4 @@ type R2ExternalBlobStorageOptions = {
  */
 declare function createR2ExternalBlobStorage(options: R2ExternalBlobStorageOptions): ExternalBlobStorage;
 //#endregion
-export { ConsoleWrapper, DateRangeFilter, ExternalBlobStorage, HandleWorkflowQueueMessageParams, InternalWorkflowContextOptions, Log, PossibleValueTypeNames, PossibleValueTypes, PropertyFilter, QueueWorkflowContextOptions, R2ExternalBlobStorageOptions, Serializer, Step, StepContextOptions, StepCtx, StepWorkflowStatus, StringFilter, ValueTypeMap, WorkflowContext, WorkflowContextInstance, WorkflowContextOptions, WorkflowEnqueueBatchItem, WorkflowFilter, WorkflowFunction, WorkflowProperty, WorkflowPropertyDefinition, WorkflowQueueMessage, WorkflowRun, WorkflowStatus, createCleanupManager, createLogAccessor, createQueueWorkflowContext, createR2ExternalBlobStorage, createStepContext, createWorkflowContext, createWorkflowDependencies, createWorkflowDependency, defaultIdFactory, defaultSerializer, defineWorkflow, deleteWorkflowDependency, deserializeWithExternalStorage, ensureTables, finalizeWorkflowRecord, insertStepRecordFull, insertWorkflowRecord, pushLogToDB, serializeWithExternalStorage, tryDeserializeObj, updateWorkflow, updateWorkflowName, upsertWorkflowProperty, workflowTableRowToWorkflowRun };
+export { ConsoleWrapper, DateRangeFilter, ExternalBlobStorage, HandleWorkflowQueueMessageParams, InternalWorkflowContextOptions, Log, PossibleValueTypeNames, PossibleValueTypes, PropertyFilter, QueueWorkflowContextOptions, R2ExternalBlobStorageOptions, RetryConfig, Serializer, Step, StepContextOptions, StepCtx, StepWorkflowStatus, StringFilter, ValueTypeMap, WorkflowContext, WorkflowContextInstance, WorkflowContextOptions, WorkflowEnqueueBatchItem, WorkflowFilter, WorkflowFunction, WorkflowProperty, WorkflowPropertyDefinition, WorkflowQueueMessage, WorkflowRun, WorkflowStatus, createCleanupManager, createLogAccessor, createQueueWorkflowContext, createR2ExternalBlobStorage, createStepContext, createWorkflowContext, createWorkflowDependencies, createWorkflowDependency, defaultIdFactory, defaultSerializer, defineWorkflow, deleteWorkflowDependency, deserializeWithExternalStorage, ensureTables, finalizeWorkflowRecord, insertStepRecordFull, insertWorkflowRecord, pushLogToDB, retryD1Operation, serializeWithExternalStorage, tryDeserializeObj, updateWorkflow, updateWorkflowName, upsertWorkflowProperty, workflowTableRowToWorkflowRun };

package/dist/index.js

@@ -2,8 +2,8 @@
 /**
 * Detect the current schema version for each table
 */
-async function detectSchemaVersion(db) {
-	const workflowTableInfo = await 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 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 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 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,11 +52,11 @@ 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 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 db.batch([
+	if (!hasInputRef || inputHasNotNull) await retryD1Operation(() => db.batch([
 		db.prepare(`CREATE TABLE WorkflowTable_new (
         instanceId TEXT NOT NULL,
         workflowType TEXT NOT NULL,
@@ -78,16 +78,16 @@ 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 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 db.batch([
+	if (!hasTriggerId) await retryD1Operation(() => db.batch([
 		db.prepare(`CREATE TABLE WorkflowTable_new (
         instanceId TEXT NOT NULL,
         workflowType TEXT NOT NULL,
@@ -111,23 +111,23 @@ 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 db.prepare(`CREATE TABLE WorkflowTable (
+		await retryD1Operation(() => db.prepare(`CREATE TABLE WorkflowTable (
           instanceId TEXT NOT NULL,
           workflowType TEXT NOT NULL,
           workflowName TEXT NOT NULL,
@@ -144,31 +144,31 @@ 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 db.prepare(`CREATE TABLE StepTable (
+		await retryD1Operation(() => db.prepare(`CREATE TABLE StepTable (
           instanceId TEXT NOT NULL,
           stepName TEXT NOT NULL,
           stepStatus TEXT NOT NULL,
@@ -182,23 +182,23 @@ 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 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 db.prepare(`ALTER TABLE StepTable ADD COLUMN resultRef TEXT`).run();
-		if (!hasErrorRef) await 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 db.prepare(`CREATE TABLE LogTable (
+		await retryD1Operation(() => db.prepare(`CREATE TABLE LogTable (
           instanceId TEXT NOT NULL,
           stepName TEXT,
           log TEXT NOT NULL,
@@ -208,16 +208,16 @@ 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 db.prepare(`CREATE TABLE WorkflowProperties (
+		await retryD1Operation(() => db.prepare(`CREATE TABLE WorkflowProperties (
           instanceId TEXT NOT NULL,
           key TEXT NOT NULL,
           value 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 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,37 +341,107 @@ 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 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 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
 //#region src/observableWorkflows/helperFunctions.ts
+/**
+* Default retry configuration for D1 operations
+*/
+const DEFAULT_RETRY_CONFIG = {
+	maxAttempts: 3,
+	initialDelayMs: 100,
+	maxDelayMs: 5e3,
+	backoffMultiplier: 2,
+	useJitter: true
+};
+/**
+* Check if an error is a transient D1 network error that should be retried
+*/
+function isRetriableD1Error(error) {
+	if (!error) return false;
+	const errorMessage = error.message || String(error);
+	const errorString = errorMessage.toLowerCase();
+	return errorString.includes("network connection lost") || errorString.includes("d1_error") || errorString.includes("connection reset") || errorString.includes("econnreset") || errorString.includes("timeout") || errorString.includes("etimedout");
+}
+/**
+* Calculate delay with exponential backoff and optional jitter
+*/
+function calculateDelay(attempt, config) {
+	const exponentialDelay = Math.min(config.initialDelayMs * Math.pow(config.backoffMultiplier, attempt), config.maxDelayMs);
+	if (config.useJitter) return Math.floor(Math.random() * exponentialDelay);
+	return exponentialDelay;
+}
+/**
+* Sleep for the specified number of milliseconds
+*/
+function sleep(ms) {
+	return new Promise((resolve) => setTimeout(resolve, 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(
+*   () => db.prepare("SELECT * FROM table").first(),
+*   { maxAttempts: 5, initialDelayMs: 200 }
+* )
+* ```
+*/
+async function retryD1Operation(operation, config = {}) {
+	const finalConfig = {
+		...DEFAULT_RETRY_CONFIG,
+		...config
+	};
+	let lastError;
+	for (let attempt = 0; attempt < finalConfig.maxAttempts; attempt++) try {
+		return await operation();
+	} catch (error) {
+		lastError = error;
+		if (!isRetriableD1Error(error)) throw error;
+		if (attempt < finalConfig.maxAttempts - 1) {
+			const delay = calculateDelay(attempt, finalConfig);
+			console.warn(`D1 operation failed with retriable error (attempt ${attempt + 1}/${finalConfig.maxAttempts}), retrying in ${delay}ms:`, error instanceof Error ? error.message : String(error));
+			await sleep(delay);
+		}
+	}
+	console.error(`D1 operation failed after ${finalConfig.maxAttempts} attempts:`, lastError instanceof Error ? lastError.message : String(lastError));
+	throw lastError;
+}
 async function finalizeWorkflowRecord(options, { workflowStatus, endTime, instanceId, result }) {
 	if (result !== void 0) {
 		const { data: resultData, externalRef: resultRef } = await serializeWithExternalStorage(result, options.serializer, options.externalBlobStorage);
-		return options.D1.prepare(`UPDATE WorkflowTable
+		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 options.D1.prepare(`UPDATE WorkflowTable
+	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);
 }
 /**
 * Insert a new workflow record into the database.
@@ -402,7 +472,7 @@ async function insertWorkflowRecord(options, { instanceId, workflowType, workflo
         (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 insertWorkflowStatement.run();
+		const result = await retryD1Operation(() => insertWorkflowStatement.run(), options.retryConfig);
 		return {
 			success: result.success,
 			meta: result.meta
@@ -416,7 +486,7 @@ async function insertWorkflowRecord(options, { instanceId, workflowType, workflo
 		tenantId,
 		createdAt
 	}));
-	const results = await options.D1.batch([insertWorkflowStatement, ...dependencyStatements]);
+	const results = await retryD1Operation(() => options.D1.batch([insertWorkflowStatement, ...dependencyStatements]), options.retryConfig);
 	const allSucceeded = results.every((result) => result.success);
 	return {
 		success: allSucceeded,
@@ -424,12 +494,12 @@ async function insertWorkflowRecord(options, { instanceId, workflowType, workflo
 	};
 }
 function insertStepRecordFull(context, { instanceId, name, status, metadata, startTime, endTime, result, error, resultRef, errorRef }) {
-	return context.D1.prepare(`INSERT INTO StepTable
+	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 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);
@@ -503,9 +573,9 @@ function truncateLogMessage(message) {
 }
 function pushLogToDB(options, { instanceId, stepName, message, timestamp, type, logOrder, tenantId }) {
 	const truncatedMessage = truncateLogMessage(message);
-	return options.D1.prepare(`INSERT INTO LogTable
+	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 = [];
@@ -540,10 +610,12 @@ var LogBatcher = class {
 		if (this.batch.length === 0) return;
 		const logsToFlush = this.batch.splice(0);
 		try {
-			const statements = logsToFlush.map((entry) => this.options.D1.prepare(`INSERT INTO LogTable
+			await retryD1Operation(async () => {
+				const statements = logsToFlush.map((entry) => this.options.D1.prepare(`INSERT INTO LogTable
                  (instanceId, stepName, log, timestamp, type, logOrder, tenantId)
                  VALUES (?, ?, ?, ?, ?, ?, ?)`).bind(entry.instanceId, entry.stepName, entry.message, entry.timestamp, entry.type, entry.logOrder, entry.tenantId));
-			await this.options.D1.batch(statements);
+				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)));
@@ -671,9 +743,9 @@ async function workflowTableRowToWorkflowRun({ row, serializer, externalBlobStor
 	};
 }
 async function updateWorkflowName(context, instanceId, newWorkflowName) {
-	return await context.D1.prepare(`UPDATE WorkflowTable
+	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.
@@ -750,7 +822,7 @@ async function updateWorkflow(context, instanceId, updates) {
 	};
 	bindings.push(instanceId);
 	const sql = `UPDATE WorkflowTable SET ${setClauses.join(", ")} WHERE instanceId = ?`;
-	return await 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
@@ -783,9 +855,9 @@ function deserializeWorkflowPropertyValue(serializedValue, valueType) {
 }
 async function upsertWorkflowProperty({ context, instanceId, key, value, tenantId }) {
 	const { serializedValue, valueType } = serializeWorkflowPropertyValue(value);
-	const res = await context.D1.prepare(`INSERT OR REPLACE INTO WorkflowProperties
+	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;
@@ -841,12 +913,12 @@ function prepareWorkflowDependencyStatement({ D1, dependencyWorkflowId, dependen
 * ```
 */
 async function createWorkflowDependency({ context, dependencyWorkflowId, dependentWorkflowId, tenantId }) {
-	return await prepareWorkflowDependencyStatement({
+	return await retryD1Operation(() => prepareWorkflowDependencyStatement({
 		D1: context.D1,
 		dependencyWorkflowId,
 		dependentWorkflowId,
 		tenantId
-	}).run();
+	}).run(), context.retryConfig);
 }
 /**
 * Create multiple workflow dependencies in a single transaction.
@@ -879,7 +951,7 @@ async function createWorkflowDependencies({ context, dependencies, tenantId }) {
 		tenantId,
 		createdAt
 	}));
-	return await context.D1.batch(statements);
+	return await retryD1Operation(() => context.D1.batch(statements), context.retryConfig);
 }
 /**
 * Delete a specific workflow dependency relationship.
@@ -896,8 +968,8 @@ async function createWorkflowDependencies({ context, dependencies, tenantId }) {
 * ```
 */
 async function deleteWorkflowDependency({ context, dependencyWorkflowId, dependentWorkflowId, tenantId }) {
-	return await context.D1.prepare(`DELETE FROM WorkflowDependencies
-          WHERE dependencyWorkflowId = ? AND dependentWorkflowId = ? AND tenantId = ?`).bind(dependencyWorkflowId, dependentWorkflowId, tenantId).run();
+	return await retryD1Operation(() => context.D1.prepare(`DELETE FROM WorkflowDependencies
+          WHERE dependencyWorkflowId = ? AND dependentWorkflowId = ? AND tenantId = ?`).bind(dependencyWorkflowId, dependentWorkflowId, tenantId).run(), context.retryConfig);
 }
 
 //#endregion
@@ -917,7 +989,7 @@ const createCleanupManager = (context) => {
 	const getAffectedWorkflows = async (config, limit) => {
 		const { statuses, statusPlaceholders } = buildStatusesAndPlaceholders(config);
 		if (statuses.length === 0) return [];
-		const result = await context.D1.prepare(`
+		const result = await retryD1Operation(() => context.D1.prepare(`
       SELECT instanceId, inputRef
       FROM WorkflowTable
       WHERE tenantId = ? 
@@ -925,13 +997,13 @@ 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) => {
 		const { statuses, statusPlaceholders } = buildStatusesAndPlaceholders(config);
 		if (statuses.length === 0) return [];
-		const result = await context.D1.prepare(`
+		const result = await retryD1Operation(() => context.D1.prepare(`
       SELECT s.instanceId, s.stepName, s.stepStatus, s.errorRef, s.resultRef
       FROM StepTable s
       WHERE s.instanceId IN (
@@ -944,7 +1016,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) => {
@@ -997,15 +1069,15 @@ const createCleanupManager = (context) => {
 		}
 		if (deletedWorkflows.length > 0) {
 			console.log(`Proceeding to delete workflows from the database...`);
-			await 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);
 				const workflowIds = batch.map(() => "?").join(", ");
-				const result = await context.D1.prepare(`
+				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 {
@@ -1021,8 +1093,8 @@ const createCleanupManager = (context) => {
 		};
 	};
 	const cleanupOrphanedSteps = async (config, limit) => {
-		await context.D1.prepare(`PRAGMA foreign_keys = ON`).run();
-		const orphanedSteps = await context.D1.prepare(`
+		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
       WHERE s.tenantId = ?
@@ -1032,7 +1104,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) {
@@ -1048,11 +1120,11 @@ const createCleanupManager = (context) => {
 			for (let i = 0; i < orphanedStepResults.length; i += 99) {
 				const batch = orphanedStepResults.slice(i, i + 99);
 				const instanceIds = batch.map(() => "?").join(", ");
-				const deletedStepsResult = await context.D1.prepare(`
+				const deletedStepsResult = await retryD1Operation(() => context.D1.prepare(`
           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 {
@@ -1068,8 +1140,8 @@ const createCleanupManager = (context) => {
 		};
 	};
 	const cleanupOrphanedLogs = async (limit) => {
-		await context.D1.prepare(`PRAGMA foreign_keys = ON`).run();
-		const deletedLogsResult = await context.D1.prepare(`
+		await retryD1Operation(() => context.D1.prepare(`PRAGMA foreign_keys = ON`).run(), context.retryConfig);
+		const deletedLogsResult = await retryD1Operation(() => context.D1.prepare(`
       DELETE FROM LogTable
       WHERE tenantId = ?
         AND (
@@ -1084,7 +1156,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 {
@@ -1272,7 +1344,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 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;
@@ -1299,7 +1371,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 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({
@@ -1316,7 +1388,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 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,
@@ -1337,10 +1409,10 @@ 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 dependenciesResult = await context.D1.prepare(`SELECT w.*, wd.createdAt, wd.dependentWorkflowId
+					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,
@@ -1367,10 +1439,10 @@ 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 dependentsResult = await context.D1.prepare(`SELECT w.*, wd.createdAt, wd.dependencyWorkflowId
+					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,
@@ -1395,7 +1467,7 @@ const createLogAccessor = (context) => {
 		return [];
 	};
 	const getWorkflowByParentId = async (parentInstanceId) => {
-		const result = await 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,
@@ -1407,7 +1479,7 @@ const createLogAccessor = (context) => {
 		return null;
 	};
 	const getWorkflowByTriggerId = async (triggerId) => {
-		const result = await 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,
@@ -1419,12 +1491,12 @@ const createLogAccessor = (context) => {
 		return null;
 	};
 	const getWorkflowTypesByTenantId = async (tenantId) => {
-		const result = await 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 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,
@@ -1434,7 +1506,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 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,
@@ -1465,7 +1537,7 @@ const createLogAccessor = (context) => {
 			retryWorkflow.isRetryOf = workflow;
 		});
 		workflow.isRetryOf = parentWorkflow;
-		const allLogs = await 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,
@@ -1481,10 +1553,10 @@ const createLogAccessor = (context) => {
 		const properties = await getWorkflowProperties(instanceId);
 		workflow.properties = properties;
 		if (populateDependencies) {
-			const dependenciesResult = await context.D1.prepare(`SELECT w.*, wd.createdAt 
+			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,
@@ -1500,10 +1572,10 @@ const createLogAccessor = (context) => {
 			}));
 		}
 		if (populateDependents) {
-			const dependentsResult = await context.D1.prepare(`SELECT w.*, wd.createdAt 
+			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,
@@ -1521,7 +1593,7 @@ const createLogAccessor = (context) => {
 		return workflow;
 	};
 	const getStep = async (instanceId, stepName) => {
-		const result = await 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;
@@ -1538,7 +1610,7 @@ const createLogAccessor = (context) => {
 			error: deserializedError,
 			logs: []
 		};
-		const logResult = await 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,
@@ -1549,10 +1621,10 @@ const createLogAccessor = (context) => {
 		return step;
 	};
 	const getPropertiesKeys = async (instanceId) => {
-		const result = await context.D1.prepare(`
+		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) => ({
@@ -1575,7 +1647,7 @@ const createLogAccessor = (context) => {
 			bindings.push(toTime);
 		}
 		const whereClause = whereConditions.length > 0 ? `WHERE ${whereConditions.join(" AND ")}` : "";
-		const result = await context.D1.prepare(`
+		const result = await retryD1Operation(() => context.D1.prepare(`
       SELECT 
         workflowType,
         COUNT(*) as workflowCount,
@@ -1618,7 +1690,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,
@@ -1806,7 +1878,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,
@@ -1853,7 +1926,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;
@@ -1931,9 +2004,9 @@ async function createStepContext(context) {
 			const stepStatus$1 = "completed";
 			const { data: resultData, externalRef: resultRef } = await serializeWithExternalStorage(result, context.serializer, context.externalBlobStorage);
 			const stepError$1 = null;
-			await context.D1.prepare(`UPDATE StepTable
+			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) {
@@ -1941,9 +2014,9 @@ async function createStepContext(context) {
 			const stepStatus$1 = "failed";
 			const stepResult$1 = null;
 			const { data: errorData, externalRef: errorRef } = await serializeWithExternalStorage(error, context.serializer, context.externalBlobStorage);
-			await context.D1.prepare(`UPDATE StepTable
+			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;
 		}
@@ -1962,14 +2035,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);
@@ -2025,7 +2099,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, {
@@ -2045,7 +2120,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({
@@ -2095,10 +2173,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 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}`);
@@ -2204,4 +2282,4 @@ function createR2ExternalBlobStorage(options) {
 }
 
 //#endregion
-export { createCleanupManager, createLogAccessor, createQueueWorkflowContext, createR2ExternalBlobStorage, createStepContext, createWorkflowContext, createWorkflowDependencies, createWorkflowDependency, defaultIdFactory, defaultSerializer, defineWorkflow, deleteWorkflowDependency, deserializeWithExternalStorage, ensureTables, finalizeWorkflowRecord, insertStepRecordFull, insertWorkflowRecord, pushLogToDB, serializeWithExternalStorage, tryDeserializeObj, updateWorkflow, updateWorkflowName, upsertWorkflowProperty, workflowTableRowToWorkflowRun };
+export { createCleanupManager, createLogAccessor, createQueueWorkflowContext, createR2ExternalBlobStorage, createStepContext, createWorkflowContext, createWorkflowDependencies, createWorkflowDependency, defaultIdFactory, defaultSerializer, defineWorkflow, deleteWorkflowDependency, deserializeWithExternalStorage, ensureTables, finalizeWorkflowRecord, insertStepRecordFull, insertWorkflowRecord, pushLogToDB, retryD1Operation, serializeWithExternalStorage, tryDeserializeObj, updateWorkflow, updateWorkflowName, upsertWorkflowProperty, workflowTableRowToWorkflowRun };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brandboostinggmbh/observable-workflows",
-  "version": "0.19.0-beta.4",
+  "version": "0.20.0-beta.5",
   "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"
   }
 }