@getstrata/cli 1.1.1 → 1.1.3

package/CHANGELOG.md

@@ -1,5 +1,19 @@
 # @getstrata/cli changelog
 
+## 1.1.3
+
+- Eager with() arrays, OpenAPI mkdir, public-read/auth docs
+
+## 1.1.2
+
+- Product CLI helpers, file migrations, and job discovery.
+
+## Unreleased
+
+- Export `queueWorker`, `queueFailed`, `scaffold`, `openapi`, and `schedule` subpaths. Generated apps register `queue:work` through `runQueueWorkerCommand({ boot, close })` (no secrets guard in the helper), plus failed-job commands, `make:*`, `openapi:*`, and `schedule:run`. Monorepo `queue:failed` / `retry` / `flush-failed` go through `createQueueFailedCommands()` so they type as `StrataCommand`. `boot` may return a value (`bootstrapApp()` returns the app).
+- `make:job` emits `static jobName`. `make:request` imports `@getstrata/core/http`. `make:module --with-web` writes `views/` when that directory exists.
+- Peer dependencies on `@getstrata/core` and `@getstrata/bootstrap`.
+
 ## 1.1.1
 
 Fix generated app boot

package/README.md

@@ -19,6 +19,8 @@ strata help
 
 `strata start` does not migrate when `APP_ENV=production`. Run `strata migrate` as an explicit deploy step.
 
+App commands from `src/cli/register.ts` merge with this list. Generated apps add `queue:work`, failed-job commands, `make:*`, `openapi:*`, and `schedule:run`.
+
 ## Running it
 
 This package installs into your app, not globally, so `strata` lands in `node_modules/.bin` and is not on your `PATH`. Use the scripts a generated app already ships:
@@ -49,9 +51,9 @@ From the current working directory, `strata` loads `strata.config.ts` if present
 | `migrate` | `src/db/migrate.ts` |
 | `fresh` | `src/db/fresh.ts` |
 
-`src/cli/register.ts` can export `commands` or `registerCommands()` to add your own commands. Generated apps do not ship one.
+`src/cli/register.ts` can export `commands` or `registerCommands()` to add your own commands. Generated apps ship `queue:work`, which boots the app (`bootstrapApp` / `createApp`) rather than the monorepo provider stack, plus `make:*`, failed-job commands, `openapi:*`, and `schedule:run`.
 
-The published `strata` binary does **not** include monorepo codegen (`make:module`, `make:migration`, `make:job`, `openapi:*`, `queue:work`, `schedule:run`, …). Those commands ship with the [Strata framework repo](https://github.com/EyK-26/strata) CLI (`bun run cli …` when developing the framework). Product apps can copy `src/cli/register.ts` from that repo or implement their own registrars. Scaffold commands resolve paths from the app working directory (`src/modules`, `src/db/migrations`, `src/jobs`). See [docs/BUILDING-APPS.md](https://github.com/EyK-26/strata/blob/main/docs/BUILDING-APPS.md#extending-the-cli).
+Helpers live on package subpaths: `@getstrata/cli/queueWorker`, `@getstrata/cli/queueFailed`, `@getstrata/cli/scaffold`, `@getstrata/cli/openapi`, and `@getstrata/cli/schedule`. `queue:work` takes `{ boot, close }` and does not call `assertProductionSecrets()` (that belongs in app boot). Scaffold commands resolve paths from the app working directory (`src/modules`, `src/db/migrations`, `src/jobs`, `views/` or `resources/views`). See [docs/BUILDING-APPS.md](https://github.com/EyK-26/strata/blob/main/docs/BUILDING-APPS.md#extending-the-cli).
 
 A migrate entry may export `close()`. The CLI calls it after `migrate()` and `fresh()` so pooled drivers such as `mysql2` release the event loop instead of hanging the command.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/cli",
-  "version": "1.1.1",
+  "version": "1.1.3",
   "description": "Strata CLI: framework commands for Bun apps (dev, start, migrate, run)",
   "type": "module",
   "license": "MIT",
@@ -16,6 +16,26 @@
     ".": {
       "import": "./src/index.ts",
       "default": "./src/index.ts"
+    },
+    "./queueWorker": {
+      "import": "./src/queueWorker.ts",
+      "default": "./src/queueWorker.ts"
+    },
+    "./queueFailed": {
+      "import": "./src/queueFailed.ts",
+      "default": "./src/queueFailed.ts"
+    },
+    "./scaffold": {
+      "import": "./src/scaffold/index.ts",
+      "default": "./src/scaffold/index.ts"
+    },
+    "./openapi": {
+      "import": "./src/openapi.ts",
+      "default": "./src/openapi.ts"
+    },
+    "./schedule": {
+      "import": "./src/schedule.ts",
+      "default": "./src/schedule.ts"
     }
   },
   "files": [
@@ -25,6 +45,10 @@
     "CHANGELOG.md"
   ],
   "scripts": {},
+  "peerDependencies": {
+    "@getstrata/bootstrap": "^1.1.1",
+    "@getstrata/core": "^1.1.1"
+  },
   "publishConfig": {
     "access": "public"
   },

package/src/openapi.ts

@@ -0,0 +1,89 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { registerOpenApiRouteMap } from "@getstrata/bootstrap/buildModuleRoutes";
+import { routeRegistry } from "@getstrata/bootstrap/routeRegistry";
+import { generateOpenApiSpec, renderOpenApiDocument } from "@getstrata/core/openapi/generator";
+import { validateOpenApiSpec } from "@getstrata/core/openapi/validate";
+
+type AppBootstrap = () => Promise<{ routes: Record<string, unknown> }>;
+
+function withoutSpaCatchAll(routes: Record<string, unknown>): Record<string, unknown> {
+  const next = { ...routes };
+  delete next["/*"];
+  return next;
+}
+
+async function registerAppOpenApiRoutes(bootstrap: AppBootstrap): Promise<void> {
+  const { routes } = await bootstrap();
+  routeRegistry.clear();
+  registerOpenApiRouteMap(withoutSpaCatchAll(routes), ["global", "api"]);
+}
+
+function createOpenApiGenerateCommand(bootstrap: AppBootstrap) {
+  return async function openapiGenerateCommand(): Promise<void> {
+    await registerAppOpenApiRoutes(bootstrap);
+
+    const spec = generateOpenApiSpec(routeRegistry.list());
+    const jsonPath = join(process.cwd(), "docs/openapi.json");
+    await mkdir(dirname(jsonPath), { recursive: true });
+    await writeFile(jsonPath, renderOpenApiDocument(spec), "utf8");
+
+    console.log(`OpenAPI spec written to ${jsonPath} (${routeRegistry.list().length} routes).`);
+  };
+}
+
+function createOpenApiValidateCommand(bootstrap: AppBootstrap) {
+  return async function openapiValidateCommand(): Promise<void> {
+    await registerAppOpenApiRoutes(bootstrap);
+
+    const spec = generateOpenApiSpec(routeRegistry.list());
+    const errors = validateOpenApiSpec(spec);
+
+    if (errors.length > 0) {
+      console.error("OpenAPI validation failed:");
+      for (const error of errors) {
+        console.error(`- ${error}`);
+      }
+      process.exit(1);
+    }
+
+    console.log(`OpenAPI spec valid (${routeRegistry.list().length} routes).`);
+  };
+}
+
+function createOpenApiCheckCommand(bootstrap: AppBootstrap) {
+  return async function openapiCheckCommand(): Promise<void> {
+    await registerAppOpenApiRoutes(bootstrap);
+
+    const spec = generateOpenApiSpec(routeRegistry.list());
+    const errors = validateOpenApiSpec(spec);
+
+    if (errors.length > 0) {
+      console.error("OpenAPI validation failed:");
+      for (const error of errors) {
+        console.error(`- ${error}`);
+      }
+      process.exit(1);
+    }
+
+    const generated = renderOpenApiDocument(spec);
+    const jsonPath = join(process.cwd(), "docs/openapi.json");
+    const committed = await readFile(jsonPath, "utf8");
+
+    if (committed !== generated) {
+      console.error("OpenAPI spec drift detected.");
+      console.error("Run `strata openapi:generate` and commit docs/openapi.json.");
+      process.exit(1);
+    }
+
+    console.log(`OpenAPI spec matches committed file (${routeRegistry.list().length} routes).`);
+  };
+}
+
+export type { AppBootstrap };
+export {
+  createOpenApiCheckCommand,
+  createOpenApiGenerateCommand,
+  createOpenApiValidateCommand,
+  registerAppOpenApiRoutes,
+};

package/src/queueFailed.ts

@@ -0,0 +1,74 @@
+import { createFailedJobService } from "@getstrata/core/queue/createAppQueue";
+import { jobRegistry } from "@getstrata/core/queue/jobRegistry";
+import { runQueueJob } from "@getstrata/core/queue/jobRunner";
+import type { StrataCommand } from "./types.ts";
+
+type QueueFailedBoot = () => unknown | Promise<unknown>;
+
+async function queueFailedCommand(boot?: QueueFailedBoot): Promise<void> {
+  await boot?.();
+  const failedJobs = createFailedJobService();
+  const jobs = await failedJobs.listRecent();
+
+  if (jobs.length === 0) {
+    console.log("No failed jobs.");
+    return;
+  }
+
+  for (const job of jobs) {
+    console.log(`#${job.id} ${job.job_name} failed at ${job.failed_at.toISOString()}`);
+  }
+}
+
+async function queueRetryCommand(id?: string, boot?: QueueFailedBoot): Promise<void> {
+  if (!id) {
+    throw new Error("queue:retry requires a failed job id.");
+  }
+
+  await boot?.();
+  const failedJobs = createFailedJobService();
+  const failedJob = await failedJobs.retry(Number.parseInt(id, 10));
+
+  const job = jobRegistry.create(failedJob.job_name);
+
+  if (!job) {
+    throw new Error(`Unknown job "${failedJob.job_name}".`);
+  }
+
+  await runQueueJob(
+    {
+      name: failedJob.job_name,
+      payload: failedJob.payload,
+      attempts: 0,
+    },
+    failedJobs,
+  );
+
+  console.log(`Retried failed job #${id}.`);
+}
+
+async function queueFlushFailedCommand(boot?: QueueFailedBoot): Promise<void> {
+  await boot?.();
+  const deleted = await createFailedJobService().flush();
+  console.log(`Removed ${deleted} failed job(s).`);
+}
+
+function createQueueFailedCommands(boot?: QueueFailedBoot): {
+  queueFailedCommand: StrataCommand;
+  queueRetryCommand: StrataCommand;
+  queueFlushFailedCommand: StrataCommand;
+} {
+  return {
+    queueFailedCommand: async () => queueFailedCommand(boot),
+    queueRetryCommand: async (id?: string) => queueRetryCommand(id, boot),
+    queueFlushFailedCommand: async () => queueFlushFailedCommand(boot),
+  };
+}
+
+export type { QueueFailedBoot };
+export {
+  createQueueFailedCommands,
+  queueFailedCommand,
+  queueFlushFailedCommand,
+  queueRetryCommand,
+};

package/src/queueWorker.ts

@@ -0,0 +1,45 @@
+import {
+  installGracefulShutdownSignals,
+  registerShutdownHandler,
+} from "@getstrata/core/lifecycle/gracefulShutdown";
+import { createFailedJobService, createQueueWorker } from "@getstrata/core/queue/createAppQueue";
+
+type QueueWorkerBoot = () => unknown | Promise<unknown>;
+type QueueWorkerClose = () => unknown | Promise<unknown>;
+
+async function runQueueWorkerCommand(options: {
+  boot: QueueWorkerBoot;
+  close?: QueueWorkerClose;
+  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.");
+  }
+
+  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.");
+}
+
+export type { QueueWorkerBoot, QueueWorkerClose };
+export { runQueueWorkerCommand };

package/src/scaffold/index.ts

@@ -0,0 +1,47 @@
+import type { StrataCommandMap } from "../types.ts";
+import { makeFactoryCommand } from "./makeFactory.ts";
+import { makeJobCommand } from "./makeJob.ts";
+import { makeListenerCommand } from "./makeListener.ts";
+import { makeMigrationCommand } from "./makeMigration.ts";
+import { makeModuleCommand } from "./makeModule.ts";
+import { makePolicyCommand } from "./makePolicy.ts";
+import { makeRequestCommand } from "./makeRequest.ts";
+import {
+  ensureDirectory,
+  migrationDirectory,
+  moduleDirectory,
+  timestampForFilename,
+  toCamelCase,
+  toKebabCase,
+  toPascalCase,
+  webViewsDirectory,
+} from "./utils.ts";
+
+const scaffoldCommands: StrataCommandMap = {
+  "make:module": async () => makeModuleCommand,
+  "make:policy": async () => makePolicyCommand,
+  "make:job": async () => makeJobCommand,
+  "make:listener": async () => makeListenerCommand,
+  "make:request": async () => makeRequestCommand,
+  "make:factory": async () => makeFactoryCommand,
+  "make:migration": async () => makeMigrationCommand,
+};
+
+export {
+  ensureDirectory,
+  makeFactoryCommand,
+  makeJobCommand,
+  makeListenerCommand,
+  makeMigrationCommand,
+  makeModuleCommand,
+  makePolicyCommand,
+  makeRequestCommand,
+  migrationDirectory,
+  moduleDirectory,
+  scaffoldCommands,
+  timestampForFilename,
+  toCamelCase,
+  toKebabCase,
+  toPascalCase,
+  webViewsDirectory,
+};

package/src/scaffold/makeFactory.ts

@@ -0,0 +1,48 @@
+import { join } from "node:path";
+import { ensureDirectory, moduleDirectory, toCamelCase, toKebabCase, toPascalCase } from "./utils";
+
+async function makeFactoryCommand(name?: string): Promise<void> {
+  if (!name) {
+    throw new Error("make:factory requires a model name.");
+  }
+
+  const moduleSlug = toKebabCase(name);
+  const modelName = toPascalCase(name);
+  const moduleIdentifier = toCamelCase(name);
+  const directory = moduleDirectory(moduleSlug);
+  const filePath = join(directory, "factory.ts");
+
+  await ensureDirectory(directory);
+
+  const exists = await Bun.file(filePath).exists();
+  if (exists) {
+    throw new Error(`Factory already exists: ${filePath}`);
+  }
+
+  const content = `import { Factory } from "@getstrata/core/database/factory";
+import type { ${modelName}Record } from "./types";
+
+class ${modelName}Factory extends Factory<${modelName}Record> {
+  protected definition(): ${modelName}Record {
+    const now = new Date();
+
+    return {
+      id: 0,
+    } satisfies Partial<${modelName}Record> as ${modelName}Record;
+  }
+
+  protected persist(values: Partial<${modelName}Record>): Promise<${modelName}Record> {
+    throw new Error("${modelName}Factory.persist() is not implemented.");
+  }
+}
+
+const ${moduleIdentifier}Factory = new ${modelName}Factory();
+
+export { ${modelName}Factory, ${moduleIdentifier}Factory };
+`;
+
+  await Bun.write(filePath, content);
+  console.log(`Created factory: ${filePath}`);
+}
+
+export { makeFactoryCommand };

package/src/scaffold/makeJob.ts

@@ -0,0 +1,53 @@
+import { access, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { toKebabCase, toPascalCase } from "./utils";
+
+async function makeJobCommand(name?: string): Promise<void> {
+  if (!name) {
+    throw new Error("make:job requires a job name.");
+  }
+
+  const jobSlug = toKebabCase(name);
+  const jobClass = `${toPascalCase(name)}Job`;
+  const payloadType = `${toPascalCase(name)}Payload`;
+  const directory = join(process.cwd(), "src", "jobs");
+  const jobPath = join(directory, `${jobSlug}Job.ts`);
+
+  await mkdir(directory, { recursive: true });
+
+  try {
+    await access(jobPath);
+    throw new Error(`Job already exists: ${jobPath}`);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Job already exists:")) {
+      throw error;
+    }
+  }
+
+  const content = `import { Job } from "@getstrata/core/queue";
+
+interface ${payloadType} {
+}
+
+class ${jobClass} extends Job<${payloadType}> {
+  static readonly jobName = "${jobSlug}";
+
+  override async handle(payload: ${payloadType}): Promise<void> {
+    void payload;
+  }
+}
+
+export default ${jobClass};
+export type { ${payloadType} };
+`;
+
+  await Bun.write(jobPath, content);
+
+  console.log(`Created job in: ${jobPath}`);
+  console.log(
+    `Dispatch it via queue.dispatch(new ${jobClass}(), payload) from your controller or listener.`,
+  );
+  console.log(`Workers discover it from src/jobs/ as "${jobSlug}".`);
+}
+
+export { makeJobCommand };

package/src/scaffold/makeListener.ts

@@ -0,0 +1,45 @@
+import { access, mkdir } from "node:fs/promises";
+import { join } from "node:path";
+import { toCamelCase, toKebabCase, toPascalCase } from "./utils";
+
+async function makeListenerCommand(name?: string, eventName?: string): Promise<void> {
+  if (!name) {
+    throw new Error("make:listener requires a listener name.");
+  }
+
+  const listenerSlug = toKebabCase(name);
+  const registerFunction = `register${toPascalCase(name)}Listener`;
+  const directory = join(process.cwd(), "src", "listeners");
+  const listenerPath = join(directory, `${listenerSlug}.ts`);
+  const resolvedEventName = eventName ?? `${toCamelCase(name)}.created`;
+
+  await mkdir(directory, { recursive: true });
+
+  try {
+    await access(listenerPath);
+    throw new Error(`Listener already exists: ${listenerPath}`);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Listener already exists:")) {
+      throw error;
+    }
+  }
+
+  const content = `import { eventBus } from "@getstrata/core/events";
+
+function ${registerFunction}(): void {
+  eventBus.listen("${resolvedEventName}", async (payload) => {
+    void payload;
+  });
+}
+
+export default ${registerFunction};
+`;
+
+  await Bun.write(listenerPath, content);
+
+  console.log(`Created listener in: ${listenerPath}`);
+  console.log(`Listening for event: ${resolvedEventName}`);
+  console.log("It will be auto-discovered from src/listeners/ on the next app boot.");
+}
+
+export { makeListenerCommand };

package/src/scaffold/makeMigration.ts

@@ -0,0 +1,58 @@
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { ensureDirectory, migrationDirectory, timestampForFilename, toKebabCase } from "./utils";
+
+async function makeMigrationCommand(name?: string): Promise<void> {
+  if (!name) {
+    throw new Error("make:migration requires a name.");
+  }
+
+  const normalizedName = toKebabCase(name).replace(/-/g, "_");
+  if (!normalizedName) {
+    throw new Error("make:migration requires a valid migration name.");
+  }
+
+  const fileBaseName = `${timestampForFilename()}_${normalizedName}`;
+  const directory = migrationDirectory();
+  const filePath = join(directory, `${fileBaseName}.ts`);
+
+  await ensureDirectory(directory);
+
+  try {
+    await access(filePath);
+    throw new Error(`Migration already exists: ${filePath}`);
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      if (error instanceof Error && error.message.startsWith("Migration already exists:")) {
+        throw error;
+      }
+      throw error;
+    }
+  }
+
+  const content = `import type { Migration } from "@getstrata/core/database/migrations/types";
+
+const migration: Migration = {
+  name: "${fileBaseName}",
+  async up(db) {
+    await db.unsafe(\`
+      -- Write SQL for ${fileBaseName}
+      SELECT 1
+    \`);
+  },
+  async down(db) {
+    await db.unsafe(\`
+      -- Roll back ${fileBaseName}
+      SELECT 1
+    \`);
+  },
+};
+
+export default migration;
+`;
+
+  await Bun.write(filePath, content);
+  console.log(`Created migration: ${filePath}`);
+}
+
+export { makeMigrationCommand };

package/src/scaffold/makeModule.ts

@@ -0,0 +1,592 @@
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import {
+  ensureDirectory,
+  moduleDirectory,
+  toCamelCase,
+  toKebabCase,
+  toPascalCase,
+  webViewsDirectory,
+} from "./utils";
+
+async function makeModuleCommand(...args: string[]): Promise<void> {
+  const withWeb = args.includes("--with-web");
+  const name = args.find((arg) => !arg.startsWith("--"));
+
+  if (!name) {
+    throw new Error("make:module requires a name.");
+  }
+
+  const moduleSlug = toKebabCase(name);
+  const moduleName = toPascalCase(name);
+  const moduleIdentifier = toCamelCase(name);
+  const moduleVariable = `${moduleIdentifier}Module`;
+
+  if (!moduleName || !moduleIdentifier || !moduleSlug) {
+    throw new Error("make:module requires a valid module name.");
+  }
+
+  const directory = moduleDirectory(moduleSlug);
+
+  try {
+    await access(directory);
+    throw new Error(`Module already exists: ${directory}`);
+  } catch (error) {
+    if (!(error instanceof Error) || !("code" in error) || error.code !== "ENOENT") {
+      if (error instanceof Error && error.message.startsWith("Module already exists:")) {
+        throw error;
+      }
+      throw error;
+    }
+  }
+
+  await ensureDirectory(directory);
+
+  const pluralSlug = `${moduleSlug}s`;
+
+  const files = new Map<string, string>([
+    [
+      "types.ts",
+      `interface ${moduleName}Record {
+  id: number;
+  name: string;
+}
+
+export type { ${moduleName}Record };
+`,
+    ],
+    [
+      "table.ts",
+      `import { defineTable } from "@getstrata/core/database/table";
+import type { ${moduleName}Record } from "./types";
+
+const ${moduleIdentifier}Table = defineTable<${moduleName}Record, "id">({
+  name: "${moduleSlug}",
+  primaryKey: "id",
+  columns: ["id", "name"],
+  defaultOrderBy: { column: "id", direction: "ASC" },
+});
+
+export { ${moduleIdentifier}Table };
+`,
+    ],
+    [
+      "repository.ts",
+      `import { BaseRepository } from "@getstrata/core/database/baseRepository";
+import { ${moduleIdentifier}Table } from "./table";
+import type { ${moduleName}Record } from "./types";
+
+class ${moduleName}Repository extends BaseRepository<${moduleName}Record, "id"> {
+  constructor() {
+    super(${moduleIdentifier}Table);
+  }
+}
+
+export default ${moduleName}Repository;
+`,
+    ],
+    [
+      "service.ts",
+      `import ${moduleName}Repository from "./repository";
+import type { ${moduleName}Record } from "./types";
+import type { PaginatedResult } from "@getstrata/core/pagination";
+
+class ${moduleName}Service {
+  constructor(private readonly repository: ${moduleName}Repository) {}
+
+  paginate(options: {
+    page: number;
+    perPage: number;
+  }): Promise<PaginatedResult<${moduleName}Record>> {
+    return this.repository.paginate(options);
+  }
+
+  findByIdOrThrow(id: number): Promise<${moduleName}Record> {
+    return this.repository.findByIdOrThrow(id);
+  }
+
+  create(input: { name: string }): Promise<${moduleName}Record> {
+    return this.repository.create(input);
+  }
+
+  update(id: number, input: { name?: string }): Promise<${moduleName}Record> {
+    return this.repository.update(id, input);
+  }
+
+  delete(id: number): Promise<void> {
+    return this.repository.delete(id);
+  }
+}
+
+export default ${moduleName}Service;
+`,
+    ],
+    [
+      "policy.ts",
+      `import type { AuthUser } from "@getstrata/core/auth/authContext";
+import { Policy } from "@getstrata/core/auth/policy";
+import type { ${moduleName}Record } from "./types";
+
+class ${moduleName}Policy extends Policy {
+  override create(_user: AuthUser | null): boolean {
+    return true;
+  }
+
+  override update(_user: AuthUser | null, _resource: ${moduleName}Record): boolean {
+    return true;
+  }
+
+  override delete(user: AuthUser | null, _resource: ${moduleName}Record): boolean {
+    return user?.role === "admin" || user?.role === "member";
+  }
+}
+
+export default ${moduleName}Policy;
+`,
+    ],
+    [
+      "provider.ts",
+      `import type { ServiceProvider } from "@getstrata/core/contracts/di";
+import { CORE_POLICY_GATE_TOKEN } from "@getstrata/bootstrap/config";
+import ${moduleName}Repository from "./repository";
+import ${moduleName}Service from "./service";
+import ${moduleName}Policy from "./policy";
+
+const ${moduleIdentifier}RepositoryToken = "${moduleSlug}.repository";
+const ${moduleIdentifier}ServiceToken = "${moduleSlug}.service";
+const ${moduleIdentifier}PolicyToken = "${moduleSlug}.policy";
+
+const ${moduleIdentifier}Provider: ServiceProvider = {
+  name: "${moduleSlug}.provider",
+  register({ container }) {
+    container.singleton(${moduleIdentifier}RepositoryToken, () => new ${moduleName}Repository());
+    container.singleton(${moduleIdentifier}PolicyToken, () => new ${moduleName}Policy());
+  },
+  boot({ container }) {
+    container.singleton(${moduleIdentifier}ServiceToken, () => {
+      const repository = container.resolve<${moduleName}Repository>(${moduleIdentifier}RepositoryToken);
+      return new ${moduleName}Service(repository);
+    });
+
+    const gate = container.resolve<{ register: (resource: string, policy: unknown) => void }>(
+      CORE_POLICY_GATE_TOKEN,
+    );
+    gate.register("${moduleSlug}", container.resolve(${moduleIdentifier}PolicyToken));
+  },
+};
+
+export default ${moduleIdentifier}Provider;
+export {
+  ${moduleIdentifier}PolicyToken,
+  ${moduleIdentifier}RepositoryToken,
+  ${moduleIdentifier}ServiceToken,
+};
+`,
+    ],
+    [
+      "requests.ts",
+      `import { parseJsonBody, parsePositiveIntParam } from "@getstrata/core/http/validation";
+import { parsePaginationQuery } from "@getstrata/core/http/pagination";
+import {
+  maxLength,
+  minLength,
+  required,
+  stringRule,
+  validateObject,
+} from "@getstrata/core/validation/rules";
+
+type ${moduleName}IdParams = { id: string };
+
+interface ${moduleName}ListQueryDto {
+  page: number;
+  perPage: number;
+}
+
+interface Create${moduleName}BodyDto {
+  name: string;
+}
+
+interface Update${moduleName}BodyDto {
+  name?: string;
+}
+
+function parse${moduleName}IdParams(params: ${moduleName}IdParams): { id: number } {
+  return {
+    id: parsePositiveIntParam(params.id, "${moduleSlug} id"),
+  };
+}
+
+function parse${moduleName}ListQuery(request?: Request): ${moduleName}ListQueryDto {
+  return parsePaginationQuery(request);
+}
+
+async function parseCreate${moduleName}Body(
+  request: Request,
+): Promise<Create${moduleName}BodyDto> {
+  return await parseJsonBody(request, (payload) => {
+    const body = validateObject(payload, {
+      name: [required(), stringRule(), minLength(1), maxLength(120)],
+    });
+
+    return {
+      name: body.name as string,
+    };
+  });
+}
+
+async function parseUpdate${moduleName}Body(
+  request: Request,
+): Promise<Update${moduleName}BodyDto> {
+  return await parseJsonBody(request, (payload) => {
+    const body = validateObject(payload, {
+      name: [stringRule(), minLength(1), maxLength(120)],
+    });
+
+    return {
+      ...(body.name === undefined ? {} : { name: body.name as string }),
+    };
+  });
+}
+
+export {
+  parseCreate${moduleName}Body,
+  parse${moduleName}IdParams,
+  parse${moduleName}ListQuery,
+  parseUpdate${moduleName}Body,
+};
+export type {
+  Create${moduleName}BodyDto,
+  ${moduleName}IdParams,
+  ${moduleName}ListQueryDto,
+  Update${moduleName}BodyDto,
+};
+`,
+    ],
+    [
+      "resources.ts",
+      `import { toPaginatedResourceCollection, toResourceCollection } from "@getstrata/core/http/resources";
+import type { PaginationMeta } from "@getstrata/core/pagination";
+import type { ${moduleName}Record } from "./types";
+
+interface ${moduleName}Resource {
+  id: number;
+  name: string;
+}
+
+function to${moduleName}Resource(record: ${moduleName}Record): ${moduleName}Resource {
+  return {
+    id: record.id,
+    name: record.name,
+  };
+}
+
+function to${moduleName}ResourceCollection(
+  records: readonly ${moduleName}Record[],
+): ${moduleName}Resource[] {
+  return toResourceCollection(records, to${moduleName}Resource);
+}
+
+function to${moduleName}PaginatedResourceCollection(
+  records: readonly ${moduleName}Record[],
+  meta: PaginationMeta,
+) {
+  return toPaginatedResourceCollection(records, meta, to${moduleName}Resource);
+}
+
+export {
+  to${moduleName}PaginatedResourceCollection,
+  to${moduleName}Resource,
+  to${moduleName}ResourceCollection,
+};
+export type { ${moduleName}Resource };
+`,
+    ],
+    [
+      "controller.ts",
+      `import type { AppDependencies, CachedJson } from "@getstrata/core/contracts/di";
+import { resolveService } from "@getstrata/core/contracts/di";
+import { bindRouteModel } from "@getstrata/core/http/routeModelBinding";
+import { buildRequestCacheKey } from "@getstrata/core/http/validation";
+import { securedBindRouteModel } from "@getstrata/core/http/securedRouteModelBinding";
+import type { RouteRequest } from "@getstrata/core/http/route";
+import { createdResponse, jsonResponse, noContentResponse, withErrorHandling } from "@getstrata/core/http/response";
+import ${moduleName}Service from "./service";
+import { ${moduleIdentifier}ServiceToken } from "./provider";
+import {
+  parseCreate${moduleName}Body,
+  parse${moduleName}ListQuery,
+  parseUpdate${moduleName}Body,
+  type ${moduleName}IdParams,
+} from "./requests";
+import {
+  to${moduleName}PaginatedResourceCollection,
+  to${moduleName}Resource,
+} from "./resources";
+
+const ${moduleIdentifier.toUpperCase()}_CACHE_TAG = "${pluralSlug}";
+
+class ${moduleName}Controller {
+  constructor(
+    private readonly dependencies: AppDependencies,
+    private readonly cachedJson: CachedJson,
+  ) {}
+
+  private get service(): ${moduleName}Service {
+    return resolveService(this.dependencies, ${moduleIdentifier}ServiceToken);
+  }
+
+  readonly index = withErrorHandling(async (request?: Request) => {
+    const query = parse${moduleName}ListQuery(request);
+    const cacheKey = buildRequestCacheKey("/${pluralSlug}", request);
+
+    return await this.cachedJson(
+      cacheKey,
+      async () => {
+        const result = await this.service.paginate(query);
+        return to${moduleName}PaginatedResourceCollection(result.data, result.meta);
+      },
+      [${moduleIdentifier.toUpperCase()}_CACHE_TAG],
+      request,
+    );
+  });
+
+  readonly show = withErrorHandling(
+    bindRouteModel(
+      "id",
+      (id) => this.service.findByIdOrThrow(id),
+      async (_request, record) => {
+        return jsonResponse(to${moduleName}Resource(record));
+      },
+    ),
+  );
+
+  readonly store = withErrorHandling(async (request: Request) => {
+    const body = await parseCreate${moduleName}Body(request);
+    const record = await this.service.create(body);
+    return createdResponse(to${moduleName}Resource(record));
+  });
+
+  readonly update = withErrorHandling(
+    securedBindRouteModel(
+      "id",
+      (id) => this.service.findByIdOrThrow(id),
+      { resource: "${moduleSlug}", action: "update" },
+      async (req: RouteRequest<${moduleName}IdParams>, record) => {
+        const body = await parseUpdate${moduleName}Body(req);
+        const updated = await this.service.update(record.id, body);
+        return jsonResponse(to${moduleName}Resource(updated));
+      },
+    ),
+  );
+
+  readonly destroy = withErrorHandling(
+    securedBindRouteModel(
+      "id",
+      (id) => this.service.findByIdOrThrow(id),
+      { resource: "${moduleSlug}", action: "delete" },
+      async (_request, record) => {
+        await this.service.delete(record.id);
+        return noContentResponse();
+      },
+    ),
+  );
+}
+
+export default ${moduleName}Controller;
+`,
+    ],
+    [
+      "routes.ts",
+      `import type { HttpKernel } from "@getstrata/bootstrap/httpKernel";
+import type { AppDependencies, CachedJson } from "@getstrata/core/contracts/di";
+import type { RouteHandler } from "@getstrata/core/http/middleware";
+import ${moduleName}Controller from "./controller";
+
+function create${moduleName}Routes(
+  dependencies: AppDependencies,
+  cachedJson: CachedJson,
+  kernel: HttpKernel,
+) {
+  const controller = new ${moduleName}Controller(dependencies, cachedJson);
+
+  return {
+    "/${pluralSlug}": {
+      GET: controller.index,
+      POST: kernel.wrapAbility(
+        "${pluralSlug}:create",
+        controller.store as unknown as RouteHandler,
+      ),
+    },
+    "/${pluralSlug}/:id": {
+      GET: controller.show,
+      PATCH: kernel.wrapAbility(
+        "${pluralSlug}:update",
+        controller.update as unknown as RouteHandler,
+      ),
+      DELETE: kernel.wrapAbility(
+        "${pluralSlug}:delete",
+        controller.destroy as unknown as RouteHandler,
+      ),
+    },
+  };
+}
+
+export { create${moduleName}Routes };
+`,
+    ],
+    [
+      "index.ts",
+      `import { type AppModule } from "@getstrata/bootstrap/contracts";
+import ${moduleName}Controller from "./controller";
+import ${moduleIdentifier}Provider, {
+  ${moduleIdentifier}RepositoryToken,
+  ${moduleIdentifier}ServiceToken,
+} from "./provider";
+import { create${moduleName}Routes } from "./routes";${
+        withWeb
+          ? `
+import { create${moduleName}WebRoutes } from "./webRoutes";`
+          : ""
+      }
+import { ${moduleIdentifier}Table } from "./table";
+
+const ${moduleVariable}: AppModule = {
+  name: "${moduleSlug}",
+  order: 100,
+  tableName: ${moduleIdentifier}Table.name,
+  cacheTags: ["${pluralSlug}"],
+  providers: [${moduleIdentifier}Provider],
+  routes({ dependencies, cachedJson, kernel }) {
+    return create${moduleName}Routes(dependencies, cachedJson, kernel);
+  },${
+    withWeb
+      ? `
+  webRoutes({ dependencies, kernel }) {
+    return create${moduleName}WebRoutes(dependencies, kernel);
+  },`
+      : ""
+  }
+};
+
+export default ${moduleVariable};
+export {
+  ${moduleIdentifier}Provider,
+  ${moduleIdentifier}RepositoryToken,
+  ${moduleIdentifier}ServiceToken,
+};
+export { ${moduleName}Controller };
+export { parse${moduleName}IdParams, parse${moduleName}ListQuery } from "./requests";
+export {
+  to${moduleName}PaginatedResourceCollection,
+  to${moduleName}Resource,
+  to${moduleName}ResourceCollection,
+} from "./resources";
+export { create${moduleName}Routes } from "./routes";${
+        withWeb
+          ? `
+export { create${moduleName}WebRoutes } from "./webRoutes";`
+          : ""
+      }
+export { default as ${moduleName}Repository } from "./repository";
+export { default as ${moduleName}Service } from "./service";
+export { ${moduleIdentifier}Table } from "./table";
+export type { ${moduleName}Record } from "./types";
+`,
+    ],
+  ]);
+
+  for (const [fileName, content] of files) {
+    await Bun.write(join(directory, fileName), content);
+  }
+
+  let createdViewsDirectory: string | undefined;
+
+  if (withWeb) {
+    const viewsDirectory = webViewsDirectory(pluralSlug);
+    createdViewsDirectory = viewsDirectory;
+    await ensureDirectory(viewsDirectory);
+    await Bun.write(
+      join(viewsDirectory, "index.eta"),
+      `<section class="page-header">
+  <h1>${moduleName}s</h1>
+</section>
+
+<p class="hint">Generated web view for ${pluralSlug}. Wire up ${moduleName}WebController next.</p>
+`,
+    );
+
+    await Bun.write(
+      join(directory, "webController.ts"),
+      `import type { AppDependencies } from "@getstrata/core/contracts/di";
+import { resolveService } from "@getstrata/core/contracts/di";
+import { CORE_VIEW_TOKEN } from "@getstrata/bootstrap/providers/view";
+import { withErrorHandling } from "@getstrata/core/http/response";
+import type { ViewEngine } from "@getstrata/core/view";
+import { htmlResponse } from "@getstrata/core/view";
+import { ${moduleIdentifier}ServiceToken } from "./provider";
+import { parse${moduleName}ListQuery } from "./requests";
+import type ${moduleName}Service from "./service";
+
+class ${moduleName}WebController {
+  constructor(private readonly dependencies: AppDependencies) {}
+
+  private get service(): ${moduleName}Service {
+    return resolveService(this.dependencies, ${moduleIdentifier}ServiceToken);
+  }
+
+  private get view(): ViewEngine {
+    return resolveService(this.dependencies, CORE_VIEW_TOKEN);
+  }
+
+  readonly index = withErrorHandling(async (request?: Request) => {
+    const query = parse${moduleName}ListQuery(request);
+    const result = await this.service.paginate(query);
+
+    return htmlResponse(
+      await this.view.render("${pluralSlug}/index", {
+        title: "${moduleName}s",
+        records: result.data,
+        meta: result.meta,
+      }),
+    );
+  });
+}
+
+export default ${moduleName}WebController;
+`,
+    );
+
+    await Bun.write(
+      join(directory, "webRoutes.ts"),
+      `import type { AppDependencies } from "@getstrata/core/contracts/di";
+import type { HttpKernel } from "@getstrata/bootstrap/httpKernel";
+import type { RouteHandler } from "@getstrata/core/http/middleware";
+import ${moduleName}WebController from "./webController";
+
+function create${moduleName}WebRoutes(dependencies: AppDependencies, kernel: HttpKernel) {
+  const controller = new ${moduleName}WebController(dependencies);
+
+  return {
+    "/${pluralSlug}": {
+      GET: kernel.wrapWebPublicRead(controller.index as unknown as RouteHandler),
+    },
+  };
+}
+
+export { create${moduleName}WebRoutes };
+`,
+    );
+  }
+
+  console.log(`Created module scaffold in: ${directory}`);
+  if (createdViewsDirectory) {
+    const relativeViews = createdViewsDirectory.startsWith(process.cwd())
+      ? createdViewsDirectory.slice(process.cwd().length + 1)
+      : createdViewsDirectory;
+    console.log(`Created web view scaffold in: ${relativeViews}/`);
+  }
+  console.log(`Module will be auto-discovered from the app modules directory (${moduleSlug}/)`);
+  console.log(`Next: strata make:migration create_${moduleSlug} && strata migrate`);
+}
+
+export { makeModuleCommand };

package/src/scaffold/makePolicy.ts

@@ -0,0 +1,66 @@
+import { access } from "node:fs/promises";
+import { join } from "node:path";
+import { moduleDirectory, toCamelCase, toKebabCase, toPascalCase } from "./utils";
+
+async function makePolicyCommand(moduleName?: string): Promise<void> {
+  if (!moduleName) {
+    throw new Error("make:policy requires a module name.");
+  }
+
+  const moduleSlug = toKebabCase(moduleName);
+  const resourceName = toPascalCase(moduleName);
+  const directory = moduleDirectory(moduleSlug);
+  const policyPath = join(directory, "policy.ts");
+
+  try {
+    await access(directory);
+  } catch {
+    throw new Error(`Module not found: ${directory}`);
+  }
+
+  try {
+    await access(policyPath);
+    throw new Error(`Policy already exists: ${policyPath}`);
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("Policy already exists:")) {
+      throw error;
+    }
+  }
+
+  const recordType = `${resourceName}Record`;
+  const policyClass = `${resourceName}Policy`;
+  const policyVariable = `${toCamelCase(moduleName)}Policy`;
+
+  const content = `import { Policy } from "@getstrata/core/auth/policy";
+import type { ${recordType} } from "./types";
+
+class ${policyClass} extends Policy {
+  override view(_user: unknown, _resource: ${recordType}): boolean {
+    return true;
+  }
+
+  override create(_user: unknown): boolean {
+    return true;
+  }
+
+  override update(_user: unknown, _resource: ${recordType}): boolean {
+    return true;
+  }
+
+  override delete(_user: unknown, _resource: ${recordType}): boolean {
+    return true;
+  }
+}
+
+export default ${policyClass};
+`;
+
+  await Bun.write(policyPath, content);
+
+  console.log(`Created policy in: ${policyPath}`);
+  console.log(
+    `Register it in src/modules/${moduleSlug}/provider.ts boot() via gate.register("${moduleSlug}", container.resolve(${policyVariable})).`,
+  );
+}
+
+export { makePolicyCommand };

package/src/scaffold/makeRequest.ts

@@ -0,0 +1,70 @@
+import { join } from "node:path";
+import { ensureDirectory, moduleDirectory, toKebabCase, toPascalCase } from "./utils";
+
+async function makeRequestCommand(moduleName?: string): Promise<void> {
+  if (!moduleName) {
+    throw new Error("make:request requires a module name.");
+  }
+
+  const moduleSlug = toKebabCase(moduleName);
+  const moduleNamePascal = toPascalCase(moduleName);
+  const filePath = join(moduleDirectory(moduleSlug), "requests.ts");
+
+  await ensureDirectory(moduleDirectory(moduleSlug));
+
+  const exists = await Bun.file(filePath).exists();
+  if (exists) {
+    throw new Error(`Request file already exists: ${filePath}`);
+  }
+
+  const content = `import { FormRequest } from "@getstrata/core/http";
+import { parsePositiveIntParam } from "@getstrata/core/http/validation";
+import {
+  maxLength,
+  minLength,
+  required,
+  stringRule,
+  validateObject,
+} from "@getstrata/core/validation/rules";
+
+type ${moduleNamePascal}IdParams = { id: string };
+
+interface Create${moduleNamePascal}BodyDto {
+  name: string;
+}
+
+class Create${moduleNamePascal}Request extends FormRequest<Create${moduleNamePascal}BodyDto> {
+  protected parse(payload: unknown): Create${moduleNamePascal}BodyDto {
+    const validated = validateObject(payload, {
+      name: [required(), stringRule(), minLength(1), maxLength(120)],
+    });
+
+    return {
+      name: validated.name as string,
+    };
+  }
+}
+
+const create${moduleNamePascal}Request = new Create${moduleNamePascal}Request();
+
+function parse${moduleNamePascal}IdParams(params: ${moduleNamePascal}IdParams): { id: number } {
+  return {
+    id: parsePositiveIntParam(params.id, "${moduleSlug} id"),
+  };
+}
+
+async function parseCreate${moduleNamePascal}Body(
+  request: Request,
+): Promise<Create${moduleNamePascal}BodyDto> {
+  return await create${moduleNamePascal}Request.validate(request);
+}
+
+export { parseCreate${moduleNamePascal}Body, parse${moduleNamePascal}IdParams };
+export type { Create${moduleNamePascal}BodyDto, ${moduleNamePascal}IdParams };
+`;
+
+  await Bun.write(filePath, content);
+  console.log(`Created request helpers: ${filePath}`);
+}
+
+export { makeRequestCommand };

package/src/scaffold/utils.ts

@@ -0,0 +1,71 @@
+import { existsSync } from "node:fs";
+import { mkdir } from "node:fs/promises";
+import { join } from "node:path";
+
+function toKebabCase(value: string): string {
+  return value
+    .trim()
+    .replace(/([a-z0-9])([A-Z])/g, "$1-$2")
+    .replace(/[\s_]+/g, "-")
+    .replace(/[^a-zA-Z0-9-]/g, "-")
+    .replace(/-+/g, "-")
+    .replace(/^-|-$/g, "")
+    .toLowerCase();
+}
+
+function toPascalCase(value: string): string {
+  return toKebabCase(value)
+    .split("-")
+    .filter(Boolean)
+    .map((part) => part[0]?.toUpperCase() + part.slice(1))
+    .join("");
+}
+
+function toCamelCase(value: string): string {
+  const pascalCase = toPascalCase(value);
+  return pascalCase[0]?.toLowerCase() + pascalCase.slice(1);
+}
+
+function timestampForFilename(date: Date = new Date()): string {
+  const parts = [
+    date.getUTCFullYear(),
+    String(date.getUTCMonth() + 1).padStart(2, "0"),
+    String(date.getUTCDate()).padStart(2, "0"),
+    String(date.getUTCHours()).padStart(2, "0"),
+    String(date.getUTCMinutes()).padStart(2, "0"),
+    String(date.getUTCSeconds()).padStart(2, "0"),
+  ];
+
+  return parts.join("");
+}
+
+async function ensureDirectory(path: string): Promise<void> {
+  await mkdir(path, { recursive: true });
+}
+
+function moduleDirectory(name: string): string {
+  return join(process.cwd(), "src", "modules", toKebabCase(name));
+}
+
+function migrationDirectory(): string {
+  return join(process.cwd(), "src", "db", "migrations");
+}
+
+function webViewsDirectory(pluralSlug: string): string {
+  const productViews = join(process.cwd(), "views");
+  if (existsSync(productViews)) {
+    return join(productViews, pluralSlug);
+  }
+  return join(process.cwd(), "resources", "views", pluralSlug);
+}
+
+export {
+  ensureDirectory,
+  migrationDirectory,
+  moduleDirectory,
+  timestampForFilename,
+  toCamelCase,
+  toKebabCase,
+  toPascalCase,
+  webViewsDirectory,
+};

package/src/schedule.ts

@@ -0,0 +1,25 @@
+import { appSchedule, runDueScheduledTasks } from "@getstrata/core/scheduler/schedule";
+
+type LoadAppSchedule = () => void | Promise<void>;
+
+function createScheduleRunCommand(loadSchedule: LoadAppSchedule) {
+  return async function scheduleRunCommand(): Promise<void> {
+    await loadSchedule();
+
+    const due = appSchedule.dueTasks();
+
+    if (due.length === 0) {
+      console.log("No scheduled tasks due.");
+      return;
+    }
+
+    for (const task of due) {
+      console.log(`Running scheduled task: ${task.name}`);
+    }
+
+    await runDueScheduledTasks(appSchedule);
+  };
+}
+
+export type { LoadAppSchedule };
+export { createScheduleRunCommand };