@getstrata/starter 1.1.0 → 1.1.2

package/README.md

@@ -34,7 +34,7 @@ Pick one database engine. Docker Compose is optional (`--docker`, `--no-docker`,
 
 A Bun and TypeScript app on `@getstrata/core` and `@getstrata/bootstrap` that boots, migrates, and passes `bun run check`. Cookie apps include a restyleable welcome page, `/login`, `/register`, and password reset. Token apps include `POST /api/v1/auth/login` plus register and reset. Tenancy is `none`, `column` (any engine), or `rls` (Postgres only; other engines fall back to `column`). Choices are recorded in `strata.layers.json`.
 
-The `strata` binary installs into the app rather than globally, so use the generated `bun run` scripts.
+The `strata` binary installs into the app rather than globally, so use the generated `bun run` scripts. Generated apps ship `src/cli/register.ts` with `queue:work` (`bun run queue:work`, requires `REDIS_URL`), `make:*`, `openapi:*`, and `schedule:run`. `queue:work` boots that app rather than the framework-repo worker.
 
 ## Docs
 

package/dist/cli.js

@@ -2856,9 +2856,9 @@ function renderPackageJson(projectName, options = {}) {
     "@getstrata/cli": "workspace:*",
     "@getstrata/core": "workspace:*"
   } : {
-    "@getstrata/bootstrap": "^1.1.0",
-    "@getstrata/cli": "^1.1.0",
-    "@getstrata/core": "^1.1.0"
+    "@getstrata/bootstrap": "^1.1.2",
+    "@getstrata/cli": "^1.1.2",
+    "@getstrata/core": "^1.1.2"
   };
   coreDeps.eta = "^4.6.0";
   if (options.layers?.database === "mysql") {
@@ -2869,6 +2869,7 @@ function renderPackageJson(projectName, options = {}) {
     start: "strata start",
     "db:migrate": "strata migrate",
     "db:fresh": "strata migrate:fresh",
+    "queue:work": "strata queue:work",
     check: "tsc --noEmit"
   };
   if (options.layers && needsFrontendBuild(options.layers.frontend)) {
@@ -3081,7 +3082,7 @@ ${next.join(`
 `)}
 \`\`\`
 
-Open http://localhost:3000. Health check: \`GET /health\`.
+Open http://localhost:3000. Health check: \`GET /health\`. Redis worker: \`bun run queue:work\` (requires \`REDIS_URL\`).
 
 ${renderSupportingToolsReadme(layers)}${layers.auth !== "headers" ? `
 Seeded login (password \`StrataDemo!ChangeMe\`):
@@ -3146,7 +3147,7 @@ The image sets \`APP_ENV=production\` and \`AUTH_DEV_HEADERS=false\`; everything
 - Behind a reverse proxy or load balancer, set \`TRUST_FORWARDED_FOR=true\` so throttles and session records see the client address instead of the proxy. Only the rightmost public hop of \`X-Forwarded-For\` is trusted.
 ${authUsesCookie(layers.auth) ? "- Set `SESSION_SECRET` to 32+ characters.\n" : ""}${authUsesToken(layers.auth) ? "- Set `TOKEN_HASH_PEPPER`.\n" : ""}${layers.extras.scim ? "- Set `SCIM_BEARER_TOKEN`.\n" : ""}${layers.extras.metrics ? "- Set `METRICS_TOKEN`.\n" : ""}${layers.tenancy === "rls" ? `- \`DATABASE_URL\` must be a \`NOBYPASSRLS\` role, not the \`postgres\` superuser. Generated apps create \`${GENERATED_POSTGRES_APP_ROLE}\` via \`db/ensure-postgres-app-role.sql\` (and Compose init on first empty volume). \`MIGRATION_DATABASE_URL\` may stay the superuser for CREATE ROLE / GRANT / migrate. Production boot rejects username \`postgres\` or \`root\`, then inspects \`pg_roles\` for \`rolsuper\` / \`rolbypassrls\`.
 ` : ""}
-\`strata start\` does not migrate when \`APP_ENV=production\`. Run \`bun run db:migrate\` as a deploy step. \`GET /health\` is 200 when \`notes\` is readable (including zero rows) and 503 when that read fails.
+\`strata start\` does not migrate when \`APP_ENV=production\`. Run \`bun run db:migrate\` as a deploy step. \`GET /health\` is 200 when \`notes\` is readable (including zero rows) and 503 when that read fails. Redis jobs need a worker: \`bun run queue:work\` (requires \`REDIS_URL\`).
 `;
 }
 
@@ -3473,11 +3474,19 @@ export async function closeDatabase() {
 }
 `;
 }
-function renderMigrateTs(layers) {
+function starterSchemaStatements(layers) {
   const d = dialectFragments(layers.database);
   const statements = [];
   const tenancyOn = usesTenantTable(layers.tenancy);
   const mfaOn = layers.extras.mfa && authNeedsUsers(layers.auth);
+  const payloadType = layers.database === "postgres" ? "JSONB NOT NULL" : `${d.text} NOT NULL`;
+  statements.push(`CREATE TABLE IF NOT EXISTS failed_job (
+    id ${d.id},
+    job_name ${d.keyText} NOT NULL,
+    payload ${payloadType},
+    exception ${d.text} NOT NULL,
+    failed_at ${d.timestamp}
+  )`);
   if (tenancyOn) {
     statements.push(`CREATE TABLE IF NOT EXISTS tenant (
     id ${d.id},
@@ -3564,8 +3573,87 @@ function renderMigrateTs(layers) {
     }
     statements.push(generatedRlsBootstrapSql(rlsTables, userOwnedTables).trim());
   }
-  const list = statements.map((sql) => `  \`${sql.replace(/`/g, "\\`")}\`,`).join(`
+  return statements;
+}
+function renderStarterSchemaMigration(layers) {
+  const statements = starterSchemaStatements(layers);
+  const cascade = layers.database === "sqlite" ? "" : " CASCADE";
+  const upCalls = statements.map((sql) => `    await db.unsafe(${JSON.stringify(sql)});`).join(`
 `);
+  const downCalls = dropTables(layers).map((table) => `    await db.unsafe("DROP TABLE IF EXISTS ${table}${cascade}");`).join(`
+`);
+  return `import type { Migration } from "@getstrata/core/database/migrations/types";
+
+const migration: Migration = {
+  name: "0001_starter_schema",
+  async up(db) {
+${upCalls}
+  },
+  async down(db) {
+${downCalls}
+  },
+};
+
+export default migration;
+`;
+}
+function renderMigrationRuntimeTs(layers) {
+  if (layers.database === "postgres") {
+    return `import { join } from "node:path";
+import { loadMigrationsFromDirectory } from "@getstrata/core/database/migrations";
+import type { MigrationDatabase } from "@getstrata/core/database/migrations/types";
+import {
+  grantPostgresAppRolePrivileges,
+  openPostgresAdminConnection,
+  postgresDatabaseNameFromUrl,
+} from "@getstrata/core/tenant/enableTenantRls";
+
+const MIGRATIONS_DIRECTORY = join(import.meta.dir, "migrations");
+
+export async function loadStarterMigrations() {
+  return loadMigrationsFromDirectory(MIGRATIONS_DIRECTORY);
+}
+
+export async function withMigrationDatabase<T>(
+  fn: (db: MigrationDatabase) => Promise<T>,
+): Promise<T> {
+  const runtimeUrl = process.env.DATABASE_URL ?? "";
+  const admin = await openPostgresAdminConnection({
+    runtimeUrl,
+    migrationUrl: process.env.MIGRATION_DATABASE_URL,
+  });
+  try {
+    const result = await fn(admin);
+    await grantPostgresAppRolePrivileges(admin, {
+      database: postgresDatabaseNameFromUrl(runtimeUrl),
+    });
+    return result;
+  } finally {
+    await admin.close?.();
+  }
+}
+`;
+  }
+  return `import { join } from "node:path";
+import { loadMigrationsFromDirectory } from "@getstrata/core/database/migrations";
+import type { MigrationDatabase } from "@getstrata/core/database/migrations/types";
+import { getSql } from "../bootstrap/database.ts";
+
+const MIGRATIONS_DIRECTORY = join(import.meta.dir, "migrations");
+
+export async function loadStarterMigrations() {
+  return loadMigrationsFromDirectory(MIGRATIONS_DIRECTORY);
+}
+
+export async function withMigrationDatabase<T>(
+  fn: (db: MigrationDatabase) => Promise<T>,
+): Promise<T> {
+  return fn(getSql());
+}
+`;
+}
+function renderMigrateTs(layers) {
+  const tenancyOn = usesTenantTable(layers.tenancy);
   const ph = layers.database === "postgres";
   const verifyOn = layers.extras.emailVerification && authNeedsUsers(layers.auth);
   const verifiedNow = nowTimestampLiteral(layers.database);
@@ -3600,8 +3688,6 @@ function renderMigrateTs(layers) {
   const hashImport = authNeedsUsers(layers.auth) ? `import { hashPassword } from "@getstrata/core/auth/password";
 ` : "";
   const rlsBypassImport = layers.tenancy === "rls" && layers.database === "postgres" ? `import { runWithMigrationBypass } from "@getstrata/core/tenant/databaseTenantContext";
-` : "";
-  const postgresRoleImport = layers.database === "postgres" ? `import { grantPostgresAppRolePrivileges, openPostgresAdminConnection, postgresDatabaseNameFromUrl } from "@getstrata/core/tenant/enableTenantRls";
 ` : "";
   const bindSql = seedTenant || layers.tenancy === "rls" && layers.database === "postgres" ? `  const sql = getSql();
 ` : "";
@@ -3612,15 +3698,13 @@ function renderMigrateTs(layers) {
   const noteCreate = tenancyOn ? `await Note.create({ body: "Welcome to Strata!", tenant_id: 1 });` : `await Note.create({ body: "Welcome to Strata!" });`;
   const userImport = authNeedsUsers(layers.auth) ? `import { User } from "../models/User.ts";
 ` : "";
-  const needsSqlClient = layers.database !== "postgres" || Boolean(seedTenant) || layers.tenancy === "rls" && layers.database === "postgres";
+  const needsSqlClient = Boolean(seedTenant) || layers.tenancy === "rls" && layers.database === "postgres";
   const databaseImport = needsSqlClient ? `import { closeDatabase, getSql } from "../bootstrap/database.ts";
 ` : `import { closeDatabase } from "../bootstrap/database.ts";
 `;
-  return `${hashImport}${rlsBypassImport}${postgresRoleImport}${ensureImport(layers)}${databaseImport}import { Note } from "../models/Note.ts";
-${userImport}
-const migrations = [
-${list}
-];
+  return `${hashImport}${rlsBypassImport}${ensureImport(layers)}${databaseImport}import { migrateDatabase } from "@getstrata/core/database/migrations";
+import { Note } from "../models/Note.ts";
+${userImport}import { loadStarterMigrations, withMigrationDatabase } from "./migrationRuntime.ts";
 
 export async function seed() {
 ${ensureCall(layers)}${bindSql}${seedOpen}${seedTenant}
@@ -3630,26 +3714,10 @@ ${ensureCall(layers)}${bindSql}${seedOpen}${seedTenant}
 }
 
 export async function migrate() {
-${ensureCall(layers)}${layers.database === "postgres" ? `  const runtimeUrl = process.env.DATABASE_URL ?? "";
-  const admin = await openPostgresAdminConnection({
-    runtimeUrl,
-    migrationUrl: process.env.MIGRATION_DATABASE_URL,
+${ensureCall(layers)}  await withMigrationDatabase(async (db) => {
+    await migrateDatabase(db, await loadStarterMigrations());
   });
-  try {
-    for (const statement of migrations) {
-      await admin.unsafe(statement);
-    }
-    await grantPostgresAppRolePrivileges(admin, {
-      database: postgresDatabaseNameFromUrl(runtimeUrl),
-    });
-  } finally {
-    await admin.close?.();
-  }
-` : `  const sql = getSql();
-  for (const statement of migrations) {
-    await sql.unsafe(statement);
-  }
-`}  await seed();
+  await seed();
 }
 
 /** The CLI calls this after migrate() so pooled drivers do not hold the process open. */
@@ -3862,7 +3930,7 @@ export { AuthOneTimeToken };
 `;
 }
 function dropTables(layers) {
-  const ordered = [];
+  const ordered = ["failed_job"];
   if (authUsesToken(layers.auth)) {
     ordered.push("api_tokens");
   }
@@ -3880,31 +3948,17 @@ function dropTables(layers) {
   }
   return ordered;
 }
-function renderPostgresAdminDropCall() {
-  return `  await dropPostgresTablesAsAdmin(tables, {
-    runtimeUrl: process.env.DATABASE_URL ?? "",
-    migrationUrl: process.env.MIGRATION_DATABASE_URL,
-  });
-`;
-}
 function renderFreshTs(layers) {
-  const tables = dropTables(layers);
-  const cascade = layers.database === "sqlite" ? "" : " CASCADE";
-  const imports = layers.database === "postgres" ? `import { dropPostgresTablesAsAdmin } from "@getstrata/core/tenant/enableTenantRls";
-${ensureImport(layers)}import { closeDatabase } from "../bootstrap/database.ts";
-import { migrate } from "./migrate.ts";` : `${ensureImport(layers)}import { closeDatabase, getSql } from "../bootstrap/database.ts";
-import { migrate } from "./migrate.ts";`;
-  const dropBody = layers.database === "postgres" ? `${renderPostgresAdminDropCall()}  await migrate();` : `  const sql = getSql();
-  for (const table of tables) {
-    await sql.unsafe(\`DROP TABLE IF EXISTS \${table}${cascade}\`);
-  }
-  await migrate();`;
-  return `${imports}
-
-const tables = ${JSON.stringify(tables)};
+  return `${ensureImport(layers)}import { freshDatabase } from "@getstrata/core/database/migrations";
+import { closeDatabase } from "../bootstrap/database.ts";
+import { seed } from "./migrate.ts";
+import { loadStarterMigrations, withMigrationDatabase } from "./migrationRuntime.ts";
 
 export async function fresh() {
-${ensureCall(layers)}${dropBody}
+${ensureCall(layers)}  await withMigrationDatabase(async (db) => {
+    await freshDatabase(db, await loadStarterMigrations());
+  });
+  await seed();
 }
 
 /** The CLI calls this after fresh() so pooled drivers do not hold the process open. */
@@ -3933,23 +3987,17 @@ if (import.meta.main) {
 `;
 }
 function renderStatusTs(layers) {
-  const tables = dropTables(layers);
-  return `${ensureImport(layers)}import { getSql } from "../bootstrap/database.ts";
-
-const tables = ${JSON.stringify(tables)};
+  return `${ensureImport(layers)}import { getMigrationStatus } from "@getstrata/core/database/migrations";
+import { loadStarterMigrations, withMigrationDatabase } from "./migrationRuntime.ts";
 
 export async function status() {
-${ensureCall(layers)}  const sql = getSql();
-  console.log("Starter schema (inline SQL, not a migration runner):");
-  for (const table of tables) {
-    try {
-      const rows = await sql.unsafe<{ count: string | number }>(
-        \`SELECT COUNT(*) AS count FROM \${table}\`,
-      );
-      console.log(\`- [present] \${table} (rows: \${rows[0]?.count ?? 0})\`);
-    } catch {
-      console.log(\`- [missing] \${table}\`);
-    }
+${ensureCall(layers)}  const rows = await withMigrationDatabase(async (db) => {
+    return getMigrationStatus(db, await loadStarterMigrations());
+  });
+  console.log("Migrations:");
+  for (const row of rows) {
+    const batch = row.batch == null ? "" : \` (batch \${row.batch})\`;
+    console.log(\`- [\${row.status}] \${row.name}\${batch}\`);
   }
 }
 
@@ -3960,28 +4008,25 @@ if (import.meta.main) {
 `;
 }
 function renderRollbackTs(layers) {
-  const tables = dropTables(layers);
-  const cascade = layers.database === "sqlite" ? "" : " CASCADE";
-  const imports = layers.database === "postgres" ? `import { dropPostgresTablesAsAdmin } from "@getstrata/core/tenant/enableTenantRls";
-${ensureImport(layers)}` : `${ensureImport(layers)}import { getSql } from "../bootstrap/database.ts";`;
-  const dropBody = layers.database === "postgres" ? `${renderPostgresAdminDropCall()}  for (const table of tables) {
-    console.log(\`dropped \${table}\`);
-  }` : `  const sql = getSql();
-  for (const table of tables) {
-    await sql.unsafe(\`DROP TABLE IF EXISTS \${table}${cascade}\`);
-    console.log(\`dropped \${table}\`);
-  }`;
-  return `${imports}
-
-const tables = ${JSON.stringify(tables)};
+  return `${ensureImport(layers)}import { rollbackDatabase } from "@getstrata/core/database/migrations";
+import { loadStarterMigrations, withMigrationDatabase } from "./migrationRuntime.ts";
 
 export async function rollback() {
-${ensureCall(layers)}${dropBody}
+${ensureCall(layers)}  const rolledBack = await withMigrationDatabase(async (db) => {
+    return rollbackDatabase(db, await loadStarterMigrations(), {
+      onMigration: (name) => {
+        console.log(\`rolled back \${name}\`);
+      },
+    });
+  });
+  if (rolledBack === 0) {
+    console.log("Nothing to roll back.");
+  }
 }
 
 if (import.meta.main) {
   await rollback();
-  console.log("Rolled back starter tables.");
+  console.log("Rolled back last migration batch.");
   process.exit(0);
 }
 `;
@@ -4067,7 +4112,9 @@ export default configProvider;
 `;
 }
 function renderQueueProvider() {
-  return `import type { ServiceProvider } from "@getstrata/core/contracts/di";
+  return `import { discoverJobs } from "@getstrata/bootstrap/discoverJobs";
+import { registerDefaultJobs } from "@getstrata/bootstrap/queue/defaultJobs";
+import type { ServiceProvider } from "@getstrata/core/contracts/di";
 import { CORE_QUEUE_TOKEN } from "@getstrata/core/contracts/serviceTokens";
 import {
   createAppQueue,
@@ -4081,7 +4128,13 @@ const queueProvider: ServiceProvider = {
     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));
+    container.set(
+      CORE_QUEUE_TOKEN,
+      createAppQueue(driver, process.env.REDIS_URL, failedJobs, () => {
+        registerDefaultJobs();
+        discoverJobs();
+      }),
+    );
   },
 };
 
@@ -4185,7 +4238,9 @@ export default policyProvider;
 `;
 }
 function renderProvidersIndex() {
-  return `import type { ServiceProvider } from "@getstrata/core/contracts/di";
+  return `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";
 import cacheProvider from "./cache.ts";
 import configProvider from "./config.ts";
@@ -4193,6 +4248,30 @@ 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();
+    });
+
+    for (const registerListener of discoverListeners()) {
+      registerListener();
+    }
+  },
+};
+
 const starterProviders: ServiceProvider[] = [
   configProvider,
   cacheProvider,
@@ -4200,6 +4279,7 @@ const starterProviders: ServiceProvider[] = [
   queueProvider,
   authProvider,
   policyProvider,
+  listenersProvider,
 ];
 
 export { starterProviders };
@@ -4228,6 +4308,7 @@ import {
 import { mergeSpaRoutes } from "@getstrata/bootstrap/createSpaRoutes";
 import {
   configureModulesDirectory,
+  discoverModules,
   ensureModulesLoaded,
 } from "@getstrata/bootstrap/discoverModules";
 import { createHealthRoutes } from "@getstrata/bootstrap/health";
@@ -4286,6 +4367,10 @@ function createAppContext(): AppContext {
   runProviderPhase(starterProviders, "register", context);
   runProviderPhase(starterProviders, "boot", context);
 
+  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 };
@@ -4356,6 +4441,116 @@ export function buildRoutes(dependencies: AppDependencies): AppRouteMap {
 }
 `;
 }
+function renderCliRegisterTs() {
+  return `import type { StrataCommandMap } from "@getstrata/cli";
+
+const commands: StrataCommandMap = {
+  "make:module": async () => (await import("@getstrata/cli/scaffold")).makeModuleCommand,
+  "make:policy": async () => (await import("@getstrata/cli/scaffold")).makePolicyCommand,
+  "make:job": async () => (await import("@getstrata/cli/scaffold")).makeJobCommand,
+  "make:listener": async () => (await import("@getstrata/cli/scaffold")).makeListenerCommand,
+  "make:request": async () => (await import("@getstrata/cli/scaffold")).makeRequestCommand,
+  "make:factory": async () => (await import("@getstrata/cli/scaffold")).makeFactoryCommand,
+  "make:migration": async () => (await import("@getstrata/cli/scaffold")).makeMigrationCommand,
+  "queue:work": async () => (await import("./queueWork.ts")).queueWorkCommand,
+  "queue:failed": async () => (await import("./queueFailed.ts")).queueFailedCommand,
+  "queue:retry": async () => (await import("./queueFailed.ts")).queueRetryCommand,
+  "queue:flush-failed": async () => (await import("./queueFailed.ts")).queueFlushFailedCommand,
+  "openapi:generate": async () => (await import("./openapi.ts")).openapiGenerateCommand,
+  "openapi:validate": async () => (await import("./openapi.ts")).openapiValidateCommand,
+  "openapi:check": async () => (await import("./openapi.ts")).openapiCheckCommand,
+  "schedule:run": async () => (await import("./scheduleRun.ts")).scheduleRunCommand,
+};
+
+export { commands };
+`;
+}
+function renderCliQueueWorkTs() {
+  return `async function queueWorkCommand(): Promise<void> {
+  if (!process.env.REDIS_URL) {
+    throw new Error("queue:work requires REDIS_URL to be set.");
+  }
+
+  const { runQueueWorkerCommand } = await import("@getstrata/cli/queueWorker");
+  const { bootstrapApp } = await import("../bootstrap/createApp.ts");
+  const { closeDatabase } = await import("../bootstrap/database.ts");
+
+  await runQueueWorkerCommand({
+    boot: () => bootstrapApp({ migrate: false }),
+    close: closeDatabase,
+  });
+}
+
+export { queueWorkCommand };
+`;
+}
+function renderCliQueueFailedTs() {
+  return `async function bootApp(): Promise<void> {
+  const { bootstrapApp } = await import("../bootstrap/createApp.ts");
+  await bootstrapApp({ migrate: false });
+}
+
+async function queueFailedCommand(): Promise<void> {
+  const { queueFailedCommand: run } = await import("@getstrata/cli/queueFailed");
+  await run(bootApp);
+}
+
+async function queueRetryCommand(id?: string): Promise<void> {
+  const { queueRetryCommand: run } = await import("@getstrata/cli/queueFailed");
+  await run(id, bootApp);
+}
+
+async function queueFlushFailedCommand(): Promise<void> {
+  const { queueFlushFailedCommand: run } = await import("@getstrata/cli/queueFailed");
+  await run(bootApp);
+}
+
+export { queueFailedCommand, queueFlushFailedCommand, queueRetryCommand };
+`;
+}
+function renderCliOpenApiTs() {
+  return `async function bootstrap() {
+  const { createApp } = await import("../bootstrap/createApp.ts");
+  return createApp({ migrate: false });
+}
+
+async function openapiGenerateCommand(): Promise<void> {
+  const { createOpenApiGenerateCommand } = await import("@getstrata/cli/openapi");
+  await createOpenApiGenerateCommand(bootstrap)();
+}
+
+async function openapiValidateCommand(): Promise<void> {
+  const { createOpenApiValidateCommand } = await import("@getstrata/cli/openapi");
+  await createOpenApiValidateCommand(bootstrap)();
+}
+
+async function openapiCheckCommand(): Promise<void> {
+  const { createOpenApiCheckCommand } = await import("@getstrata/cli/openapi");
+  await createOpenApiCheckCommand(bootstrap)();
+}
+
+export { openapiCheckCommand, openapiGenerateCommand, openapiValidateCommand };
+`;
+}
+function renderCliScheduleRunTs() {
+  return `async function scheduleRunCommand(): Promise<void> {
+  const { createScheduleRunCommand } = await import("@getstrata/cli/schedule");
+  await createScheduleRunCommand(async () => {
+    const { bootstrapApp } = await import("../bootstrap/createApp.ts");
+    await bootstrapApp({ migrate: false });
+    await import("../bootstrap/schedule.ts");
+  })();
+}
+
+export { scheduleRunCommand };
+`;
+}
+function renderScheduleTs() {
+  return `import { appSchedule } from "@getstrata/core/scheduler/schedule";
+
+export { appSchedule };
+`;
+}
 function renderViewTs(layers) {
   const authImport = authNeedsUsers(layers.auth) ? `import { currentAuthUser } from "@getstrata/core/auth/authContext";
 import { resolveCsrfTokenForRequest } from "@getstrata/core/http/csrfToken";
@@ -4805,6 +5000,12 @@ function writeGeneratedFiles(options) {
     removeIfExists(join2(src, "bootstrap/ensureDatabase.ts"));
   }
   writeText(join2(src, "bootstrap/createApp.ts"), renderCreateAppTs(layers));
+  writeText(join2(src, "bootstrap/schedule.ts"), renderScheduleTs());
+  writeText(join2(src, "cli/register.ts"), renderCliRegisterTs());
+  writeText(join2(src, "cli/queueWork.ts"), renderCliQueueWorkTs());
+  writeText(join2(src, "cli/queueFailed.ts"), renderCliQueueFailedTs());
+  writeText(join2(src, "cli/openapi.ts"), renderCliOpenApiTs());
+  writeText(join2(src, "cli/scheduleRun.ts"), renderCliScheduleRunTs());
   writeText(join2(src, "bootstrap/providers/config.ts"), renderConfigProvider(layers));
   writeText(join2(src, "bootstrap/providers/queue.ts"), renderQueueProvider());
   writeText(join2(src, "bootstrap/providers/policy.ts"), renderPolicyProvider());
@@ -4824,6 +5025,8 @@ function writeGeneratedFiles(options) {
     removeIfExists(join2(src, "models/ApiToken.ts"));
   }
   writeText(join2(src, "db/migrate.ts"), renderMigrateTs(layers));
+  writeText(join2(src, "db/migrationRuntime.ts"), renderMigrationRuntimeTs(layers));
+  writeText(join2(src, "db/migrations/0001_starter_schema.ts"), renderStarterSchemaMigration(layers));
   writeText(join2(src, "db/fresh.ts"), renderFreshTs(layers));
   writeText(join2(src, "db/seed.ts"), renderSeedTs());
   writeText(join2(src, "db/status.ts"), renderStatusTs(layers));

package/dist/templates/package.json

@@ -8,12 +8,13 @@
     "start": "strata start",
     "db:migrate": "strata migrate",
     "db:fresh": "strata migrate:fresh",
+    "queue:work": "strata queue:work",
     "check": "tsc --noEmit"
   },
   "dependencies": {
-    "@getstrata/bootstrap": "^1.1.0",
-    "@getstrata/cli": "^1.1.0",
-    "@getstrata/core": "^1.1.0",
+    "@getstrata/bootstrap": "^1.1.2",
+    "@getstrata/cli": "^1.1.2",
+    "@getstrata/core": "^1.1.2",
     "eta": "^4.6.0"
   },
   "devDependencies": {

package/dist/templates/strata.config.ts

@@ -2,6 +2,7 @@ export default {
   preload: "./src/bootstrap/preload.ts",
   server: "./src/bootstrap/server.ts",
   modulesDirectory: "./src/modules",
+  commands: "./src/cli/register.ts",
   migrate: "./src/db/migrate.ts",
   fresh: "./src/db/fresh.ts",
 };

package/package.json

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

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

@@ -1,95 +0,0 @@
-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 { createWebServer } from "@getstrata/bootstrap/web/server";
-import { isProductionEnv } from "@getstrata/core/runtime/appEnv";
-import { setActiveApplicationContext } from "@getstrata/core/runtime/applicationRegistry";
-import { migrate } from "../db/migrate.ts";
-import { buildRoutes } from "../routes.ts";
-import { loadConfig } from "./config.ts";
-import { starterProviders } from "./providers/index.ts";
-
-export interface BootstrapOptions {
-  migrate?: boolean;
-}
-
-export interface BootstrappedApp {
-  context: AppContext;
-  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);
-
-  assertAppDependenciesComplete(dependencies);
-
-  const appContext = { container, config, dependencies: dependencies as AppDependencies };
-  setActiveApplicationContext(appContext as never);
-  return appContext;
-}
-
-export async function bootstrapApp(options: BootstrapOptions = {}): Promise<BootstrappedApp> {
-  const isProduction = isProductionEnv();
-  const { migrate: runMigrate = !isProduction } = options;
-
-  const appConfig = loadConfig();
-  const context = createAppContext();
-
-  if (runMigrate) {
-    await migrate();
-  }
-
-  const routes = buildRoutes(context.dependencies);
-
-  return { context, routes, config: appConfig };
-}
-
-export function createAppServer(routes: AppRouteMap, port = 0) {
-  return createWebServer({
-    port,
-    publicDir: "./public",
-    routes,
-  });
-}
-
-export { createAppContext };