@brandboostinggmbh/observable-workflows 0.0.2 → 0.1.0

package/dist/index.d.ts

@@ -1,6 +1,284 @@
-//#region src/index.d.ts
-declare const foo = "foo";
-declare function fn(): void;
+//#region src/observableWorkflows/createStepContext.d.ts
+declare function createStepContext(context: StepContextOptions): Promise<(<RESULT>(step: {
+  name: string;
+  metadata?: Record<string, any>;
+}, callback: (ctx: StepCtx) => Promise<RESULT>) => Promise<RESULT>)>;
 
 //#endregion
-export { fn, foo };
+//#region src/observableWorkflows/helperFunctions.d.ts
+declare function finalizeWorkflowRecord(options: InternalWorkflowContextOptions, {
+  workflowStatus,
+  endTime,
+  instanceId
+}: {
+  workflowStatus: StepWorkflowStatus;
+  endTime: number;
+  instanceId: string;
+}): Promise<D1Result<Record<string, unknown>>>;
+declare function insertWorkflowRecord(options: InternalWorkflowContextOptions, {
+  instanceId,
+  workflowType,
+  workflowName,
+  workflowMetadata,
+  input,
+  workflowStatus,
+  startTime,
+  endTime,
+  parentInstanceId
+}: {
+  instanceId: string;
+  workflowType: string;
+  workflowName: string;
+  workflowMetadata: any;
+  input: any;
+  workflowStatus: StepWorkflowStatus;
+  startTime: number;
+  endTime?: number | null;
+  parentInstanceId?: string | null;
+}): Promise<D1Result<Record<string, unknown>>>;
+declare function insertStepRecordFull(context: StepContextOptions, {
+  instanceId,
+  name,
+  status,
+  metadata,
+  startTime,
+  endTime,
+  result,
+  error
+}: {
+  instanceId: string;
+  name: string;
+  status: StepWorkflowStatus;
+  metadata: string;
+  startTime: number;
+  endTime: number | null;
+  result: string | null;
+  error: string | null;
+}): Promise<D1Result<Record<string, unknown>>>;
+declare function pushLogToDB(options: InternalWorkflowContextOptions, {
+  instanceId,
+  stepName,
+  message,
+  timestamp,
+  type,
+  logOrder
+}: {
+  instanceId: string;
+  stepName: string | null;
+  message: string;
+  timestamp: number;
+  type: string;
+  logOrder: number;
+}): Promise<D1Result<Record<string, unknown>>>;
+declare function tryDeserializeObj(obj: string, serializer: Serializer): any;
+/**
+ * We want to save steps to a databse, we are using D1, so SQLite is the database.
+ * Step Table:
+ * - instanceId: string
+ * - stepName: string
+ * - stepStatus: string (pending, completed, failed)
+ * - stepMetadata: string (JSON)
+ * - startTime: number (timestamp)
+ * - endTime: number (timestamp) (optional)
+ * - result: string (JSON) (optional)
+ * - error: string (JSON) (optional)
+ *
+ * Log Table:
+ * - instanceId: string
+ * - stepName: string
+ * - log: string
+ * - timestamp: number (timestamp)
+ * - type: string (info, error, warning)
+ */
+/**
+ * Ensure that the required tables exist in D1 (SQLite).
+ */
+declare function ensureTables(db: D1Database): Promise<void>;
+declare function workflowTableRowToWorkflowRun(row: {
+  instanceId: string;
+  workflowType: string;
+  workflowName: string;
+  input: string;
+  tenantId: string;
+  workflowStatus: StepWorkflowStatus;
+  startTime: number;
+  endTime: number | null;
+  parentInstanceId: string | null;
+}, serializer: Serializer): WorkflowRun;
+declare function updateWorkflowName(context: {
+  D1: D1Database;
+}, instanceId: string, newWorkflowName: string): Promise<D1Result<Record<string, unknown>>>;
+type ValueTypeMap = {
+  string: string;
+  number: number;
+  boolean: boolean;
+  object: object;
+};
+type PossibleValueTypeNames = keyof ValueTypeMap;
+type PossibleValueTypes = ValueTypeMap[PossibleValueTypeNames];
+declare function upsertWorkflowProperty<T extends keyof ValueTypeMap>({
+  context,
+  instanceId,
+  key,
+  valueType,
+  value
+}: {
+  context: InternalWorkflowContextOptions;
+  instanceId: string;
+  key: string;
+  valueType: T;
+  value: ValueTypeMap[T];
+}): Promise<boolean>;
+
+//#endregion
+//#region src/observableWorkflows/types.d.ts
+type StepContextOptions = {
+  D1: D1Database;
+  tenantId: string;
+  instanceId: string;
+  /** If the currect execution is a retry, this field references the original execution. */
+  parentInstanceId?: string;
+  serializer: Serializer;
+  idFactory: () => string;
+};
+type ConsoleWrapper = {
+  log: (message: string) => void;
+  info: (message: string) => void;
+  error: (message: string) => void;
+  warn: (message: string) => void;
+};
+type StepCtx = {
+  console: ConsoleWrapper;
+};
+type Log = {
+  instanceId: string;
+  stepName: string | null;
+  log: string;
+  timestamp: number;
+  type: 'info' | 'error' | 'warn';
+};
+type StepWorkflowStatus = 'pending' | 'completed' | 'failed';
+type Step = {
+  instanceId: string;
+  name: string;
+  metadata: Record<string, any>;
+  status: StepWorkflowStatus;
+  startTime: number;
+  endTime: number | null;
+  result: any | null;
+  error: any | null;
+  logs?: Log[];
+  tenantId?: string;
+};
+type WorkflowRun = {
+  instanceId: string;
+  workflowType: string;
+  workflowName: string;
+  input: any;
+  tenantId: string;
+  workflowStatus: StepWorkflowStatus;
+  startTime: number;
+  endTime: number | null;
+  parentInstanceId: string | null;
+  steps?: Step[];
+  /** All Logs associated with the workflow. Includes logs that are part of steps */
+  logs?: Log[];
+  isRetryOf?: WorkflowRun | null;
+  retries?: WorkflowRun[] | null;
+  properties?: WorkflowProperty[];
+};
+type WorkflowProperty<T extends keyof ValueTypeMap = keyof ValueTypeMap> = {
+  key: string;
+  valueType: T;
+  value: ValueTypeMap[T];
+};
+type WorkflowPropertyDefinition = {
+  key: string;
+  valueType: 'string' | 'number' | 'boolean' | 'object';
+};
+type StepContext = Awaited<ReturnType<typeof createStepContext>>;
+type Serializer = {
+  serialize: (data: any) => string;
+  deserialize: (data: string) => any;
+};
+type WorkflowContextOptions = {
+  D1: D1Database;
+  tenantId: string;
+  idFactory?: () => string;
+  serializer?: Serializer;
+};
+type InternalWorkflowContextOptions = WorkflowContextOptions & Required<Pick<WorkflowContextOptions, 'serializer' | 'idFactory'>>;
+type QueueWorkflowContextOptions = {
+  QUEUE: Queue<WorkflowQueueMessage>;
+  serializer?: Serializer;
+  idFactory?: () => string;
+};
+type WorkflowContext = {
+  step: StepContext;
+  console: ConsoleWrapper;
+  setWorkflowName: (newName: string) => Promise<void>;
+  setWorkflowProperty: <T extends keyof ValueTypeMap>(key: string, valueType: T, value: ValueTypeMap[T]) => Promise<void>;
+};
+type WorkflowFunction<INPUT, TYPE extends string = string> = {
+  workflowType: TYPE;
+  metadata: Record<string, any>;
+  /**
+   * The code that will be executed.
+   * Do not call this directly.
+   * Use either the WorkflowContect, or the QueueWorkflowContext to run or enqueue this. */
+  _callback: (input: INPUT, ctx: WorkflowContext) => Promise<any>;
+};
+type WorkflowQueueMessage = {
+  type: 'workflow-run';
+  workflowType: string;
+  workflowName: string;
+  tenantId: string;
+  input: any;
+} | {
+  type: 'workflow-retry';
+  workflowType: string;
+  tenantId: string;
+  retryInstanceId: string;
+};
+
+//#endregion
+//#region src/observableWorkflows/defineWorkflow.d.ts
+declare function defineWorkflow<I extends {} | null>(workflow: {
+  workflowType: string;
+  metadata?: Record<string, any>;
+}, callback: (input: I, ctx: WorkflowContext) => Promise<any>): WorkflowFunction<I>;
+
+//#endregion
+//#region src/observableWorkflows/createWorkflowContext.d.ts
+declare function createWorkflowContext(options: WorkflowContextOptions): Promise<{
+  call: <I>(workflow: WorkflowFunction<I>, input: I, workflowName: string, parentInstanceId?: string | undefined) => Promise<void>;
+  retry: <I>(workflow: WorkflowFunction<I>, retryInstanceId: string) => Promise<void>;
+}>;
+
+//#endregion
+//#region src/observableWorkflows/createQueueWorkflowContext.d.ts
+declare function createQueueWorkflowContext(options: QueueWorkflowContextOptions): {
+  enqueueWorkflow: <I>(workflow: WorkflowFunction<I>, tenantId: string, input: I, initialName: string) => Promise<void>;
+  enqueueRetryWorkflow: <I>(workflow: WorkflowFunction<I>, tenantId: string, oldInstanceId: string) => Promise<void>;
+  handleWorkflowQueueMessage: <T>(message: WorkflowQueueMessage, env: {
+    LOG_DB: D1Database;
+  }, workflowResolver: (workflowType: string) => WorkflowFunction<T> | undefined) => Promise<void>;
+};
+
+//#endregion
+//#region src/observableWorkflows/createLogAccessor.d.ts
+declare const createLogAccessor: (context: {
+  D1: D1Database;
+  tenantId: string;
+  serializer: Serializer;
+}) => {
+  listSteps: (limit: number, offset: number, instanceId?: string | undefined) => Promise<Step[]>;
+  getStep: (instanceId: string, stepName: string) => Promise<Step | null>;
+  listWorkflows: (limit: number, offset: number) => Promise<WorkflowRun[]>;
+  getWorkflow: (instanceId: string) => Promise<WorkflowRun | null>;
+  getWorkflowTypesByTenantId: (tenantId: string) => Promise<string[]>;
+  getPropertiesKeys: (instanceId?: string) => Promise<WorkflowPropertyDefinition[]>;
+};
+
+//#endregion
+export { ConsoleWrapper, InternalWorkflowContextOptions, Log, PossibleValueTypeNames, PossibleValueTypes, QueueWorkflowContextOptions, Serializer, Step, StepContextOptions, StepCtx, StepWorkflowStatus, ValueTypeMap, WorkflowContext, WorkflowContextOptions, WorkflowFunction, WorkflowProperty, WorkflowPropertyDefinition, WorkflowQueueMessage, WorkflowRun, createLogAccessor, createQueueWorkflowContext, createStepContext, createWorkflowContext, defineWorkflow, ensureTables, finalizeWorkflowRecord, insertStepRecordFull, insertWorkflowRecord, pushLogToDB, tryDeserializeObj, updateWorkflowName, upsertWorkflowProperty, workflowTableRowToWorkflowRun };

package/dist/index.js

@@ -1,8 +1,617 @@
-//#region src/index.ts
-const foo = "foo";
-function fn() {
-	return;
+//#region src/observableWorkflows/helperFunctions.ts
+function finalizeWorkflowRecord(options, { workflowStatus, endTime, instanceId }) {
+	return options.D1.prepare(
+		/* sql */
+		`UPDATE WorkflowTable
+          SET workflowStatus = ?, endTime = ?
+          WHERE instanceId = ?`
+).bind(workflowStatus, endTime, instanceId).run();
 }
+function insertWorkflowRecord(options, { instanceId, workflowType, workflowName, workflowMetadata, input, workflowStatus, startTime, endTime, parentInstanceId }) {
+	return options.D1.prepare(
+		/* sql */
+		`INSERT INTO WorkflowTable
+        (instanceId, workflowType, workflowName, workflowMetadata, input, tenantId, workflowStatus, startTime, endTime, parentInstanceId)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+).bind(instanceId, workflowType, workflowName, options.serializer.serialize(workflowMetadata), options.serializer.serialize(input), options.tenantId, workflowStatus, startTime, endTime ?? null, parentInstanceId ?? null).run();
+}
+function insertStepRecordFull(context, { instanceId, name, status, metadata, startTime, endTime, result, error }) {
+	return context.D1.prepare(
+		/* sql */
+		`INSERT INTO StepTable
+            (instanceId, stepName, stepStatus, stepMetadata, startTime, endTime, result, error, tenantId)
+            VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+).bind(instanceId, name, status, metadata, startTime, endTime, result, error, context.tenantId).run();
+}
+function pushLogToDB(options, { instanceId, stepName, message, timestamp, type, logOrder }) {
+	return options.D1.prepare(
+		/* sql */
+		`INSERT INTO LogTable
+           (instanceId, stepName, log, timestamp, type, logOrder, tenantId)
+           VALUES (?, ?, ?, ?, ?, ?, ?)`
+).bind(instanceId, stepName, message, timestamp, type, logOrder, options.tenantId).run();
+}
+function tryDeserializeObj(obj, serializer) {
+	try {
+		return serializer.deserialize(obj);
+	} catch (error) {
+		console.error("Error deserializing object:", error);
+		return obj;
+	}
+}
+/**
+* We want to save steps to a databse, we are using D1, so SQLite is the database.
+* Step Table:
+* - instanceId: string
+* - stepName: string
+* - stepStatus: string (pending, completed, failed)
+* - stepMetadata: string (JSON)
+* - startTime: number (timestamp)
+* - endTime: number (timestamp) (optional)
+* - result: string (JSON) (optional)
+* - error: string (JSON) (optional)
+*
+* Log Table:
+* - instanceId: string
+* - stepName: string
+* - log: string
+* - timestamp: number (timestamp)
+* - type: string (info, error, warning)
+*/
+/**
+* Ensure that the required tables exist in D1 (SQLite).
+*/
+async function ensureTables(db) {
+	const s1 = db.prepare(
+		/* sql */
+		`CREATE TABLE IF NOT EXISTS WorkflowTable (
+        instanceId TEXT NOT NULL,
+        workflowType TEXT NOT NULL,
+        workflowName TEXT NOT NULL,
+        workflowMetadata TEXT NOT NULL,
+        input TEXT NOT NULL,
+        tenantId TEXT NOT NULL,
+        workflowStatus TEXT NOT NULL,
+        startTime INTEGER NOT NULL,
+        endTime INTEGER,
+        parentInstanceId TEXT,
+        PRIMARY KEY (instanceId)
+    )`
+);
+	const s2 = db.prepare(
+		/* sql */
+		`CREATE TABLE IF NOT EXISTS StepTable (
+          instanceId TEXT NOT NULL,
+          stepName TEXT NOT NULL,
+          stepStatus TEXT NOT NULL,
+          stepMetadata TEXT NOT NULL,
+          startTime INTEGER NOT NULL,
+          endTime INTEGER,
+          result TEXT,
+          error TEXT,
+          tenantId TEXT NOT NULL,
+          PRIMARY KEY (instanceId, stepName)
+      )`
+);
+	const s3 = db.prepare(
+		/* sql */
+		`CREATE TABLE IF NOT EXISTS LogTable (
+        instanceId TEXT NOT NULL,
+        stepName TEXT,
+        log TEXT NOT NULL,
+        timestamp INTEGER NOT NULL,
+        type TEXT NOT NULL,
+        logOrder INTEGER NOT NULL,
+        tenantId TEXT NOT NULL,
+        FOREIGN KEY (instanceId, stepName) REFERENCES StepTable(instanceId, stepName)
+        DEFERRABLE INITIALLY DEFERRED  -- Makes constraint check at commit time, this is needed, since stepName is nullable in the log table.
+        
+    )`
+);
+	const s7 = db.prepare(
+		/* sql */
+		`
+      CREATE TABLE IF NOT EXISTS WorkflowProperties (
+        instanceId TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value TEXT NOT NULL,
+        valueType TEXT NOT NULL,
+        tenantId TEXT NOT NULL,
+        PRIMARY KEY (instanceId, key),
+        FOREIGN KEY (instanceId) REFERENCES WorkflowTable(instanceId)
+        ON DELETE CASCADE
+      )`
+);
+	const s6 = db.prepare(
+		/* sql */
+		`
+    CREATE INDEX IF NOT EXISTS idx_workflows_parent_instance_id ON WorkflowTable (parentInstanceId)
+    `
+);
+	const p1 = db.prepare(`PRAGMA foreign_keys = ON`);
+	await db.batch([
+		s1,
+		s2,
+		s3,
+		s6,
+		s7,
+		p1
+	]);
+}
+function workflowTableRowToWorkflowRun(row, serializer) {
+	return {
+		instanceId: row.instanceId,
+		workflowType: row.workflowType,
+		workflowName: row.workflowName,
+		input: tryDeserializeObj(row.input, serializer),
+		tenantId: row.tenantId,
+		workflowStatus: row.workflowStatus,
+		startTime: row.startTime,
+		endTime: row.endTime,
+		parentInstanceId: row.parentInstanceId
+	};
+}
+async function updateWorkflowName(context, instanceId, newWorkflowName) {
+	return await context.D1.prepare(
+		/* sql */
+		`UPDATE WorkflowTable
+          SET workflowName = ?
+          WHERE instanceId = ?`
+).bind(newWorkflowName, instanceId).run();
+}
+async function upsertWorkflowProperty({ context, instanceId, key, valueType, value }) {
+	const serializedValue = valueType === "object" ? JSON.stringify(value) : String(value);
+	const res = await context.D1.prepare(
+		/* sql */
+		`INSERT OR REPLACE INTO WorkflowProperties
+          (instanceId, key, value, valueType, tenantId)
+          VALUES (?, ?, ?, ?, ?)`
+).bind(instanceId, key, serializedValue, valueType, context.tenantId).run();
+	if (res.error) {
+		console.error("Error inserting workflow property:", res.error);
+		return false;
+	}
+	return res.success;
+}
+
+//#endregion
+//#region src/observableWorkflows/defineWorkflow.ts
+function defineWorkflow(workflow, callback) {
+	return {
+		workflowType: workflow.workflowType,
+		metadata: workflow.metadata || {},
+		_callback: callback
+	};
+}
+
+//#endregion
+//#region src/observableWorkflows/createStepContext.ts
+async function createStepContext(context) {
+	const instanceId = context.instanceId;
+	await ensureTables(context.D1);
+	const step = async (step$1, callback) => {
+		if (context.parentInstanceId) {
+			const existingStep = await context.D1.prepare(
+				/* sql */
+				`SELECT * FROM StepTable WHERE instanceId = ? AND stepName = ? AND tenantId = ?`
+).bind(context.parentInstanceId, step$1.name, context.tenantId).first();
+			if (existingStep) {
+				const row = existingStep;
+				if (row.status === "completed") {
+					await insertStepRecordFull(context, {
+						instanceId,
+						name: row.name,
+						status: row.status,
+						metadata: row.metadata,
+						startTime: row.startTime,
+						endTime: row.endTime,
+						result: row.result,
+						error: row.error
+					});
+					return context.serializer.deserialize(row.result);
+				}
+			}
+		}
+		let waitFor = [];
+		const startTime = Date.now();
+		const stepStatus = "pending";
+		const stepMetadata = context.serializer.serialize(step$1.metadata || {});
+		const stepName = step$1.name;
+		const stepResult = null;
+		const stepError = null;
+		await insertStepRecordFull(context, {
+			instanceId,
+			name: stepName,
+			status: stepStatus,
+			metadata: stepMetadata,
+			startTime,
+			endTime: null,
+			result: stepResult,
+			error: stepError
+		});
+		let logOrder = 0;
+		const log = (message, type = "info") => {
+			logOrder++;
+			const timestamp = Date.now();
+			const logPromise = pushLogToDB(context, {
+				stepName: step$1.name,
+				instanceId,
+				message,
+				timestamp,
+				type,
+				logOrder
+			});
+			waitFor.push(logPromise);
+		};
+		const ctx = { console: {
+			log: (message) => {
+				log(message, "info");
+			},
+			info: (message) => {
+				log(message, "info");
+			},
+			error: (message) => {
+				log(message, "error");
+			},
+			warn: (message) => {
+				log(message, "warn");
+			}
+		} };
+		try {
+			const result = await callback(ctx);
+			const endTime = Date.now();
+			const stepStatus$1 = "completed";
+			let stepResult$1 = null;
+			try {
+				stepResult$1 = result ? context.serializer.serialize(result) : null;
+			} catch {
+				stepResult$1 = String(result);
+			}
+			const stepError$1 = null;
+			await context.D1.prepare(
+				/* sql */
+				`UPDATE StepTable
+          SET stepStatus = ?, endTime = ?, result = ?, error = ?
+          WHERE instanceId = ? AND stepName = ?`
+).bind(stepStatus$1, endTime, stepResult$1, stepError$1, instanceId, stepName).run();
+			await Promise.allSettled(waitFor);
+			return result;
+		} catch (error) {
+			const endTime = Date.now();
+			const stepStatus$1 = "failed";
+			const stepResult$1 = null;
+			let stepError$1;
+			try {
+				stepError$1 = context.serializer.serialize(error);
+			} catch {
+				stepError$1 = String(error);
+			}
+			await context.D1.prepare(
+				/* sql */
+				`UPDATE StepTable
+          SET stepStatus = ?, endTime = ?, result = ?, error = ?
+          WHERE instanceId = ? AND stepName = ?`
+).bind(stepStatus$1, endTime, stepResult$1, stepError$1, instanceId, stepName).run();
+			await Promise.allSettled(waitFor);
+			throw error;
+		}
+	};
+	return step;
+}
+
+//#endregion
+//#region src/observableWorkflows/createWorkflowContext.ts
+async function createWorkflowContext(options) {
+	await ensureTables(options.D1);
+	const internalContext = {
+		...options,
+		serializer: options.serializer ?? {
+			serialize: JSON.stringify,
+			deserialize: JSON.parse
+		},
+		idFactory: options.idFactory ?? (() => crypto.randomUUID())
+	};
+	const call = async (workflow, input, workflowName, parentInstanceId = void 0) => {
+		const instanceId = internalContext.idFactory();
+		const startTime = Date.now();
+		await insertWorkflowRecord(internalContext, {
+			instanceId,
+			workflowType: workflow.workflowType,
+			workflowName,
+			workflowMetadata: workflow.metadata,
+			input,
+			workflowStatus: "pending",
+			startTime,
+			endTime: null,
+			parentInstanceId
+		});
+		let waitFor = [];
+		let logOrder = 0;
+		const log = (message, type = "info") => {
+			logOrder++;
+			const timestamp = Date.now();
+			const logPromise = pushLogToDB(internalContext, {
+				instanceId,
+				stepName: null,
+				message,
+				timestamp,
+				type,
+				logOrder
+			});
+			waitFor.push(logPromise);
+		};
+		const stepContext = await createStepContext({
+			D1: options.D1,
+			tenantId: options.tenantId,
+			instanceId,
+			serializer: internalContext.serializer,
+			idFactory: internalContext.idFactory
+		});
+		try {
+			await workflow._callback(input, {
+				step: stepContext,
+				console: {
+					log: (message) => {
+						log(message, "info");
+					},
+					info: (message) => {
+						log(message, "info");
+					},
+					error: (message) => {
+						log(message, "error");
+					},
+					warn: (message) => {
+						log(message, "warn");
+					}
+				},
+				async setWorkflowName(newName) {
+					await updateWorkflowName({ D1: options.D1 }, instanceId, newName);
+				},
+				async setWorkflowProperty(key, valueType, value) {
+					await upsertWorkflowProperty({
+						context: internalContext,
+						instanceId,
+						key,
+						valueType,
+						value
+					});
+				}
+			});
+			const endTime = Date.now();
+			const workflowStatus = "completed";
+			await finalizeWorkflowRecord(internalContext, {
+				workflowStatus,
+				endTime,
+				instanceId
+			});
+			await Promise.allSettled(waitFor);
+		} catch (error) {
+			const endTime = Date.now();
+			const workflowStatus = "failed";
+			await finalizeWorkflowRecord(internalContext, {
+				workflowStatus,
+				endTime,
+				instanceId
+			});
+			await Promise.allSettled(waitFor);
+			throw error;
+		}
+	};
+	const retry = async (workflow, retryInstanceId) => {
+		const oldRun = await options.D1.prepare(
+			/* sql */
+			`SELECT input, workflowName FROM WorkflowTable WHERE instanceId = ? `
+).bind(retryInstanceId).first();
+		const oldWorkflowName = oldRun?.workflowName;
+		const encodedInput = oldRun?.input;
+		if (!encodedInput) throw new Error(`No input found for instanceId ${retryInstanceId}`);
+		const input = JSON.parse(encodedInput);
+		await call(workflow, input, oldWorkflowName ?? "unknown", retryInstanceId);
+	};
+	return {
+		call,
+		retry
+	};
+}
+
+//#endregion
+//#region src/observableWorkflows/createQueueWorkflowContext.ts
+function createQueueWorkflowContext(options) {
+	const enqueueWorkflow = async (workflow, tenantId, input, initialName) => {
+		await options.QUEUE.send({
+			type: "workflow-run",
+			workflowType: workflow.workflowType,
+			workflowName: initialName,
+			input,
+			tenantId
+		});
+	};
+	const enqueueRetryWorkflow = async (workflow, tenantId, oldInstanceId) => {
+		await options.QUEUE.send({
+			type: "workflow-retry",
+			workflowType: workflow.workflowType,
+			retryInstanceId: oldInstanceId,
+			tenantId
+		});
+	};
+	const handleWorkflowQueueMessage = async (message, env, workflowResolver) => {
+		const workflowFunction = workflowResolver(message.workflowType);
+		if (!workflowFunction) throw new Error(`Workflow ${message.workflowType} not found`);
+		const wfc = await createWorkflowContext({
+			D1: env.LOG_DB,
+			tenantId: message.tenantId,
+			serializer: options.serializer,
+			idFactory: options.idFactory
+		});
+		if (message.type === "workflow-run") {
+			console.log("running workflow", message.input);
+			await wfc.call(workflowFunction, message.input, message.workflowName);
+		} else if (message.type === "workflow-retry") {
+			console.log("retrying workflow", message.retryInstanceId);
+			await wfc.retry(workflowFunction, message.retryInstanceId);
+		}
+	};
+	return {
+		enqueueWorkflow,
+		enqueueRetryWorkflow,
+		handleWorkflowQueueMessage
+	};
+}
+
+//#endregion
+//#region src/observableWorkflows/createLogAccessor.ts
+const createLogAccessor = (context) => {
+	const listSteps = async (limit, offset, instanceId) => {
+		const result = await context.D1.prepare(
+			/* sql */
+			`SELECT * FROM StepTable 
+    WHERE tenantId = ? AND (? IS NULL OR instanceId = ?)
+    ORDER BY startTime ASC LIMIT ? OFFSET ?`
+).bind(context.tenantId, instanceId ?? null, instanceId ?? null, limit, offset).all();
+		return result.results ? result.results.map((row) => ({
+			instanceId: row.instanceId,
+			name: row.stepName,
+			metadata: tryDeserializeObj(row.stepMetadata, context.serializer),
+			status: row.stepStatus,
+			startTime: row.startTime,
+			endTime: row.endTime,
+			result: row.result ? tryDeserializeObj(row.result, context.serializer) : null,
+			error: row.error ? tryDeserializeObj(row.error, context.serializer) : null
+		})) : [];
+	};
+	const listWorkflows = async (limit, offset) => {
+		const result = await context.D1.prepare(
+			/* sql */
+			`SELECT * 
+      FROM WorkflowTable
+      WHERE tenantId = ?
+      ORDER BY startTime DESC LIMIT ? OFFSET ?`
+).bind(context.tenantId, limit, offset).all();
+		return result.results ? result.results.map((row) => workflowTableRowToWorkflowRun(row, context.serializer)) : [];
+	};
+	const getWorkflowByParentId = async (parentInstanceId) => {
+		const result = await context.D1.prepare(
+			/* sql */
+			`SELECT * FROM WorkflowTable WHERE parentInstanceId = ? AND tenantId = ?`
+).bind(parentInstanceId, context.tenantId).all();
+		return result.results ? result.results.map((row) => workflowTableRowToWorkflowRun(row, context.serializer)) : null;
+	};
+	const getWorkflowTypesByTenantId = async (tenantId) => {
+		const result = await context.D1.prepare(
+			/* sql */
+			`SELECT DISTINCT workflowType FROM WorkflowTable WHERE tenantId = ?`
+).bind(tenantId).all();
+		if (!result.results) return [];
+		return result.results.map((row) => row.workflowType);
+	};
+	const getWorkflowProperties = async (instanceId) => {
+		const result = await context.D1.prepare(
+			/* sql */
+			`SELECT * FROM WorkflowProperties WHERE instanceId = ?`
+).bind(instanceId).all();
+		if (!result.results) return [];
+		return result.results.map((row) => ({
+			key: row.key,
+			valueType: row.valueType,
+			value: tryDeserializeObj(row.value, context.serializer)
+		}));
+	};
+	/** This function gets the basic data of a workflow, without populating any of it's complex fields */
+	const getWorkflowShallow = async (instanceId) => {
+		const result = await context.D1.prepare(
+			/* sql */
+			`SELECT * FROM WorkflowTable WHERE instanceId = ? AND tenantId = ?`
+).bind(instanceId, context.tenantId).first();
+		if (!result) return null;
+		const workflow = workflowTableRowToWorkflowRun(result, context.serializer);
+		return workflow;
+	};
+	const getWorkflow = async (instanceId) => {
+		const workflow = await getWorkflowShallow(instanceId);
+		if (!workflow) return null;
+		const steps = await listSteps(100, 0, instanceId);
+		const retryWorkflows = await getWorkflowByParentId(instanceId);
+		const parentWorkflow = workflow.parentInstanceId ? await getWorkflowShallow(workflow.parentInstanceId) : null;
+		workflow.retries = retryWorkflows;
+		retryWorkflows?.forEach((retryWorkflow) => {
+			retryWorkflow.isRetryOf = workflow;
+		});
+		workflow.isRetryOf = parentWorkflow;
+		const allLogs = await context.D1.prepare(
+			/* sql */
+			`SELECT * FROM LogTable WHERE instanceId = ? ORDER BY timestamp ASC, logOrder ASC`
+).bind(instanceId).all();
+		const logs = allLogs.results?.map((logRow) => ({
+			instanceId: logRow.instanceId,
+			stepName: logRow.stepName,
+			log: logRow.log,
+			timestamp: logRow.timestamp,
+			type: logRow.type
+		}));
+		steps.forEach((step) => {
+			step.logs = logs?.filter((log) => log.stepName === step.name) ?? [];
+		});
+		workflow.steps = steps;
+		workflow.logs = logs;
+		const properties = await getWorkflowProperties(instanceId);
+		workflow.properties = properties;
+		return workflow;
+	};
+	const getStep = async (instanceId, stepName) => {
+		const result = await context.D1.prepare(
+			/* sql */
+			`SELECT * FROM StepTable WHERE instanceId = ? AND stepName = ? AND tenantId = ?`
+).bind(instanceId, stepName, context.tenantId).all();
+		if (!result.results || result.results.length === 0) return null;
+		const row = result.results[0];
+		if (!row) return null;
+		const step = {
+			instanceId: row.instanceId,
+			name: row.stepName,
+			metadata: tryDeserializeObj(row.stepMetadata, context.serializer),
+			status: row.stepStatus,
+			startTime: row.startTime,
+			endTime: row.endTime,
+			result: row.result ? tryDeserializeObj(row.result, context.serializer) : null,
+			error: row.error ? tryDeserializeObj(row.error, context.serializer) : null,
+			logs: []
+		};
+		const logResult = await context.D1.prepare(
+			/* sql */
+			`SELECT * FROM LogTable WHERE instanceId = ? AND stepName = ? ORDER BY logOrder ASC`
+).bind(instanceId, stepName).all();
+		if (logResult.results) step.logs = logResult.results.map((logRow) => ({
+			instanceId: logRow.instanceId,
+			stepName: logRow.stepName,
+			log: logRow.log,
+			timestamp: logRow.timestamp,
+			type: logRow.type
+		}));
+		return step;
+	};
+	const getPropertiesKeys = async (instanceId) => {
+		const result = await context.D1.prepare(
+			/* sql */
+			`
+      SELECT DISTINCT key, valueType FROM PropertiesTable
+      WHERE tenantId = ? AND (? IS NULL OR instanceId = ?)  
+      `
+).bind(context.tenantId, instanceId ?? null, instanceId ?? null).all();
+		if (!result.results) return [];
+		return result.results.map((row) => ({
+			key: row.key,
+			valueType: row.valueType
+		}));
+	};
+	return {
+		listSteps,
+		getStep,
+		listWorkflows,
+		getWorkflow,
+		getWorkflowTypesByTenantId,
+		getPropertiesKeys
+	};
+};
 
 //#endregion
-export { fn, foo };
+export { createLogAccessor, createQueueWorkflowContext, createStepContext, createWorkflowContext, defineWorkflow, ensureTables, finalizeWorkflowRecord, insertStepRecordFull, insertWorkflowRecord, pushLogToDB, tryDeserializeObj, updateWorkflowName, upsertWorkflowProperty, workflowTableRowToWorkflowRun };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brandboostinggmbh/observable-workflows",
-  "version": "0.0.2",
+  "version": "0.1.0",
   "description": "My awesome typescript library",
   "type": "module",
   "license": "MIT",
@@ -27,6 +27,7 @@
     "access": "public"
   },
   "devDependencies": {
+    "@cloudflare/workers-types": "^4.20250515.0",
     "@sxzz/eslint-config": "^7.0.1",
     "@sxzz/prettier-config": "^2.2.1",
     "@types/node": "^22.15.17",