@party-stack/ontology 0.18.0 → 0.19.1

package/lib/live/outbox/createOntologyOutbox.js

@@ -1,343 +1,292 @@
-import { createLocalCollection, isCoordinationHost, CoordinationError, } from "@party-stack/runtime";
-import { useConnectivityChanges } from "@party-stack/runtime/effection";
-import { createSignal, each, resource, run, spawn, suspend, until, useAbortSignal, } from "effection";
 import { runOutboxLeader } from "./leaderExecutor.js";
+import { OUTBOX_COORDINATION_SERVICE } from "./service.js";
 import { serveOntologyOutbox } from "./outboxService.js";
-import { decodeOutboxEntry, decodeOutboxRequest, encodeOutboxRequest } from "./outboxValues.js";
-import { OutboxProjectionManager } from "./projectionManager.js";
 import { OntologyOutboxRepository } from "./repository.js";
-import { OUTBOX_COORDINATION_SERVICE, } from "./service.js";
+import { OutboxProjectionManager } from "./projectionManager.js";
+import { CoordinationError, createLocalCollection, isCoordinationHost } from "@party-stack/runtime";
+import { cloneValue } from "@party-stack/coordination";
+import { useConnectivityChanges } from "@party-stack/runtime/effection";
+import { createSignal, each, resource, run, spawn, suspend, until, useAbortSignal } from "effection";
+//#region src/live/outbox/createOntologyOutbox.ts
 const DEFAULT_MAX_RETRIES = 3;
-const DEFAULT_RETRY_DELAY_MS = 1_000;
+const DEFAULT_RETRY_DELAY_MS = 1e3;
 function nonNegativeInteger(value, fallback, name) {
-    const resolved = value ?? fallback;
-    if (!Number.isSafeInteger(resolved) || resolved < 0) {
-        throw new RangeError(`${name} must be a non-negative safe integer.`);
-    }
-    return resolved;
+	const resolved = value ?? fallback;
+	if (!Number.isSafeInteger(resolved) || resolved < 0) throw new RangeError(`${name} must be a non-negative safe integer.`);
+	return resolved;
 }
 function deferred() {
-    let resolvePromise;
-    let rejectPromise;
-    const value = {
-        promise: undefined,
-        settled: false,
-        resolve(result) {
-            if (value.settled)
-                return;
-            value.settled = true;
-            resolvePromise(result);
-        },
-        reject(error) {
-            if (value.settled)
-                return;
-            value.settled = true;
-            rejectPromise(error);
-        },
-    };
-    value.promise = new Promise((resolve, reject) => {
-        resolvePromise = resolve;
-        rejectPromise = reject;
-    });
-    return value;
+	let resolvePromise;
+	let rejectPromise;
+	const value = {
+		promise: void 0,
+		settled: false,
+		resolve(result) {
+			if (value.settled) return;
+			value.settled = true;
+			resolvePromise(result);
+		},
+		reject(error) {
+			if (value.settled) return;
+			value.settled = true;
+			rejectPromise(error);
+		}
+	};
+	value.promise = new Promise((resolve, reject) => {
+		resolvePromise = resolve;
+		rejectPromise = reject;
+	});
+	return value;
 }
 function normalizeError(error) {
-    return error instanceof Error ? error : new Error(String(error));
+	return error instanceof Error ? error : new Error(String(error));
 }
 function eventError(event) {
-    const error = new Error(event.error.message);
-    error.name = event.error.name;
-    return error;
+	const error = new Error(event.error.message);
+	error.name = event.error.name;
+	return error;
 }
 function createOutboxCollection(options) {
-    return createLocalCollection({
-        name: "ontology-outbox",
-        getKey: (entry) => entry.id,
-        runtime: options.runtime,
-        schemaVersion: 1,
-    });
+	return createLocalCollection({
+		name: "ontology-outbox",
+		getKey: (entry) => entry.id,
+		runtime: options.runtime,
+		schemaVersion: 1
+	});
 }
-export function useOntologyOutbox(options, collection = createOutboxCollection(options)) {
-    return resource(function* (provide) {
-        const repository = new OntologyOutboxRepository(collection);
-        const failureStrategy = options.failureStrategy ?? "discard-all";
-        const service = options.runtime.coordination.service(OUTBOX_COORDINATION_SERVICE);
-        const wake = createSignal();
-        const projections = new OutboxProjectionManager(options.project ? async (entry) => options.project?.(decodeOutboxEntry(entry)) : undefined);
-        const completions = new Map();
-        const lifetime = {};
-        let disposing = false;
-        let reconciliationVersion = 0;
-        const deliverResult = async (event) => {
-            const completion = completions.get(event.id);
-            if (event.type === "completed") {
-                await projections.discard(event.id);
-                if (completion) {
-                    completions.delete(event.id);
-                    completion.resolve(event.result);
-                }
-                return;
-            }
-            const error = eventError(event);
-            await projections.discard(event.id, error);
-            if (completion) {
-                completions.delete(event.id);
-                completion.reject(error);
-            }
-        };
-        try {
-            lifetime.unsubscribeResults =
-                service.events.subscribe("result", (event) => {
-                    void deliverResult(event);
-                });
-            yield* until(repository.preload());
-            if (isCoordinationHost(options.runtime.coordination)) {
-                lifetime.server = serveOntologyOutbox(options.runtime.coordination, repository);
-            }
-            const reconcileProjections = async () => {
-                const version = ++reconciliationVersion;
-                const entries = await repository.entries();
-                if (disposing || version !== reconciliationVersion) {
-                    return;
-                }
-                await projections.reconcile(entries);
-            };
-            lifetime.unsubscribeCollection = collection.subscribeChanges(() => {
-                wake.send();
-                void reconcileProjections();
-            });
-            lifetime.unsubscribeConnection =
-                options.connection
-                    ? {
-                        unsubscribe: options.connection.subscribe(() => {
-                            wake.send();
-                        }),
-                    }
-                    : undefined;
-            const existing = yield* until(repository.entries());
-            yield* until(projections.restore(existing));
-            const connectivityChanges = yield* useConnectivityChanges(options.runtime);
-            lifetime.connectivityTask = yield* spawn(function* () {
-                for (const isConnected of yield* each(connectivityChanges)) {
-                    void isConnected;
-                    wake.send();
-                    yield* each.next();
-                }
-            });
-            if (isCoordinationHost(options.runtime.coordination)) {
-                const host = options.runtime.coordination;
-                const leaderOptions = {
-                    runtime: options.runtime,
-                    service,
-                    wake,
-                    failureStrategy: failureStrategy,
-                    maxRetries: nonNegativeInteger(options.maxRetries, DEFAULT_MAX_RETRIES, "Outbox maxRetries"),
-                    retryDelayMs: DEFAULT_RETRY_DELAY_MS,
-                    execute: (entry) => options.execute(decodeOutboxEntry(entry)),
-                    connection: options.connection,
-                };
-                lifetime.leaderTask = yield* spawn(function* () {
-                    const lifetimeSignal = yield* useAbortSignal();
-                    while (!lifetimeSignal.aborted) {
-                        try {
-                            const leaderRun = host.runAsLeader(({ signal }) => runOutboxLeader(signal, leaderOptions), {
-                                signal: lifetimeSignal,
-                            });
-                            lifetime.leaderRun = leaderRun;
-                            yield* until(leaderRun);
-                            return;
-                        }
-                        catch (error) {
-                            if (lifetimeSignal.aborted) {
-                                return;
-                            }
-                            if (!host.isLeader && !(error instanceof CoordinationError)) {
-                                continue;
-                            }
-                            throw error;
-                        }
-                    }
-                });
-            }
-            const outbox = {
-                collection,
-                ready: Promise.resolve(),
-                async enqueue(request, enqueueOptions) {
-                    const timestamp = Date.now();
-                    const proposed = {
-                        id: crypto.randomUUID(),
-                        sequence: 0,
-                        request: encodeOutboxRequest({
-                            ...request,
-                            idempotencyKey: request.idempotencyKey ?? crypto.randomUUID(),
-                        }),
-                        visibility: enqueueOptions?.visibility ?? "confirmed",
-                        status: "queued",
-                        createdAt: timestamp,
-                        updatedAt: timestamp,
-                        attempts: 0,
-                        retryable: true,
-                        nextAttemptAt: timestamp,
-                    };
-                    const completion = deferred();
-                    void completion.promise.catch(() => undefined);
-                    completions.set(proposed.id, completion);
-                    let entry;
-                    try {
-                        entry = await service.methods.enqueue({
-                            entry: proposed,
-                        });
-                    }
-                    catch (error) {
-                        completions.delete(proposed.id);
-                        completion.reject(normalizeError(error));
-                        throw error;
-                    }
-                    await projections.ensure(entry);
-                    return {
-                        entry: decodeOutboxEntry(entry),
-                        completed: completion.promise,
-                    };
-                },
-                async edit(id, update) {
-                    const current = repository.get(id);
-                    if (!current) {
-                        throw new Error(`Outbox entry "${id}" was not found in this context.`);
-                    }
-                    const request = structuredClone(decodeOutboxRequest(current.request));
-                    update(request);
-                    const entry = await service.methods.edit({
-                        id,
-                        request: encodeOutboxRequest(request),
-                    });
-                    await projections.ensure(entry);
-                    return decodeOutboxEntry(entry);
-                },
-                async remove(id) {
-                    await service.methods.remove({ id });
-                },
-                async retry(id) {
-                    await service.methods.retry({ id });
-                    wake.send();
-                },
-                cleanup() {
-                    return Promise.resolve();
-                },
-            };
-            yield* provide(outbox);
-        }
-        finally {
-            disposing = true;
-            reconciliationVersion += 1;
-            const cleanupErrors = [];
-            const capture = (error) => {
-                cleanupErrors.push(normalizeError(error));
-            };
-            lifetime.unsubscribeResults?.();
-            lifetime.unsubscribeCollection?.unsubscribe();
-            lifetime.unsubscribeConnection?.unsubscribe();
-            if (lifetime.server) {
-                try {
-                    yield* until(lifetime.server.close());
-                }
-                catch (error) {
-                    capture(error);
-                }
-            }
-            if (lifetime.leaderTask !== undefined) {
-                try {
-                    yield* lifetime.leaderTask.halt();
-                }
-                catch (error) {
-                    capture(error);
-                }
-            }
-            if (lifetime.leaderRun) {
-                yield* until(Promise.allSettled([lifetime.leaderRun]));
-            }
-            if (lifetime.connectivityTask !== undefined) {
-                try {
-                    yield* lifetime.connectivityTask.halt();
-                }
-                catch (error) {
-                    capture(error);
-                }
-            }
-            try {
-                yield* until(projections.close());
-            }
-            catch (error) {
-                capture(error);
-            }
-            const disposed = new Error("Outbox disposed.");
-            for (const completion of completions.values()) {
-                completion.reject(disposed);
-            }
-            completions.clear();
-            try {
-                yield* until(collection.cleanup());
-            }
-            catch (error) {
-                capture(error);
-            }
-            if (cleanupErrors[0]) {
-                yield* until(Promise.reject(cleanupErrors[0]));
-            }
-        }
-    });
+function useOntologyOutbox(options, collection = createOutboxCollection(options)) {
+	return resource(function* (provide) {
+		const repository = new OntologyOutboxRepository(collection);
+		const failureStrategy = options.failureStrategy ?? "discard-all";
+		const service = options.runtime.coordination.service(OUTBOX_COORDINATION_SERVICE);
+		const wake = createSignal();
+		const projections = new OutboxProjectionManager(options.project ? async (entry) => options.project?.(entry) : void 0);
+		const completions = /* @__PURE__ */ new Map();
+		const lifetime = {};
+		let disposing = false;
+		let reconciliationVersion = 0;
+		const deliverResult = async (event) => {
+			const completion = completions.get(event.id);
+			if (event.type === "completed") {
+				await projections.discard(event.id);
+				if (completion) {
+					completions.delete(event.id);
+					completion.resolve(event.result);
+				}
+				return;
+			}
+			const error = eventError(event);
+			await projections.discard(event.id, error);
+			if (completion) {
+				completions.delete(event.id);
+				completion.reject(error);
+			}
+		};
+		try {
+			lifetime.unsubscribeResults = service.events.subscribe("result", (event) => {
+				deliverResult(event);
+			});
+			yield* until(repository.preload());
+			if (isCoordinationHost(options.runtime.coordination)) lifetime.server = serveOntologyOutbox(options.runtime.coordination, repository);
+			const reconcileProjections = async () => {
+				const version = ++reconciliationVersion;
+				const entries = await repository.entries();
+				if (disposing || version !== reconciliationVersion) return;
+				await projections.reconcile(entries);
+			};
+			lifetime.unsubscribeCollection = collection.subscribeChanges(() => {
+				wake.send();
+				reconcileProjections();
+			});
+			lifetime.unsubscribeConnection = options.connection ? { unsubscribe: options.connection.subscribe(() => {
+				wake.send();
+			}) } : void 0;
+			const existing = yield* until(repository.entries());
+			yield* until(projections.restore(existing));
+			const connectivityChanges = yield* useConnectivityChanges(options.runtime);
+			lifetime.connectivityTask = yield* spawn(function* () {
+				for (const isConnected of yield* each(connectivityChanges)) {
+					wake.send();
+					yield* each.next();
+				}
+			});
+			if (isCoordinationHost(options.runtime.coordination)) {
+				const host = options.runtime.coordination;
+				const leaderOptions = {
+					runtime: options.runtime,
+					service,
+					wake,
+					failureStrategy,
+					maxRetries: nonNegativeInteger(options.maxRetries, DEFAULT_MAX_RETRIES, "Outbox maxRetries"),
+					retryDelayMs: DEFAULT_RETRY_DELAY_MS,
+					execute: (entry) => options.execute(entry),
+					connection: options.connection
+				};
+				lifetime.leaderTask = yield* spawn(function* () {
+					const lifetimeSignal = yield* useAbortSignal();
+					while (!lifetimeSignal.aborted) try {
+						const leaderRun = host.runAsLeader(({ signal }) => runOutboxLeader(signal, leaderOptions), { signal: lifetimeSignal });
+						lifetime.leaderRun = leaderRun;
+						yield* until(leaderRun);
+						return;
+					} catch (error) {
+						if (lifetimeSignal.aborted) return;
+						if (!host.isLeader && !(error instanceof CoordinationError)) continue;
+						throw error;
+					}
+				});
+			}
+			yield* provide({
+				collection,
+				ready: Promise.resolve(),
+				async enqueue(request, enqueueOptions) {
+					const timestamp = Date.now();
+					const proposed = {
+						id: crypto.randomUUID(),
+						sequence: 0,
+						request: {
+							...request,
+							idempotencyKey: request.idempotencyKey ?? crypto.randomUUID()
+						},
+						visibility: enqueueOptions?.visibility ?? "confirmed",
+						status: "queued",
+						createdAt: timestamp,
+						updatedAt: timestamp,
+						attempts: 0,
+						retryable: true,
+						nextAttemptAt: timestamp
+					};
+					const completion = deferred();
+					completion.promise.catch(() => void 0);
+					completions.set(proposed.id, completion);
+					let entry;
+					try {
+						entry = await service.methods.enqueue({ entry: proposed });
+					} catch (error) {
+						completions.delete(proposed.id);
+						completion.reject(normalizeError(error));
+						throw error;
+					}
+					await projections.ensure(entry);
+					return {
+						entry,
+						completed: completion.promise
+					};
+				},
+				async edit(id, update) {
+					const current = repository.get(id);
+					if (!current) throw new Error(`Outbox entry "${id}" was not found in this context.`);
+					const request = cloneValue(current.request);
+					update(request);
+					const entry = await service.methods.edit({
+						id,
+						request
+					});
+					await projections.ensure(entry);
+					return entry;
+				},
+				async remove(id) {
+					await service.methods.remove({ id });
+				},
+				async retry(id) {
+					await service.methods.retry({ id });
+					wake.send();
+				},
+				cleanup() {
+					return Promise.resolve();
+				}
+			});
+		} finally {
+			disposing = true;
+			reconciliationVersion += 1;
+			const cleanupErrors = [];
+			const capture = (error) => {
+				cleanupErrors.push(normalizeError(error));
+			};
+			lifetime.unsubscribeResults?.();
+			lifetime.unsubscribeCollection?.unsubscribe();
+			lifetime.unsubscribeConnection?.unsubscribe();
+			if (lifetime.server) try {
+				yield* until(lifetime.server.close());
+			} catch (error) {
+				capture(error);
+			}
+			if (lifetime.leaderTask !== void 0) try {
+				yield* lifetime.leaderTask.halt();
+			} catch (error) {
+				capture(error);
+			}
+			if (lifetime.leaderRun) yield* until(Promise.allSettled([lifetime.leaderRun]));
+			if (lifetime.connectivityTask !== void 0) try {
+				yield* lifetime.connectivityTask.halt();
+			} catch (error) {
+				capture(error);
+			}
+			try {
+				yield* until(projections.close());
+			} catch (error) {
+				capture(error);
+			}
+			const disposed = /* @__PURE__ */ new Error("Outbox disposed.");
+			for (const completion of completions.values()) completion.reject(disposed);
+			completions.clear();
+			try {
+				yield* until(collection.cleanup());
+			} catch (error) {
+				capture(error);
+			}
+			if (cleanupErrors[0]) yield* until(Promise.reject(cleanupErrors[0]));
+		}
+	});
 }
-export function createOntologyOutbox(options) {
-    const collection = createOutboxCollection(options);
-    let outbox;
-    const ready = deferred();
-    // Prevent unhandled rejection when cleanup races startup.
-    void ready.promise.catch(() => undefined);
-    let cleanupPromise;
-    const task = run(function* () {
-        try {
-            const value = yield* useOntologyOutbox(options, collection);
-            outbox = value;
-            ready.resolve();
-            yield* suspend();
-        }
-        catch (error) {
-            ready.reject(normalizeError(error));
-            throw error;
-        }
-    });
-    void task.catch(() => undefined);
-    return {
-        collection,
-        ready: ready.promise,
-        task,
-        async enqueue(request, enqueueOptions) {
-            await ready.promise;
-            return outbox.enqueue(request, enqueueOptions);
-        },
-        async edit(id, update) {
-            await ready.promise;
-            return outbox.edit(id, update);
-        },
-        async remove(id) {
-            await ready.promise;
-            return outbox.remove(id);
-        },
-        async retry(id) {
-            await ready.promise;
-            return outbox.retry(id);
-        },
-        async cleanup() {
-            cleanupPromise ??= (async () => {
-                // Let persistence startup settle before tearing down so
-                // loopback markReady cannot race cleaned-up status.
-                await Promise.allSettled([ready.promise, collection.preload()]);
-                await task.halt().catch(() => undefined);
-                if (collection.status !== "cleaned-up") {
-                    await collection.cleanup().catch(() => undefined);
-                }
-            })();
-            return cleanupPromise;
-        },
-    };
+function createOntologyOutbox(options) {
+	const collection = createOutboxCollection(options);
+	let outbox;
+	const ready = deferred();
+	ready.promise.catch(() => void 0);
+	let cleanupPromise;
+	const task = run(function* () {
+		try {
+			outbox = yield* useOntologyOutbox(options, collection);
+			ready.resolve();
+			yield* suspend();
+		} catch (error) {
+			ready.reject(normalizeError(error));
+			throw error;
+		}
+	});
+	task.catch(() => void 0);
+	return {
+		collection,
+		ready: ready.promise,
+		task,
+		async enqueue(request, enqueueOptions) {
+			await ready.promise;
+			return outbox.enqueue(request, enqueueOptions);
+		},
+		async edit(id, update) {
+			await ready.promise;
+			return outbox.edit(id, update);
+		},
+		async remove(id) {
+			await ready.promise;
+			return outbox.remove(id);
+		},
+		async retry(id) {
+			await ready.promise;
+			return outbox.retry(id);
+		},
+		async cleanup() {
+			cleanupPromise ??= (async () => {
+				await Promise.allSettled([ready.promise, collection.preload()]);
+				await task.halt().catch(() => void 0);
+				if (collection.status !== "cleaned-up") await collection.cleanup().catch(() => void 0);
+			})();
+			return cleanupPromise;
+		}
+	};
 }
+//#endregion
+export { createOntologyOutbox, useOntologyOutbox };
+
 //# sourceMappingURL=createOntologyOutbox.js.map