@getstrata/starter 2.0.9 → 2.2.0

package/dist/cli.js

@@ -2905,6 +2905,8 @@ function renderEnvExample(projectName, layers) {
     `APP_KEY_PREFIX=${projectName}`,
     "APP_ENV=local",
     "PORT=3000",
+    "# Total graceful shutdown budget in milliseconds; keep deployment grace longer.",
+    "SHUTDOWN_TIMEOUT_MS=30000",
     "APP_URL=http://localhost:3000",
     `DATABASE_URL=${defaultDatabaseUrl(layers, projectName)}`,
     ...postgresAppRoleEnvNotes(layers),
@@ -2922,6 +2924,8 @@ function renderEnvExample(projectName, layers) {
     `MAIL_DRIVER=${layers.mail}`,
     `AUTH_DEV_HEADERS=${envFlag(layers.auth === "headers")}`
   ];
+  lines.push("# Scheduler coordination defaults to Redis in production, one process in development.");
+  lines.push("# SCHEDULER_COORDINATION=redis");
   lines.push("APP_DEBUG=false");
   lines.push("FEATURE_PUBLIC_READS=false");
   lines.push("# wrapWebPublicRead / wrapPublicRead require login when false (production-safe default).");
@@ -3191,9 +3195,9 @@ function renderPackageJson(projectName, options = {}) {
     "@getstrata/cli": "workspace:*",
     "@getstrata/core": "workspace:*"
   } : {
-    "@getstrata/bootstrap": "^2.0.9",
-    "@getstrata/cli": "^2.0.9",
-    "@getstrata/core": "^2.0.9"
+    "@getstrata/bootstrap": "^2.2.0",
+    "@getstrata/cli": "^2.2.0",
+    "@getstrata/core": "^2.2.0"
   };
   coreDeps.eta = "^4.6.0";
   if (options.layers?.database === "mysql") {
@@ -3384,7 +3388,7 @@ function renderIntegrationsReadme(layers) {
     "",
     "OAuth, billing, outbound webhooks, SIEM, and SAML are **off by default**. Commented placeholders live in `.env.example`. Framework map: [INTEGRATIONS.md](https://github.com/EyK-26/strata/blob/main/docs/INTEGRATIONS.md).",
     "",
-    "Wizard flags (any stack unless noted): `--oauth-github` and `--oidc` (cookie HTML), `--billing`, `--webhooks`. They emit modules, migrations, jobs, or listeners. `createApp` still calls `discoverListeners()` and `discoverJobs()`.",
+    "Wizard flags (any stack unless noted): `--oauth-github` and `--oidc` (cookie HTML), `--billing`, `--webhooks`. They emit modules, migrations, jobs, or listeners. `createApp` still calls `await discoverListeners()` and `await discoverJobs()`.",
     ""
   ];
   if (enabled.length > 0) {
@@ -3780,9 +3784,7 @@ function starterSchemaStatements(layers) {
   if (tenancyOn) {
     statements.push(`CREATE TABLE IF NOT EXISTS tenant (
     id ${d.id},
-    slug ${d.keyText} NOT NULL UNIQUE,
-    plan ${d.defaultText} NOT NULL DEFAULT 'free',
-    region ${d.defaultText} NOT NULL DEFAULT 'eu'
+    slug ${d.keyText} NOT NULL UNIQUE
   )`);
   }
   const notesTenantColumn = tenancyOn ? `
@@ -3953,8 +3955,8 @@ function renderMigrateTs(layers) {
   );
   if (Number(tenantCount) === 0) {
     await sql.unsafe(
-      "INSERT INTO tenant (slug, plan, region) VALUES (${ph ? "$1, $2, $3" : "?, ?, ?"})",
-      ["default", "free", "eu"],
+      "INSERT INTO tenant (slug) VALUES (${ph ? "$1" : "?"})",
+      ["default"],
     );
   }` : "";
   const seedUsers = authNeedsUsers(layers.auth) ? `
@@ -4030,8 +4032,7 @@ function renderNoteModel(layers) {
   tenant_id: number;` : "";
   const tenantColumn = tenancyOn ? ', "tenant_id"' : "";
   const fillable = tenancyOn ? '["body", "tenant_id"]' : '["body"]';
-  return `import { BaseRepository } from "@getstrata/core/database/baseRepository";
-import { Model, registerModelRepository } from "@getstrata/core/database/model";
+  return `import { defineModel } from "@getstrata/core/database/model";
 import { defineTable } from "@getstrata/core/database/table";
 
 interface NoteRecord {
@@ -4047,21 +4048,13 @@ const notesTable = defineTable<NoteRecord, "id">({
   defaultOrderBy: { column: "id", direction: "ASC" },
 });
 
-class NoteRepository extends BaseRepository<NoteRecord, "id"> {
-  constructor() {
-    super(notesTable);
-  }
-}
-
-class Note extends Model<NoteRecord, "id"> {
+class Note extends defineModel(notesTable) {
   static $fillable = ${fillable} as const;
   // created_at uses the table default. Sending a JS Date from $timestamps
   // is rejected by SQLite bindings.
   static $timestamps = false;
 }
 
-registerModelRepository(Note, new NoteRepository());
-
 export type { NoteRecord };
 export { Note };
 `;
@@ -4098,8 +4091,7 @@ function renderUserModel(layers) {
   const fillableLiteral = `[${fillable.map((column) => `"${column}"`).join(", ")}]`;
   const hiddenLiteral = `[${hidden.map((column) => `"${column}"`).join(", ")}]`;
   const columnsLiteral = columns.map((column) => `"${column}"`).join(", ");
-  return `import { BaseRepository } from "@getstrata/core/database/baseRepository";
-import { Model, registerModelRepository } from "@getstrata/core/database/model";
+  return `import { defineModel } from "@getstrata/core/database/model";
 import { defineTable } from "@getstrata/core/database/table";
 
 interface UserRecord {
@@ -4120,13 +4112,7 @@ const usersTable = defineTable<UserRecord, "id">({
   defaultOrderBy: { column: "id", direction: "ASC" },
 });
 
-class UserRepository extends BaseRepository<UserRecord, "id"> {
-  constructor() {
-    super(usersTable);
-  }
-}
-
-class User extends Model<UserRecord, "id"> {
+class User extends defineModel(usersTable) {
   static $fillable = ${fillableLiteral} as const;
   static $hidden = ${hiddenLiteral} as const;
   // created_at uses the table default. Sending a JS Date from $timestamps
@@ -4134,15 +4120,12 @@ class User extends Model<UserRecord, "id"> {
   static $timestamps = false;
 }
 
-registerModelRepository(User, new UserRepository());
-
 export type { UserRecord };
 export { User };
 `;
 }
 function renderApiTokenModel() {
-  return `import { BaseRepository } from "@getstrata/core/database/baseRepository";
-import { Model, registerModelRepository } from "@getstrata/core/database/model";
+  return `import { defineModel } from "@getstrata/core/database/model";
 import { defineTable } from "@getstrata/core/database/table";
 
 interface ApiTokenRecord {
@@ -4163,28 +4146,19 @@ const apiTokensTable = defineTable<ApiTokenRecord, "id">({
   defaultOrderBy: { column: "id", direction: "ASC" },
 });
 
-class ApiTokenRepository extends BaseRepository<ApiTokenRecord, "id"> {
-  constructor() {
-    super(apiTokensTable);
-  }
-}
-
-class ApiToken extends Model<ApiTokenRecord, "id"> {
+class ApiToken extends defineModel(apiTokensTable) {
   static $fillable = ["user_id", "name", "token_hash", "abilities", "expires_at", "last_used_at"] as const;
   // created_at uses the table default. Sending a JS Date from $timestamps
   // is rejected by SQLite bindings.
   static $timestamps = false;
 }
 
-registerModelRepository(ApiToken, new ApiTokenRepository());
-
 export type { ApiTokenRecord };
 export { ApiToken };
 `;
 }
 function renderAuthOneTimeTokenModel() {
-  return `import { BaseRepository } from "@getstrata/core/database/baseRepository";
-import { Model, registerModelRepository } from "@getstrata/core/database/model";
+  return `import { defineModel } from "@getstrata/core/database/model";
 import { defineTable } from "@getstrata/core/database/table";
 
 interface AuthOneTimeTokenRecord {
@@ -4203,44 +4177,20 @@ const authOneTimeTokensTable = defineTable<AuthOneTimeTokenRecord, "id">({
   defaultOrderBy: { column: "id", direction: "ASC" },
 });
 
-class AuthOneTimeTokenRepository extends BaseRepository<AuthOneTimeTokenRecord, "id"> {
-  constructor() {
-    super(authOneTimeTokensTable);
-  }
-}
-
-class AuthOneTimeToken extends Model<AuthOneTimeTokenRecord, "id"> {
+class AuthOneTimeToken extends defineModel(authOneTimeTokensTable) {
   static $fillable = ["purpose", "user_id", "token_hash", "expires_at", "consumed_at"] as const;
   static $timestamps = false;
 }
 
-registerModelRepository(AuthOneTimeToken, new AuthOneTimeTokenRepository());
-
 export type { AuthOneTimeTokenRecord };
 export { AuthOneTimeToken };
 `;
 }
-function renderModelsRegister(layers) {
-  const lines = [
-    "// Side-effect imports run registerModelRepository() in each model file.",
-    "// registerModelClass() is only for a string alias that is neither constructor.name nor $morphClass.",
-    'import { registerModelClass } from "@getstrata/core/database/model";',
-    'import "./Note.ts";'
-  ];
-  if (authNeedsUsers(layers.auth)) {
-    lines.push('import "./User.ts";');
-    lines.push('import "./AuthOneTimeToken.ts";');
-  }
-  if (authUsesToken(layers.auth)) {
-    lines.push('import "./ApiToken.ts";');
-  }
-  lines.push("");
-  lines.push("// Example after you add a Product model with belongsTo('Category'):");
-  lines.push('// registerModelClass("Category", Category);');
-  lines.push("void registerModelClass;");
-  lines.push("");
-  return `${lines.join(`
-`)}
+function renderModelsRegister(_layers) {
+  return `import { discoverModels } from "@getstrata/bootstrap/discoverModels";
+
+// Discovery binds default repositories and registers every name before model boot.
+await discoverModels(import.meta.dir);
 `;
 }
 function dropTables(layers) {
@@ -4440,17 +4390,15 @@ import {
 
 const queueProvider: ServiceProvider = {
   name: "starter.queue",
-  register({ container }) {
+  async register({ container, onCleanup }) {
     const driver = (process.env.QUEUE_DRIVER ?? "sync") as "sync" | "async" | "redis";
     const failedJobs = createFailedJobService();
     container.set(FAILED_JOB_SERVICE_TOKEN, failedJobs);
-    container.set(
-      CORE_QUEUE_TOKEN,
-      createAppQueue(driver, process.env.REDIS_URL, failedJobs, () => {
-        registerDefaultJobs();
-        discoverJobs();
-      }),
-    );
+    registerDefaultJobs();
+    await discoverJobs();
+    const queue = createAppQueue(driver, process.env.REDIS_URL, failedJobs);
+    onCleanup(() => queue.close?.(), driver === "async" ? "drain" : "close");
+    container.set(CORE_QUEUE_TOKEN, queue);
   },
 };
 
@@ -4554,7 +4502,8 @@ export default policyProvider;
 `;
 }
 function renderProvidersIndex() {
-  return `import { discoverListeners } from "@getstrata/bootstrap/discoverListeners";
+  return `import { tracingProvider } from "@getstrata/bootstrap";
+import { discoverListeners } from "@getstrata/bootstrap/discoverListeners";
 import { registerInvalidateCacheOnModelWriteListeners } from "@getstrata/bootstrap/listeners/invalidateCacheOnModelWrite";
 import type { ServiceProvider } from "@getstrata/core/contracts/di";
 import authProvider from "./auth.ts";
@@ -4564,32 +4513,20 @@ import policyProvider from "./policy.ts";
 import queueProvider from "./queue.ts";
 import storageProvider from "./storage.ts";
 
-const registeredListenerGroups = new Set<string>();
-
-function registerListenerGroup(name: string, register: () => void): void {
-  if (registeredListenerGroups.has(name)) {
-    return;
-  }
-
-  registeredListenerGroups.add(name);
-  register();
-}
-
 const listenersProvider: ServiceProvider = {
   name: "starter.listeners",
-  boot() {
-    registerListenerGroup("cache.invalidate-on-model-write", () => {
-      registerInvalidateCacheOnModelWriteListeners();
-    });
+  async boot({ onCleanup }) {
+    onCleanup(registerInvalidateCacheOnModelWriteListeners());
 
-    for (const registerListener of discoverListeners()) {
-      registerListener();
+    for (const registerListener of await discoverListeners()) {
+      await registerListener();
     }
   },
 };
 
 const starterProviders: ServiceProvider[] = [
   configProvider,
+  tracingProvider,
   cacheProvider,
   storageProvider,
   queueProvider,
@@ -4610,17 +4547,8 @@ function renderCreateAppTs(layers) {
     ...createMetricsRoutes(),` : "";
   return `import { join } from "node:path";
 import "./preload.ts";
-import { runProviderPhase } from "@getstrata/bootstrap/context";
-import {
-  type AppContext,
-  type AppDependencies,
-  type AppRouteMap,
-  assertAppDependenciesComplete,
-  type ConfigStore,
-  type MutableAppDependencies,
-  type ProviderContext,
-  ServiceContainer,
-} from "@getstrata/bootstrap/contracts";
+import { createAppContext as createProviderAppContext, type InitializedAppContext } from "@getstrata/bootstrap/context";
+import type { AppRouteMap } from "@getstrata/bootstrap/contracts";
 import { mergeSpaRoutes } from "@getstrata/bootstrap/createSpaRoutes";
 import {
   configureModulesDirectory,
@@ -4630,13 +4558,13 @@ import {
 import { createHealthRoutes } from "@getstrata/bootstrap/health";
 ${metricsImport}import { assertProductionSecrets, assertRlsLiveDatabaseRole } from "@getstrata/bootstrap/secretsGuard";
 import { createWebServer } from "@getstrata/bootstrap/web/server";
-import { setActiveApplicationContext } from "@getstrata/core/runtime/applicationRegistry";
+import type { LifecycleCoordinator } from "@getstrata/core/lifecycle/gracefulShutdown";
 import { isProductionEnv } from "@getstrata/core/runtime/appEnv";
 import { isRlsTenancy } from "@getstrata/core/tenant/tenancyConfig";
 import { migrate } from "../db/migrate.ts";
 import { buildRoutes } from "../routes.ts";
 import { loadConfig } from "./config.ts";
-import { getSql } from "./database.ts";
+import { closeDatabase, getSql, pingDatabase } from "./database.ts";
 ${ensureLine}import { starterProviders } from "./providers/index.ts";
 
 export interface BootstrapOptions {
@@ -4644,98 +4572,71 @@ export interface BootstrapOptions {
 }
 
 export interface BootstrappedApp {
-  context: AppContext;
+  context: InitializedAppContext;
   routes: AppRouteMap;
   config: ReturnType<typeof loadConfig>;
 }
 
-class AppConfigStore {
-  private readonly values = new Map<string, unknown>();
-
-  set<T>(key: string, value: T): T {
-    this.values.set(key, value);
-    return value;
-  }
-
-  get<T>(key: string): T | undefined {
-    return this.values.get(key) as T | undefined;
-  }
-
-  require<T>(key: string): T {
-    const value = this.get<T>(key);
-    if (value === undefined) {
-      throw new Error(\`Missing required config value "\${key}".\`);
-    }
-    return value;
-  }
-
-  has(key: string): boolean {
-    return this.values.has(key);
-  }
-}
-
-function createAppContext(): AppContext {
-  const container = new ServiceContainer();
-  const config = new AppConfigStore() as unknown as ConfigStore;
-  const dependencies: MutableAppDependencies = { container };
-  const context: ProviderContext = { container, config, dependencies };
-
-  runProviderPhase(starterProviders, "register", context);
-  runProviderPhase(starterProviders, "boot", context);
-
+async function createAppContext(): Promise<InitializedAppContext> {
+  await ensureModulesLoaded();
   const moduleProviders = discoverModules().flatMap((module) => module.providers ?? []);
-  runProviderPhase(moduleProviders, "register", context);
-  runProviderPhase(moduleProviders, "boot", context);
-
-  assertAppDependenciesComplete(dependencies);
-
-  const appContext = { container, config, dependencies: dependencies as AppDependencies };
-  setActiveApplicationContext(appContext as never);
-  return appContext;
+  return createProviderAppContext([...starterProviders, ...moduleProviders]);
 }
 
 export async function bootstrapApp(options: BootstrapOptions = {}): Promise<BootstrappedApp> {
-  const isProduction = isProductionEnv();
-  // Dev boots migrate for convenience. Production must not mutate schema on
-  // start, so run \`strata migrate\` as an explicit deploy step instead.
-  const { migrate: runMigrate = !isProduction } = options;
+  let context: InitializedAppContext | undefined;
+  try {
+    const isProduction = isProductionEnv();
+    // Dev boots migrate for convenience. Production must not mutate schema on
+    // start, so run \`strata migrate\` as an explicit deploy step instead.
+    const { migrate: runMigrate = !isProduction } = options;
 
-  if (isProduction) {
-    assertProductionSecrets();
-  }
+    if (isProduction) {
+      assertProductionSecrets();
+    }
 
-${needsEnsure(layers) ? `  await ensureAppDatabase();
-` : ""}  const appConfig = loadConfig();
-  getSql();
-  if (isRlsTenancy()) {
-    await assertRlsLiveDatabaseRole();
-  }
-  configureModulesDirectory(join(import.meta.dir, "../modules"));
-  await ensureModulesLoaded();
-  const context = createAppContext();
+${needsEnsure(layers) ? `    await ensureAppDatabase();
+` : ""}    const appConfig = loadConfig();
+    getSql();
+    if (!(await pingDatabase())) throw new Error("Database is not ready.");
+    if (isRlsTenancy()) {
+      await assertRlsLiveDatabaseRole();
+    }
+    configureModulesDirectory(join(import.meta.dir, "../modules"));
+    await ensureModulesLoaded();
+    context = await createAppContext();
 
-  if (runMigrate) {
-    await migrate();
-  }
+    if (runMigrate) {
+      await migrate();
+    }
 
-  const routes = mergeSpaRoutes(context.dependencies, {
-    ...createHealthRoutes(context.dependencies),
-    ...buildRoutes(context.dependencies),${metricsSpread}
-  }, {
-    distDirectory: join(import.meta.dir, "../../frontend/dist"),
-  });
+    const routes = mergeSpaRoutes(context.dependencies, {
+      ...createHealthRoutes(context.dependencies),
+      ...buildRoutes(context.dependencies),${metricsSpread}
+    }, {
+      distDirectory: join(import.meta.dir, "../../frontend/dist"),
+    });
 
-  return { context, routes, config: appConfig };
+    return { context, routes, config: appConfig };
+  } catch (error) {
+    const failures: unknown[] = [];
+    for (const cleanup of [() => context?.dispose(), closeDatabase]) {
+      try { await cleanup(); } catch (failure) { failures.push(failure); }
+    }
+    if (failures.length) throw new AggregateError([error, ...failures], "Application startup and cleanup failed.", { cause: error });
+    throw error;
+  }
 }
 
 export async function createApp(options: BootstrapOptions = {}) {
   return bootstrapApp({ migrate: false, ...options });
 }
 
-export function createAppServer(routes: AppRouteMap, port = 0) {
+export function createAppServer(routes: AppRouteMap, port = 0, lifecycle?: LifecycleCoordinator) {
   return createWebServer({
     port,
     publicDir: "./public",
+    lifecycle,
     routes,
   });
 }
@@ -4791,9 +4692,20 @@ function renderCliQueueWorkTs() {
   const { bootstrapApp } = await import("../bootstrap/createApp.ts");
   const { closeDatabase } = await import("../bootstrap/database.ts");
 
+  let app: Awaited<ReturnType<typeof bootstrapApp>> | undefined;
   await runQueueWorkerCommand({
-    boot: () => bootstrapApp({ migrate: false }),
-    close: closeDatabase,
+    boot: async () => {
+      app = await bootstrapApp({ migrate: false });
+    },
+    drain: () => app?.context.drain(),
+    flush: () => app?.context.flush(),
+    close: async () => {
+      try {
+        await app?.context.dispose();
+      } finally {
+        await closeDatabase();
+      }
+    },
   });
 }
 
@@ -4851,11 +4763,15 @@ export { openapiCheckCommand, openapiGenerateCommand, openapiValidateCommand };
 function renderCliScheduleRunTs() {
   return `async function scheduleRunCommand(): Promise<void> {
   const { createScheduleRunCommand } = await import("@getstrata/cli/schedule");
+  const { bootstrapApp } = await import("../bootstrap/createApp.ts");
+  const { closeDatabase } = await import("../bootstrap/database.ts");
+  let app: Awaited<ReturnType<typeof bootstrapApp>> | undefined;
   await createScheduleRunCommand(async () => {
-    const { bootstrapApp } = await import("../bootstrap/createApp.ts");
-    await bootstrapApp({ migrate: false });
+    app = await bootstrapApp({ migrate: false });
     await import("../bootstrap/schedule.ts");
-  })();
+  }, async () => {
+    try { await app?.context.dispose(); } finally { await closeDatabase(); }
+  }, { drain: () => app?.context.drain(), flush: () => app?.context.flush() })();
 }
 
 export { scheduleRunCommand };
@@ -5237,6 +5153,7 @@ function renderScimModule(layers) {
     return null;
   }
   return `import { randomBytes } from "node:crypto";
+import type { HttpKernel } from "@getstrata/bootstrap/httpKernel";
 import type { AppModule } from "@getstrata/bootstrap/contracts";
 import { routeParams } from "@getstrata/bootstrap/web/routing";
 import { createScimAuthMiddleware } from "@getstrata/core/auth/scimAuthMiddleware";
@@ -5334,12 +5251,12 @@ function readName(body: Record<string, unknown>, fallback: string): string {
   return fallback;
 }
 
-function wrapScim(handler: (request: Request) => Promise<Response>) {
-  const throttle = createScimThrottleMiddleware({
+function wrapScim(kernel: HttpKernel, handler: (request: Request) => Promise<Response>) {
+  const throttle = kernel.ownThrottle(createScimThrottleMiddleware({
     redisUrl: process.env.REDIS_URL,
     maxAttempts: 120,
     decaySeconds: 60,
-  });
+  }));
   return withMiddleware(throttle, createScimAuthMiddleware())(
     withErrorHandling(async (request) => {
       if (!scimEnabled()) {
@@ -5358,7 +5275,7 @@ const scimModule: AppModule = {
       "/scim/v2/ServiceProviderConfig": {
         GET: kernel.wrap(
           "api",
-          wrapScim(async () =>
+          wrapScim(kernel, async () =>
             scimJson({
               schemas: [CONFIG_SCHEMA],
               patch: { supported: true },
@@ -5383,7 +5300,7 @@ const scimModule: AppModule = {
       "/scim/v2/Users": {
         GET: kernel.wrap(
           "api",
-          wrapScim(async (request) => {
+          wrapScim(kernel, async (request) => {
             const url = new URL(request.url);
             const filter = url.searchParams.get("filter") ?? "";
             const match = /userName\\s+eq\\s+"([^"]+)"/i.exec(filter);
@@ -5415,7 +5332,7 @@ const scimModule: AppModule = {
         ),
         POST: kernel.wrap(
           "api",
-          wrapScim(async (request) => {
+          wrapScim(kernel, async (request) => {
             const body = (await request.json()) as Record<string, unknown>;
             const email = readUserName(body);
             const name = readName(body, email.split("@")[0] ?? "User");
@@ -5438,7 +5355,7 @@ const scimModule: AppModule = {
       "/scim/v2/Users/:id": {
         GET: kernel.wrap(
           "api",
-          wrapScim(async (request) => {
+          wrapScim(kernel, async (request) => {
             const id = readScimUserId(request);
             if (id instanceof Response) {
               return id;
@@ -5452,7 +5369,7 @@ const scimModule: AppModule = {
         ),
         PUT: kernel.wrap(
           "api",
-          wrapScim(async (request) => {
+          wrapScim(kernel, async (request) => {
             const id = readScimUserId(request);
             if (id instanceof Response) {
               return id;
@@ -5473,7 +5390,7 @@ const scimModule: AppModule = {
         ),
         PATCH: kernel.wrap(
           "api",
-          wrapScim(async (request) => {
+          wrapScim(kernel, async (request) => {
             const id = readScimUserId(request);
             if (id instanceof Response) {
               return id;
@@ -5514,7 +5431,7 @@ const scimModule: AppModule = {
         ),
         DELETE: kernel.wrap(
           "api",
-          wrapScim(async (request) => {
+          wrapScim(kernel, async (request) => {
             const id = readScimUserId(request);
             if (id instanceof Response) {
               return id;

package/dist/templates/package.json

@@ -12,9 +12,9 @@
     "check": "tsc --noEmit"
   },
   "dependencies": {
-    "@getstrata/bootstrap": "^2.0.9",
-    "@getstrata/cli": "^2.0.9",
-    "@getstrata/core": "^2.0.9",
+    "@getstrata/bootstrap": "^2.2.0",
+    "@getstrata/cli": "^2.2.0",
+    "@getstrata/core": "^2.2.0",
     "eta": "^4.6.0"
   },
   "devDependencies": {

package/dist/templates/src/bootstrap/providers/cache.ts

@@ -5,13 +5,13 @@ import type { ServiceProvider } from "@getstrata/core/contracts/di";
 
 const cacheProvider: ServiceProvider = {
   name: "starter.cache",
-  register({ container, config, dependencies }) {
+  register({ container, config, dependencies, onCleanup }) {
     container.singleton(CORE_CACHE_TOKEN, () => {
       const ttlMs = config.get<number>("cache.ttlMs") ?? 3_600_000;
       const maxEntries = config.get<number>("cache.maxEntries") ?? 100;
       const driver = config.get<"array" | "redis">("cache.driver") ?? "array";
 
-      return new CacheRepository(
+      const cache = new CacheRepository(
         createCacheStore({
           driver,
           ttlMs,
@@ -19,6 +19,8 @@ const cacheProvider: ServiceProvider = {
           redisUrl: process.env.REDIS_URL,
         }),
       );
+      onCleanup(() => cache.close());
+      return cache;
     });
 
     Reflect.set(dependencies, "cache", container.resolve(CORE_CACHE_TOKEN));

package/dist/templates/src/bootstrap/server.ts

@@ -1,25 +1,28 @@
 import "./preload.ts";
-import { ensureModulesLoaded } from "@getstrata/bootstrap/discoverModules";
+import {
+  installGracefulShutdownSignals,
+  LifecycleCoordinator,
+} from "@getstrata/core/lifecycle/gracefulShutdown";
 import { bootstrapApp, createAppServer } from "./createApp.ts";
-import { closeDatabase, pingDatabase } from "./database.ts";
+import { closeDatabase } from "./database.ts";
 
-await ensureModulesLoaded();
-
-const { routes, config } = await bootstrapApp();
-
-const server = createAppServer(routes, config.port);
-
-console.log(`Listening on http://localhost:${server.port} (APP_URL ${config.appUrl})`);
-
-if (!(await pingDatabase())) {
-  console.warn("Warning: database ping failed.");
-}
-
-async function shutdown() {
-  await closeDatabase();
-  server.stop();
-  process.exit(0);
+const { routes, config, context } = await bootstrapApp();
+const lifecycle = new LifecycleCoordinator();
+let server: ReturnType<typeof createAppServer>;
+try {
+  server = createAppServer(routes, config.port, lifecycle);
+} catch (error) {
+  try {
+    await context.dispose();
+  } finally {
+    await closeDatabase();
+  }
+  throw error;
 }
+console.log(`Listening on http://localhost:${server.port} (APP_URL ${config.appUrl})`);
 
-process.on("SIGINT", shutdown);
-process.on("SIGTERM", shutdown);
+lifecycle.register("providers:drain", () => context.drain(), "drain");
+lifecycle.register("providers:flush", () => context.flush(), "flush");
+lifecycle.register("providers:close", () => context.dispose(), "close");
+lifecycle.register("database", closeDatabase, "close");
+installGracefulShutdownSignals(undefined, lifecycle);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/starter",
-  "version": "2.0.9",
+  "version": "2.2.0",
   "description": "Interactive create-strata wizard. Choose each layer; one database engine.",
   "type": "module",
   "license": "MIT",