@getstrata/cli 2.1.0 → 2.2.0

package/CHANGELOG.md

@@ -1,5 +1,20 @@
 # @getstrata/cli changelog
 
+## 2.2.0
+
+Consistent model scopes.
+Changed-field model writes.
+Awaited provider startup.
+Shared cache correctness.
+Native HTTP controls and body limits.
+Graceful lifecycle.
+Validated async discovery.
+Stronger model input types.
+OpenTelemetry tracing.
+Distributed scheduler ownership.
+App-owned quota policy.
+Bounded memory throttling.
+
 ## 2.1.0
 
 - refactor(starter): reuse shared config and base repositories - fix(database): await password casts before model writes - fix(database): preserve concrete model types in query results
@@ -48,6 +63,8 @@
 
 ## Unreleased
 
+- Await queue/scheduler application startup and close resources after failed startup or completed work; preserve original failures when cleanup also fails.
+
 - 2.0: migrations no longer implicitly call an app seed export. Seeding requires --seed; fresh accepts the same explicit flag. Missing seed exports are rejected before applying migrations or resetting data.
 
 ## 1.1.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/cli",
-  "version": "2.1.0",
+  "version": "2.2.0",
   "description": "Strata CLI: framework commands for Bun apps (dev, start, migrate, run)",
   "type": "module",
   "license": "MIT",
@@ -46,8 +46,8 @@
   ],
   "scripts": {},
   "peerDependencies": {
-    "@getstrata/bootstrap": "^2.1.0",
-    "@getstrata/core": "^2.1.0"
+    "@getstrata/bootstrap": "^2.2.0",
+    "@getstrata/core": "^2.2.0"
   },
   "publishConfig": {
     "access": "public"

package/src/queueWorker.ts

@@ -1,6 +1,6 @@
 import {
   installGracefulShutdownSignals,
-  registerShutdownHandler,
+  LifecycleCoordinator,
 } from "@getstrata/core/lifecycle/gracefulShutdown";
 import { createFailedJobService, createQueueWorker } from "@getstrata/core/queue/createAppQueue";
 
@@ -10,35 +10,91 @@ type QueueWorkerClose = () => unknown | Promise<unknown>;
 async function runQueueWorkerCommand(options: {
   boot: QueueWorkerBoot;
   close?: QueueWorkerClose;
+  flush?: QueueWorkerClose;
+  drain?: QueueWorkerClose;
+  lifecycle?: LifecycleCoordinator;
   failedJobs?: ReturnType<typeof createFailedJobService>;
 }): Promise<void> {
   const redisUrl = process.env.REDIS_URL;
-
-  if (!redisUrl) {
-    throw new Error("queue:work requires REDIS_URL to be set.");
+  if (!redisUrl) throw new Error("queue:work requires REDIS_URL to be set.");
+  const lifecycle = options.lifecycle ?? new LifecycleCoordinator();
+  if (lifecycle.isShuttingDown) throw new Error("Cannot start a worker during shutdown.");
+  let worker: ReturnType<typeof createQueueWorker> | undefined;
+  let running: Promise<void> | undefined;
+  let booting: Promise<unknown> | undefined;
+  let stopping = false;
+  const name = `queue:${crypto.randomUUID()}`;
+  lifecycle.register(
+    `${name}:stop`,
+    () => {
+      stopping = true;
+      worker?.requestStop();
+    },
+    "stop",
+  );
+  lifecycle.register(
+    `${name}:drain`,
+    async () => {
+      // Completion, including failed startup/run, means no admitted worker remains.
+      await booting?.catch(() => {});
+      await running?.catch(() => {});
+      await options.drain?.();
+    },
+    "drain",
+  );
+  lifecycle.register(
+    `${name}:flush`,
+    async () => {
+      await options.flush?.();
+    },
+    "flush",
+  );
+  lifecycle.register(
+    `${name}:close`,
+    async () => {
+      try {
+        await worker?.close?.();
+      } finally {
+        await options.close?.();
+      }
+    },
+    "close",
+  );
+  lifecycle.register(
+    `${name}:force`,
+    () => {
+      worker?.requestStop();
+      worker?.close?.();
+    },
+    "force",
+  );
+  const uninstall = installGracefulShutdownSignals(undefined, lifecycle);
+  let failure: unknown;
+  let failed = false;
+  try {
+    booting = (async () => {
+      await options.boot();
+    })();
+    await booting;
+    if (!stopping && !lifecycle.isShuttingDown) {
+      worker = createQueueWorker(redisUrl, options.failedJobs ?? createFailedJobService());
+      console.log("[queue:work] Listening for jobs on Redis...");
+      running = worker.run();
+      await running;
+      console.log("[queue:work] Worker stopped.");
+    }
+  } catch (error) {
+    failed = true;
+    failure = error;
   }
-
-  await options.boot();
-
-  const failedJobs = options.failedJobs ?? createFailedJobService();
-
-  console.log("[queue:work] Listening for jobs on Redis...");
-  const worker = createQueueWorker(redisUrl, failedJobs);
-
-  registerShutdownHandler("queue-worker", async () => {
-    worker.requestStop();
-  });
-
-  if (options.close) {
-    registerShutdownHandler("database", async () => {
-      await options.close?.();
-    });
-  }
-
-  installGracefulShutdownSignals();
-
-  await worker.run();
-  console.log("[queue:work] Worker stopped.");
+  const result = await lifecycle.shutdown("WORKER_FINISHED");
+  uninstall();
+  if (!result.successful)
+    throw new AggregateError(
+      [...(failed ? [failure] : []), ...result.errors.map((entry) => entry.error)],
+      "Queue startup/runtime or shutdown failed.",
+    );
+  if (failed) throw failure;
 }
 
 export type { QueueWorkerBoot, QueueWorkerClose };

package/src/schedule.ts

@@ -1,25 +1,87 @@
+import {
+  installGracefulShutdownSignals,
+  LifecycleCoordinator,
+} from "@getstrata/core/lifecycle/gracefulShutdown";
 import { appSchedule, runDueScheduledTasks } from "@getstrata/core/scheduler/schedule";
 
 type LoadAppSchedule = () => void | Promise<void>;
+type CloseScheduledApp = () => void | Promise<void>;
 
-function createScheduleRunCommand(loadSchedule: LoadAppSchedule) {
+function createScheduleRunCommand(
+  loadSchedule: LoadAppSchedule,
+  close?: CloseScheduledApp,
+  options: {
+    lifecycle?: LifecycleCoordinator;
+    flush?: CloseScheduledApp;
+    drain?: CloseScheduledApp;
+  } = {},
+) {
   return async function scheduleRunCommand(): Promise<void> {
-    await loadSchedule();
-
-    const due = appSchedule.dueTasks();
-
-    if (due.length === 0) {
-      console.log("No scheduled tasks due.");
-      return;
+    const lifecycle = options.lifecycle ?? new LifecycleCoordinator();
+    if (lifecycle.isShuttingDown) throw new Error("Cannot start scheduling during shutdown.");
+    const admission = new AbortController();
+    let stopping = false;
+    let execution: Promise<void> | undefined;
+    const name = `scheduler:${crypto.randomUUID()}`;
+    lifecycle.register(
+      `${name}:stop`,
+      () => {
+        stopping = true;
+        admission.abort();
+      },
+      "stop",
+    );
+    lifecycle.register(
+      `${name}:drain`,
+      async () => {
+        await execution?.catch(() => {});
+        await options.drain?.();
+      },
+      "drain",
+    );
+    lifecycle.register(
+      `${name}:flush`,
+      async () => {
+        await options.flush?.();
+      },
+      "flush",
+    );
+    lifecycle.register(
+      `${name}:close`,
+      async () => {
+        await close?.();
+      },
+      "close",
+    );
+    const uninstall = installGracefulShutdownSignals(undefined, lifecycle);
+    let failed = false;
+    let failure: unknown;
+    try {
+      execution = (async () => {
+        await loadSchedule();
+        if (stopping) return;
+        const due = appSchedule.dueTasks();
+        if (due.length === 0) console.log("No scheduled tasks due.");
+        else {
+          for (const task of due) console.log(`Running scheduled task: ${task.name}`);
+          await runDueScheduledTasks(appSchedule, new Date(), { signal: admission.signal });
+        }
+      })();
+      await execution;
+    } catch (error) {
+      failed = true;
+      failure = error;
     }
-
-    for (const task of due) {
-      console.log(`Running scheduled task: ${task.name}`);
-    }
-
-    await runDueScheduledTasks(appSchedule);
+    const result = await lifecycle.shutdown("SCHEDULE_FINISHED");
+    uninstall();
+    if (!result.successful)
+      throw new AggregateError(
+        [...(failed ? [failure] : []), ...result.errors.map((entry) => entry.error)],
+        "Scheduler startup/runtime or shutdown failed.",
+      );
+    if (failed) throw failure;
   };
 }
 
-export type { LoadAppSchedule };
+export type { CloseScheduledApp, LoadAppSchedule };
 export { createScheduleRunCommand };