@bastani/atomic 0.9.11-alpha.8 → 0.9.11

package/dist/builtin/workflows/src/durable/dbos-lifecycle.ts

@@ -1,45 +1,41 @@
+import { type ConfiguredDbosDurability, configureDbosDurableBackend, type DbosDurableBackend } from "./dbos-backend.js";
 import {
-  configureDbosDurableBackend,
-  type ConfiguredDbosDurability,
-  type DbosDurableBackend,
-} from "./dbos-backend.js";
-import {
-  provisionResolvedLocalDbos,
-  resolveDbosSystemDatabaseUrl,
-  shouldProvisionLocalDbos,
+	provisionResolvedLocalDbos,
+	resolveDbosSystemDatabaseUrl,
+	shouldProvisionLocalDbos,
 } from "./dbos-local-postgres.js";
 
 export type DbosLifecycleState =
-  | "uninitialized"
-  | "configured"
-  | "launching"
-  | "ready"
-  | "failed"
-  | "shutting_down"
-  | "shut_down";
+	| "uninitialized"
+	| "configured"
+	| "launching"
+	| "ready"
+	| "failed"
+	| "shutting_down"
+	| "shut_down";
 
 export class DbosDurabilityError extends Error {
-  constructor(message: string, options?: ErrorOptions) {
-    super(message, options);
-    this.name = "DbosDurabilityError";
-  }
+	constructor(message: string, options?: ErrorOptions) {
+		super(message, options);
+		this.name = "DbosDurabilityError";
+	}
 }
 
 export class DbosNotReadyError extends DbosDurabilityError {
-  constructor() {
-    super("DBOS workflow durability is not ready. Await initializeDurableBackend() before accessing workflows.");
-    this.name = "DbosNotReadyError";
-  }
+	constructor() {
+		super("DBOS workflow durability is not ready. Await initializeDurableBackend() before accessing workflows.");
+		this.name = "DbosNotReadyError";
+	}
 }
 
 export class DbosShutdownError extends DbosDurabilityError {
-  constructor() {
-    super(
-      "DBOS workflow durability has been shut down in this process. "
-      + "Durable workflows can no longer start; restart Atomic to restore durability.",
-    );
-    this.name = "DbosShutdownError";
-  }
+	constructor() {
+		super(
+			"DBOS workflow durability has been shut down in this process. " +
+				"Durable workflows can no longer start; restart Atomic to restore durability.",
+		);
+		this.name = "DbosShutdownError";
+	}
 }
 type DbosConfigurator = () => Promise<ConfiguredDbosDurability>;
 type LocalDbosProvisioner = () => Promise<void>;
@@ -49,10 +45,8 @@ type LocalDbosProvisioner = () => Promise<void>;
  * Postgres, or the Docker fallback), then configure DBOS against it.
  */
 const defaultConfigurator: DbosConfigurator = async () => {
-  const systemDatabaseUrl = await resolveDbosSystemDatabaseUrl();
-  return await configureDbosDurableBackend(
-    systemDatabaseUrl === undefined ? undefined : { systemDatabaseUrl },
-  );
+	const systemDatabaseUrl = await resolveDbosSystemDatabaseUrl();
+	return await configureDbosDurableBackend(systemDatabaseUrl === undefined ? undefined : { systemDatabaseUrl });
 };
 
 let configureDurability: DbosConfigurator = defaultConfigurator;
@@ -66,95 +60,97 @@ let shutdownPromise: Promise<void> | undefined;
 let failure: DbosDurabilityError | undefined;
 
 function durabilityFailure(action: string, error: unknown): DbosDurabilityError {
-  const detail = error instanceof Error ? error.message : String(error);
-  return new DbosDurabilityError(
-    `DBOS workflow durability ${action} failed: ${detail}. Set DBOS_SYSTEM_DATABASE_URL to an existing Postgres when local provisioning is unavailable.`,
-    error instanceof Error ? { cause: error } : undefined,
-  );
+	const detail = error instanceof Error ? error.message : String(error);
+	return new DbosDurabilityError(
+		`DBOS workflow durability ${action} failed: ${detail}. Set DBOS_SYSTEM_DATABASE_URL to an existing Postgres when local provisioning is unavailable.`,
+		error instanceof Error ? { cause: error } : undefined,
+	);
 }
 
 export async function configureDbosOnce(): Promise<ConfiguredDbosDurability> {
-  if (failure !== undefined) throw failure;
-  configured ??= configureDurability().then((value) => {
-    active = value;
-    state = "configured";
-    return value;
-  }).catch((error: unknown) => {
-    failure = durabilityFailure("configuration", error);
-    state = "failed";
-    throw failure;
-  });
-  return await configured;
+	if (failure !== undefined) throw failure;
+	configured ??= configureDurability()
+		.then((value) => {
+			active = value;
+			state = "configured";
+			return value;
+		})
+		.catch((error: unknown) => {
+			failure = durabilityFailure("configuration", error);
+			state = "failed";
+			throw failure;
+		});
+	return await configured;
 }
 
 export async function launchDbosOnce(): Promise<void> {
-  if (failure !== undefined) throw failure;
-  // The executor is process-scoped and stops exactly once, at process exit.
-  // Post-shutdown launches must fail loudly instead of returning a backend
-  // whose SDK launched marker has been cleared.
-  if (state === "shutting_down" || state === "shut_down") throw new DbosShutdownError();
-  const durability = await configureDbosOnce();
-  launchPromise ??= (async () => {
-    state = "launching";
-    try {
-      await durability.launch();
-      state = "ready";
-    } catch (error) {
-      if (shouldProvisionLocalDbos(error)) {
-        try {
-          // DBOS creates an executor before testing connectivity. Tear down the
-          // failed executor so retry does not leak a pool or hang shutdown.
-          await durability.shutdown();
-          await provisionLocalDbos();
-          await durability.launch();
-          state = "ready";
-          return;
-        } catch (provisionError) {
-          failure = durabilityFailure("local Postgres startup", provisionError);
-        }
-      } else {
-        failure = durabilityFailure("launch", error);
-      }
-      state = "failed";
-      throw failure;
-    }
-  })();
-  await launchPromise;
+	if (failure !== undefined) throw failure;
+	// The executor is process-scoped and stops exactly once, at process exit.
+	// Post-shutdown launches must fail loudly instead of returning a backend
+	// whose SDK launched marker has been cleared.
+	if (state === "shutting_down" || state === "shut_down") throw new DbosShutdownError();
+	const durability = await configureDbosOnce();
+	launchPromise ??= (async () => {
+		state = "launching";
+		try {
+			await durability.launch();
+			state = "ready";
+		} catch (error) {
+			if (shouldProvisionLocalDbos(error)) {
+				try {
+					// DBOS creates an executor before testing connectivity. Tear down the
+					// failed executor so retry does not leak a pool or hang shutdown.
+					await durability.shutdown();
+					await provisionLocalDbos();
+					await durability.launch();
+					state = "ready";
+					return;
+				} catch (provisionError) {
+					failure = durabilityFailure("local Postgres startup", provisionError);
+				}
+			} else {
+				failure = durabilityFailure("launch", error);
+			}
+			state = "failed";
+			throw failure;
+		}
+	})();
+	await launchPromise;
 }
 
 export async function getReadyDbosBackend(): Promise<DbosDurableBackend> {
-  await launchDbosOnce();
-  if (state !== "ready" || active === undefined) throw failure ?? new DbosNotReadyError();
-  return active.backend;
+	await launchDbosOnce();
+	if (state !== "ready" || active === undefined) throw failure ?? new DbosNotReadyError();
+	return active.backend;
 }
 
 export function getReadyDbosBackendSync(): DbosDurableBackend | undefined {
-  return state === "ready" ? active?.backend : undefined;
+	return state === "ready" ? active?.backend : undefined;
 }
 
 export async function shutdownDbos(): Promise<void> {
-  if (shutdownPromise !== undefined) return await shutdownPromise;
-  const configuredPromise = configured;
-  if (configuredPromise === undefined) return;
-  shutdownPromise = (async () => {
-    // A backend that never reached "ready" has nothing to flush or stop.
-    // `configured`/`launchPromise` memoize rejections, so re-awaiting them
-    // unguarded would rethrow the original provisioning failure out of every
-    // session dispose — crashing otherwise-successful runs at process exit.
-    const durability = await configuredPromise.catch(() => undefined);
-    if (durability === undefined) return;
-    if (launchPromise !== undefined) await launchPromise.catch(() => undefined);
-    if (state !== "ready") return;
-    state = "shutting_down";
-    await durability.backend.flush();
-    await durability.shutdown();
-    state = "shut_down";
-  })().catch((error: unknown) => {
-    failure = durabilityFailure("shutdown", error);
-    state = "failed";
-    throw failure;
-  });
-  await shutdownPromise;
+	if (shutdownPromise !== undefined) return await shutdownPromise;
+	const configuredPromise = configured;
+	if (configuredPromise === undefined) return;
+	shutdownPromise = (async () => {
+		// A backend that never reached "ready" has nothing to flush or stop.
+		// `configured`/`launchPromise` memoize rejections, so re-awaiting them
+		// unguarded would rethrow the original provisioning failure out of every
+		// session dispose — crashing otherwise-successful runs at process exit.
+		const durability = await configuredPromise.catch(() => undefined);
+		if (durability === undefined) return;
+		if (launchPromise !== undefined) await launchPromise.catch(() => undefined);
+		if (state !== "ready") return;
+		state = "shutting_down";
+		await durability.backend.flush();
+		await durability.shutdown();
+		state = "shut_down";
+	})().catch((error: unknown) => {
+		failure = durabilityFailure("shutdown", error);
+		state = "failed";
+		throw failure;
+	});
+	await shutdownPromise;
 }
 
 /**
@@ -163,25 +159,25 @@ export async function shutdownDbos(): Promise<void> {
  * `/fork`, `/reload`) where the DBOS executor must stay launched.
  */
 export async function flushDbos(): Promise<void> {
-  if (state !== "ready" || active === undefined) return;
-  await active.backend.flush();
+	if (state !== "ready" || active === undefined) return;
+	await active.backend.flush();
 }
 
 export function dbosLifecycleState(): DbosLifecycleState {
-  return state;
+	return state;
 }
 
 /** Reset the process singleton with an explicit configurator for unit tests. */
 export function resetDbosLifecycleForTests(
-  configurator: DbosConfigurator = defaultConfigurator,
-  provisioner: LocalDbosProvisioner = provisionResolvedLocalDbos,
+	configurator: DbosConfigurator = defaultConfigurator,
+	provisioner: LocalDbosProvisioner = provisionResolvedLocalDbos,
 ): void {
-  state = "uninitialized";
-  configured = undefined;
-  active = undefined;
-  launchPromise = undefined;
-  shutdownPromise = undefined;
-  failure = undefined;
-  configureDurability = configurator;
-  provisionLocalDbos = provisioner;
+	state = "uninitialized";
+	configured = undefined;
+	active = undefined;
+	launchPromise = undefined;
+	shutdownPromise = undefined;
+	failure = undefined;
+	configureDurability = configurator;
+	provisionLocalDbos = provisioner;
 }

package/dist/builtin/workflows/src/durable/dbos-local-postgres.ts

@@ -11,10 +11,7 @@
  *      binaries are unavailable for this platform and Docker exists.
  */
 
-import {
-  EMBEDDED_DBOS_SYSTEM_DATABASE_URL,
-  ensureEmbeddedDbosPostgres,
-} from "./dbos-embedded-postgres.js";
+import { EMBEDDED_DBOS_SYSTEM_DATABASE_URL, ensureEmbeddedDbosPostgres } from "./dbos-embedded-postgres.js";
 import { commandFailureDetail, delay, runLocalCommand, tcpReachable } from "./local-command.js";
 
 const DOCKER_CONTAINER = "dbos-db";
@@ -35,92 +32,102 @@ let dockerProvider: LocalDbosProvider = ensureDockerDbosPostgres;
  * user URL or the Docker container that matches them).
  */
 export function resolveDbosSystemDatabaseUrl(): Promise<string | undefined> {
-  resolution ??= resolve().catch((error: unknown) => {
-    resolution = undefined;
-    throw error;
-  });
-  return resolution;
+	resolution ??= resolve().catch((error: unknown) => {
+		resolution = undefined;
+		throw error;
+	});
+	return resolution;
 }
 
 /** Re-ensure the previously resolved local database (launch-retry safety net). */
 export async function provisionResolvedLocalDbos(): Promise<void> {
-  await (resolvedProvider ?? embeddedProvider)();
+	await (resolvedProvider ?? embeddedProvider)();
 }
 
 export function shouldProvisionLocalDbos(error: unknown): boolean {
-  if (process.env.DBOS_SYSTEM_DATABASE_URL?.trim()) return false;
-  const message = error instanceof Error ? `${error.message}\n${error.cause ?? ""}` : String(error);
-  return /ECONNREFUSED|server not reachable|connect failed|connection refused|unable to connect to system database/i.test(message);
+	if (process.env.DBOS_SYSTEM_DATABASE_URL?.trim()) return false;
+	const message = error instanceof Error ? `${error.message}\n${error.cause ?? ""}` : String(error);
+	return /ECONNREFUSED|server not reachable|connect failed|connection refused|unable to connect to system database/i.test(
+		message,
+	);
 }
 
 async function resolve(): Promise<string | undefined> {
-  const explicit = process.env.DBOS_SYSTEM_DATABASE_URL?.trim();
-  if (explicit) return undefined;
+	const explicit = process.env.DBOS_SYSTEM_DATABASE_URL?.trim();
+	if (explicit) return undefined;
 
-  try {
-    await embeddedProvider();
-    resolvedProvider = embeddedProvider;
-    return EMBEDDED_DBOS_SYSTEM_DATABASE_URL;
-  } catch (embeddedError) {
-    try {
-      await dockerProvider();
-      resolvedProvider = dockerProvider;
-      // The container matches DBOS's documented default URL; defer to it.
-      return undefined;
-    } catch (dockerError) {
-      const embeddedDetail = embeddedError instanceof Error ? embeddedError.message : String(embeddedError);
-      const dockerDetail = dockerError instanceof Error ? dockerError.message : String(dockerError);
-      throw new Error(
-        `No usable Postgres for workflow durability. Embedded Postgres: ${embeddedDetail} Docker fallback: ${dockerDetail} `
-        + "Set DBOS_SYSTEM_DATABASE_URL to an existing Postgres to proceed.",
-      );
-    }
-  }
+	try {
+		await embeddedProvider();
+		resolvedProvider = embeddedProvider;
+		return EMBEDDED_DBOS_SYSTEM_DATABASE_URL;
+	} catch (embeddedError) {
+		try {
+			await dockerProvider();
+			resolvedProvider = dockerProvider;
+			// The container matches DBOS's documented default URL; defer to it.
+			return undefined;
+		} catch (dockerError) {
+			const embeddedDetail = embeddedError instanceof Error ? embeddedError.message : String(embeddedError);
+			const dockerDetail = dockerError instanceof Error ? dockerError.message : String(dockerError);
+			throw new Error(
+				`No usable Postgres for workflow durability. Embedded Postgres: ${embeddedDetail} Docker fallback: ${dockerDetail} ` +
+					"Set DBOS_SYSTEM_DATABASE_URL to an existing Postgres to proceed.",
+			);
+		}
+	}
 }
 
 /** Start DBOS's canonical reusable local Postgres container. */
 async function ensureDockerDbosPostgres(): Promise<void> {
-  const docker = await runLocalCommand("docker", ["version", "--format", "{{.Server.Version}}"]).catch(() => undefined);
-  if (docker === undefined || docker.exitCode !== 0) {
-    throw new Error("Docker is unavailable.");
-  }
+	const docker = await runLocalCommand("docker", ["version", "--format", "{{.Server.Version}}"]).catch(
+		() => undefined,
+	);
+	if (docker === undefined || docker.exitCode !== 0) {
+		throw new Error("Docker is unavailable.");
+	}
 
-  const inspection = await runLocalCommand("docker", ["inspect", "--format", "{{.State.Running}}", DOCKER_CONTAINER]);
-  if (inspection.exitCode === 0) {
-    if (inspection.stdout.trim() !== "true") {
-      await requireDockerSuccess("start existing DBOS Postgres", ["start", DOCKER_CONTAINER]);
-    }
-  } else {
-    await requireDockerSuccess("create DBOS Postgres", [
-      "run", "-d",
-      "--name", DOCKER_CONTAINER,
-      "-e", "POSTGRES_PASSWORD=dbos",
-      "-e", "PGDATA=/var/lib/postgresql/data",
-      "-p", "127.0.0.1:5432:5432",
-      "-v", "dbos-db-data:/var/lib/postgresql/data",
-      DOCKER_IMAGE,
-    ]);
-  }
+	const inspection = await runLocalCommand("docker", ["inspect", "--format", "{{.State.Running}}", DOCKER_CONTAINER]);
+	if (inspection.exitCode === 0) {
+		if (inspection.stdout.trim() !== "true") {
+			await requireDockerSuccess("start existing DBOS Postgres", ["start", DOCKER_CONTAINER]);
+		}
+	} else {
+		await requireDockerSuccess("create DBOS Postgres", [
+			"run",
+			"-d",
+			"--name",
+			DOCKER_CONTAINER,
+			"-e",
+			"POSTGRES_PASSWORD=dbos",
+			"-e",
+			"PGDATA=/var/lib/postgresql/data",
+			"-p",
+			"127.0.0.1:5432:5432",
+			"-v",
+			"dbos-db-data:/var/lib/postgresql/data",
+			DOCKER_IMAGE,
+		]);
+	}
 
-  for (let attempt = 0; attempt < DOCKER_READY_ATTEMPTS; attempt += 1) {
-    if (await tcpReachable("127.0.0.1", 5432)) return;
-    await delay(DOCKER_READY_DELAY_MS);
-  }
-  throw new Error("The DBOS Postgres container started but did not become ready within 30 seconds.");
+	for (let attempt = 0; attempt < DOCKER_READY_ATTEMPTS; attempt += 1) {
+		if (await tcpReachable("127.0.0.1", 5432)) return;
+		await delay(DOCKER_READY_DELAY_MS);
+	}
+	throw new Error("The DBOS Postgres container started but did not become ready within 30 seconds.");
 }
 
 async function requireDockerSuccess(action: string, args: string[]): Promise<void> {
-  const result = await runLocalCommand("docker", args);
-  if (result.exitCode === 0) return;
-  throw new Error(`Could not ${action}: ${commandFailureDetail(result)}`);
+	const result = await runLocalCommand("docker", args);
+	if (result.exitCode === 0) return;
+	throw new Error(`Could not ${action}: ${commandFailureDetail(result)}`);
 }
 
 export function resetLocalDbosProvisioningForTests(
-  embedded: LocalDbosProvider = ensureEmbeddedDbosPostgres,
-  docker: LocalDbosProvider = ensureDockerDbosPostgres,
+	embedded: LocalDbosProvider = ensureEmbeddedDbosPostgres,
+	docker: LocalDbosProvider = ensureDockerDbosPostgres,
 ): void {
-  resolution = undefined;
-  resolvedProvider = undefined;
-  embeddedProvider = embedded;
-  dockerProvider = docker;
+	resolution = undefined;
+	resolvedProvider = undefined;
+	embeddedProvider = embedded;
+	dockerProvider = docker;
 }