@stratum-hq/create 0.2.3 → 0.3.0

package/dist/index.js

@@ -1,16 +1,1183 @@
 #!/usr/bin/env node
 
 // src/index.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+import crypto2 from "node:crypto";
+import { execSync as execSync2 } from "child_process";
+import { fileURLToPath } from "url";
+
+// src/matrix.ts
+var POSTGRES_STRATEGIES = ["rls", "schema", "database"];
+var POSTGRES_ORMS = ["prisma", "drizzle", "sequelize", "knex", "pg"];
+var MONGODB_STRATEGIES = ["database", "collection"];
+var MONGODB_ORMS = ["mongoose"];
+var MYSQL_STRATEGIES = ["database", "table-prefix"];
+var MYSQL_ORMS = ["sequelize", "knex", "pg"];
+var ALL_FRAMEWORKS = ["express", "fastify", "nextjs", "hono", "nestjs", "none"];
+var VALID_COMBINATIONS = {
+  postgres: {
+    strategies: POSTGRES_STRATEGIES,
+    orms: POSTGRES_ORMS,
+    frameworks: ALL_FRAMEWORKS
+  },
+  mongodb: {
+    strategies: MONGODB_STRATEGIES,
+    orms: MONGODB_ORMS,
+    frameworks: ALL_FRAMEWORKS
+  },
+  mysql: {
+    strategies: MYSQL_STRATEGIES,
+    orms: MYSQL_ORMS,
+    frameworks: ALL_FRAMEWORKS
+  }
+};
+var ALL_DATABASES = ["postgres", "mongodb", "mysql"];
+var ALL_STRATEGIES = ["rls", "schema", "database", "collection", "table-prefix"];
+var ALL_ORMS = ["prisma", "drizzle", "sequelize", "knex", "mongoose", "pg"];
+function isValidPreset(preset) {
+  const config = VALID_COMBINATIONS[preset.database];
+  if (!config)
+    return false;
+  if (!config.strategies.includes(preset.strategy))
+    return false;
+  if (!config.orms.includes(preset.orm))
+    return false;
+  if (!config.frameworks.includes(preset.framework))
+    return false;
+  return true;
+}
+function parsePresetString(s) {
+  if (!s || typeof s !== "string")
+    return null;
+  const parts = s.toLowerCase().split("-");
+  let database;
+  let strategy;
+  let orm;
+  let framework;
+  if (parts.length === 4) {
+    [database, strategy, orm, framework] = parts;
+  } else if (parts.length === 5) {
+    database = parts[0];
+    strategy = `${parts[1]}-${parts[2]}`;
+    orm = parts[3];
+    framework = parts[4];
+  } else {
+    return null;
+  }
+  if (!ALL_DATABASES.includes(database))
+    return null;
+  if (!ALL_STRATEGIES.includes(strategy))
+    return null;
+  if (!ALL_ORMS.includes(orm))
+    return null;
+  if (!ALL_FRAMEWORKS.includes(framework))
+    return null;
+  return {
+    database,
+    strategy,
+    orm,
+    framework
+  };
+}
+
+// src/preset-project.ts
 import * as fs from "fs";
 import * as path from "path";
+import crypto from "node:crypto";
 import { execSync } from "child_process";
-import { fileURLToPath } from "url";
+
+// src/generators/docker-compose.ts
+function generatePresetDockerCompose(projectName, preset) {
+  const dbName = projectName.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+  switch (preset.database) {
+    case "postgres":
+      return generatePostgresCompose(projectName, dbName);
+    case "mongodb":
+      return generateMongoCompose(projectName, dbName);
+    case "mysql":
+      return generateMysqlCompose(projectName, dbName);
+  }
+}
+function generatePostgresCompose(projectName, dbName) {
+  return `# Docker Compose for ${projectName}
+# Start with: docker compose up -d
+version: "3.8"
+
+services:
+  db:
+    image: postgres:16-alpine
+    environment:
+      POSTGRES_DB: ${dbName}
+      POSTGRES_USER: ${dbName}
+      POSTGRES_PASSWORD: dev_password
+    ports:
+      - "5432:5432"
+    volumes:
+      - db_data:/var/lib/postgresql/data
+      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U ${dbName}"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  db_data:
+`;
+}
+function generateMongoCompose(projectName, dbName) {
+  return `# Docker Compose for ${projectName}
+# Start with: docker compose up -d
+version: "3.8"
+
+services:
+  db:
+    image: mongo:7
+    environment:
+      MONGO_INITDB_ROOT_USERNAME: ${dbName}
+      MONGO_INITDB_ROOT_PASSWORD: dev_password
+      MONGO_INITDB_DATABASE: ${dbName}
+    ports:
+      - "27017:27017"
+    volumes:
+      - db_data:/data/db
+    healthcheck:
+      test: ["CMD", "mongosh", "--eval", "db.adminCommand('ping')"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  db_data:
+`;
+}
+function generateMysqlCompose(projectName, dbName) {
+  return `# Docker Compose for ${projectName}
+# Start with: docker compose up -d
+version: "3.8"
+
+services:
+  db:
+    image: mysql:8
+    environment:
+      MYSQL_DATABASE: ${dbName}
+      MYSQL_USER: ${dbName}
+      MYSQL_PASSWORD: dev_password
+      MYSQL_ROOT_PASSWORD: dev_root_password
+    ports:
+      - "3306:3306"
+    volumes:
+      - db_data:/var/lib/mysql
+      - ./init.sql:/docker-entrypoint-initdb.d/init.sql
+    healthcheck:
+      test: ["CMD", "mysqladmin", "ping", "-h", "localhost"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  db_data:
+`;
+}
+
+// src/generators/init-sql.ts
+function generatePresetInitSql(projectName, preset) {
+  const dbName = projectName.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+  switch (preset.database) {
+    case "postgres":
+      return generatePostgresInit(projectName, dbName, preset.strategy);
+    case "mongodb":
+      return null;
+    case "mysql":
+      return generateMysqlInit(projectName, dbName);
+  }
+}
+function generatePostgresInit(projectName, dbName, strategy) {
+  let rlsBlock = "";
+  if (strategy === "rls") {
+    rlsBlock = `
+-- Enable Row-Level Security for tenant isolation
+-- Add RLS policies to each tenant-scoped table:
+--
+--   ALTER TABLE your_table ENABLE ROW LEVEL SECURITY;
+--   CREATE POLICY tenant_isolation ON your_table
+--     USING (tenant_id = current_setting('app.current_tenant')::uuid);
+--
+-- The Stratum db-adapters package sets app.current_tenant automatically.
+`;
+  }
+  return `-- Initialize ${projectName} database
+-- Enable required extensions for Stratum multi-tenancy
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
+CREATE EXTENSION IF NOT EXISTS "ltree";
+
+-- The ltree extension enables hierarchical tenant trees
+-- uuid-ossp provides uuid_generate_v4() for tenant IDs
+COMMENT ON DATABASE ${dbName} IS 'Multi-tenant database for ${projectName}';
+${rlsBlock}`;
+}
+function generateMysqlInit(projectName, dbName) {
+  return `-- Initialize ${projectName} database
+-- MySQL setup for Stratum multi-tenancy
+
+-- Ensure utf8mb4 for the database
+ALTER DATABASE ${dbName} CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci;
+
+-- Tenant metadata table
+CREATE TABLE IF NOT EXISTS _stratum_tenants (
+  id VARCHAR(36) PRIMARY KEY,
+  name VARCHAR(255) NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+`;
+}
+
+// src/generators/db-setup.ts
+function generateDbSetup(preset) {
+  switch (preset.orm) {
+    case "prisma":
+      return generatePrismaSetup(preset);
+    case "drizzle":
+      return generateDrizzleSetup(preset);
+    case "sequelize":
+      return generateSequelizeSetup(preset);
+    case "knex":
+      return generateKnexSetup(preset);
+    case "mongoose":
+      return generateMongooseSetup(preset);
+    case "pg":
+      return generatePgSetup(preset);
+  }
+}
+function generatePrismaSetup(preset) {
+  const provider = preset.database === "mysql" ? "mysql" : "postgresql";
+  const envUrl = preset.database === "mysql" ? "mysql://user:password@localhost:3306/dbname" : "postgres://user:password@localhost:5432/dbname";
+  return [
+    {
+      filename: "prisma/schema.prisma",
+      content: `// Prisma schema for Stratum multi-tenancy
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${provider}"
+  url      = env("DATABASE_URL")
+}
+
+model Tenant {
+  id        String   @id @default(uuid())
+  name      String
+  createdAt DateTime @default(now()) @map("created_at")
+
+  @@map("tenants")
+}
+
+// Add your tenant-scoped models here.
+// Each model that needs tenant isolation should have a tenantId field.
+`
+    },
+    {
+      filename: "src/stratum-prisma.ts",
+      content: `// Prisma client with Stratum tenant-scoped queries
+import { PrismaClient } from "@prisma/client";
+import { Pool } from "pg";
+import { withTenant } from "@stratum-hq/db-adapters";
+
+const prisma = new PrismaClient();
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+// Create a tenant-scoped Prisma client.
+// All queries through this client are automatically filtered by RLS.
+export function createTenantPrisma(getTenantId: () => string) {
+  return withTenant(prisma, getTenantId, pool);
+}
+
+// Usage:
+// const tenantPrisma = createTenantPrisma(() => currentTenantId);
+// const orders = await tenantPrisma.order.findMany();
+
+export { prisma, pool };
+`
+    }
+  ];
+}
+function generateDrizzleSetup(preset) {
+  const files = [];
+  if (preset.database === "mysql") {
+    files.push({
+      filename: "src/stratum-drizzle.ts",
+      content: `// Drizzle ORM with Stratum tenant-scoped queries (MySQL)
+import { drizzle } from "drizzle-orm/mysql2";
+import mysql from "mysql2/promise";
+
+const connection = await mysql.createConnection({
+  uri: process.env.DATABASE_URL,
+});
+
+export const db = drizzle(connection);
+
+// For tenant scoping, prefix table access with the tenant database name
+// or use the @stratum-hq/mysql adapter for automatic routing.
+`
+    });
+  } else {
+    files.push({
+      filename: "src/stratum-drizzle.ts",
+      content: `// Drizzle ORM with Stratum tenant-scoped queries
+import { drizzle } from "drizzle-orm/node-postgres";
+import { Pool } from "pg";
+import { withTenantDrizzle } from "@stratum-hq/db-adapters";
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+export const db = drizzle(pool);
+
+// Create a tenant-scoped Drizzle instance.
+// Queries are automatically filtered by RLS policy.
+export function createTenantDb(getTenantId: () => string) {
+  return withTenantDrizzle(db, getTenantId, pool);
+}
+
+// Usage:
+// const tenantDb = createTenantDb(() => currentTenantId);
+// const rows = await tenantDb.select().from(orders);
+
+export { pool };
+`
+    });
+  }
+  files.push({
+    filename: "drizzle.config.ts",
+    content: `import type { Config } from "drizzle-kit";
+
+export default {
+  schema: "./src/schema.ts",
+  out: "./drizzle",
+  ${preset.database === "mysql" ? 'dialect: "mysql",' : 'dialect: "postgresql",'}
+  dbCredentials: {
+    url: process.env.DATABASE_URL!,
+  },
+} satisfies Config;
+`
+  });
+  return files;
+}
+function generateSequelizeSetup(preset) {
+  const dialect = preset.database === "mysql" ? "mysql" : "postgres";
+  return [
+    {
+      filename: "src/stratum-sequelize.ts",
+      content: `// Sequelize with Stratum tenant-scoped queries
+import { Sequelize, DataTypes, Model } from "sequelize";
+
+const sequelize = new Sequelize(process.env.DATABASE_URL!, {
+  dialect: "${dialect}",
+  logging: false,
+});
+
+// Define a tenant-scoped model example
+class Tenant extends Model {}
+Tenant.init(
+  {
+    id: { type: DataTypes.UUID, primaryKey: true, defaultValue: DataTypes.UUIDV4 },
+    name: { type: DataTypes.STRING, allowNull: false },
+  },
+  { sequelize, tableName: "tenants", underscored: true },
+);
+
+// For tenant isolation, add a tenantId scope to each model:
+//   MyModel.addScope("tenant", (tenantId) => ({ where: { tenant_id: tenantId } }));
+//   const rows = await MyModel.scope({ method: ["tenant", currentTenantId] }).findAll();
+
+export { sequelize, Tenant };
+`
+    }
+  ];
+}
+function generateKnexSetup(preset) {
+  const client = preset.database === "mysql" ? "mysql2" : "pg";
+  return [
+    {
+      filename: "knexfile.ts",
+      content: `// Knex configuration for Stratum
+import type { Knex } from "knex";
+
+const config: Knex.Config = {
+  client: "${client}",
+  connection: process.env.DATABASE_URL,
+  migrations: {
+    directory: "./migrations",
+    extension: "ts",
+  },
+};
+
+export default config;
+`
+    },
+    {
+      filename: "src/stratum-knex.ts",
+      content: `// Knex with Stratum tenant-scoped queries
+import Knex from "knex";
+import config from "../knexfile.js";
+
+const knex = Knex(config);
+
+// Create a tenant-scoped query builder.
+// For RLS strategy, set the session variable before queries.
+export async function withTenantScope(tenantId: string, fn: (db: typeof knex) => Promise<void>) {
+${preset.database === "postgres" ? `  await knex.raw("SET app.current_tenant = ?", [tenantId]);` : `  // For ${preset.database}, scope queries by tenant_id column`}
+  try {
+    await fn(knex);
+  } finally {
+${preset.database === "postgres" ? `    await knex.raw("RESET app.current_tenant");` : `    // Scope cleanup not needed for column-based isolation`}
+  }
+}
+
+export { knex };
+`
+    }
+  ];
+}
+function generateMongooseSetup(_preset) {
+  return [
+    {
+      filename: "src/stratum-mongoose.ts",
+      content: `// Mongoose with Stratum multi-tenant support
+import mongoose from "mongoose";
+import { createTenantConnection } from "@stratum-hq/mongodb";
+
+// Main connection (used for tenant metadata)
+const mainConnection = mongoose.createConnection(
+  process.env.MONGODB_URI || "mongodb://localhost:27017/main",
+);
+
+// Create a tenant-scoped connection.
+// Each tenant gets its own database (database-per-tenant strategy)
+// or collection prefix (collection strategy).
+export function getTenantConnection(tenantId: string) {
+  return createTenantConnection(mainConnection, tenantId);
+}
+
+// Define schemas that work across tenant connections
+export const TenantSchema = new mongoose.Schema({
+  name: { type: String, required: true },
+  createdAt: { type: Date, default: Date.now },
+});
+
+// Usage:
+// const conn = getTenantConnection("tenant-abc");
+// const Order = conn.model("Order", OrderSchema);
+// const orders = await Order.find();
+
+export { mainConnection };
+`
+    }
+  ];
+}
+function generatePgSetup(preset) {
+  if (preset.database === "mysql") {
+    return [
+      {
+        filename: "src/stratum-db.ts",
+        content: `// Raw MySQL client with Stratum tenant-scoped queries
+import mysql from "mysql2/promise";
+
+const pool = mysql.createPool({
+  uri: process.env.DATABASE_URL,
+});
+
+// Execute a query scoped to a tenant by filtering on tenant_id
+export async function tenantQuery(tenantId: string, sql: string, params: unknown[] = []) {
+  const [rows] = await pool.execute(sql, [...params, tenantId]);
+  return rows;
+}
+
+// Usage:
+// const orders = await tenantQuery("tenant-abc", "SELECT * FROM orders WHERE tenant_id = ?");
+
+export { pool };
+`
+      }
+    ];
+  }
+  return [
+    {
+      filename: "src/stratum-db.ts",
+      content: `// PostgreSQL client with Stratum tenant-scoped queries
+import { Pool } from "pg";
+import { createTenantPool } from "@stratum-hq/db-adapters";
+
+const pool = new Pool({
+  connectionString: process.env.DATABASE_URL,
+});
+
+// Create a tenant-scoped pool.
+// Sets app.current_tenant on each connection for RLS enforcement.
+export function getTenantPool(tenantId: string) {
+  return createTenantPool(pool, tenantId);
+}
+
+// Usage:
+// const tenantPool = getTenantPool("tenant-abc");
+// const { rows } = await tenantPool.query("SELECT * FROM orders");
+
+export { pool };
+`
+    }
+  ];
+}
+
+// src/generators/middleware.ts
+function generateMiddleware(projectName, preset) {
+  switch (preset.framework) {
+    case "express":
+      return generateExpressMiddleware(projectName);
+    case "fastify":
+      return generateFastifyMiddleware(projectName);
+    case "nextjs":
+      return generateNextjsMiddleware(projectName);
+    case "hono":
+      return generateHonoMiddleware(projectName);
+    case "nestjs":
+      return generateNestjsMiddleware(projectName);
+    case "none":
+      return generateNoFramework(projectName);
+  }
+}
+function generateExpressMiddleware(projectName) {
+  return [
+    {
+      filename: "src/index.ts",
+      content: `import express from "express";
+
+const app = express();
+const port = Number(process.env.PORT) || 3000;
+
+app.use(express.json());
+
+// Tenant extraction middleware
+app.use((req, _res, next) => {
+  const tenantId =
+    req.headers["x-tenant-id"] as string ||
+    req.hostname.split(".")[0];
+  (req as any).tenantId = tenantId;
+  next();
+});
+
+app.get("/health", (_req, res) => {
+  res.json({ status: "ok", project: "${projectName}" });
+});
+
+app.get("/tenants", async (req, res) => {
+  const tenantId = (req as any).tenantId;
+  res.json({ tenantId, message: "Replace with your tenant queries" });
+});
+
+app.listen(port, () => {
+  console.log(\`${projectName} running on http://localhost:\${port}\`);
+});
+`
+    }
+  ];
+}
+function generateFastifyMiddleware(projectName) {
+  return [
+    {
+      filename: "src/index.ts",
+      content: `import Fastify from "fastify";
+
+const fastify = Fastify({ logger: true });
+const port = Number(process.env.PORT) || 3000;
+
+// Tenant extraction plugin
+fastify.decorateRequest("tenantId", "");
+fastify.addHook("onRequest", async (request) => {
+  const tenantId =
+    (request.headers["x-tenant-id"] as string) ||
+    (request.hostname?.split(".")[0] ?? "");
+  (request as any).tenantId = tenantId;
+});
+
+fastify.get("/health", async () => {
+  return { status: "ok", project: "${projectName}" };
+});
+
+fastify.get("/tenants", async (request) => {
+  const tenantId = (request as any).tenantId;
+  return { tenantId, message: "Replace with your tenant queries" };
+});
+
+fastify.listen({ port, host: "0.0.0.0" }, (err) => {
+  if (err) {
+    fastify.log.error(err);
+    process.exit(1);
+  }
+});
+`
+    }
+  ];
+}
+function generateNextjsMiddleware(projectName) {
+  return [
+    {
+      filename: "middleware.ts",
+      content: `// Next.js edge middleware for tenant resolution
+import { NextRequest, NextResponse } from "next/server";
+
+export function middleware(request: NextRequest) {
+  const hostname = request.headers.get("host") || "";
+  const subdomain = hostname.split(".")[0];
+  const headerTenantId = request.headers.get("x-tenant-id");
+  const pathTenantId = request.nextUrl.pathname.match(/^\\/tenant\\/([^/]+)/)?.[1];
+
+  const tenantId = headerTenantId || pathTenantId || subdomain;
+
+  const requestHeaders = new Headers(request.headers);
+  if (tenantId && tenantId !== "localhost" && tenantId !== "www") {
+    requestHeaders.set("x-tenant-id", tenantId);
+  }
+
+  return NextResponse.next({ request: { headers: requestHeaders } });
+}
+
+export const config = {
+  matcher: ["/((?!_next/static|_next/image|favicon.ico).*)"],
+};
+`
+    },
+    {
+      filename: "src/app/page.tsx",
+      content: `// app/page.tsx - ${projectName} root page
+export default function Home() {
+  return (
+    <main style={{ padding: "2rem", fontFamily: "sans-serif" }}>
+      <h1>${projectName}</h1>
+      <p>Multi-tenant app powered by Stratum.</p>
+      <ul>
+        <li>Configure tenants via the Stratum control plane</li>
+        <li>Access tenant context via <code>x-tenant-id</code> header</li>
+        <li>Use <code>@stratum-hq/lib</code> for tenant resolution</li>
+      </ul>
+    </main>
+  );
+}
+`
+    }
+  ];
+}
+function generateHonoMiddleware(projectName) {
+  return [
+    {
+      filename: "src/index.ts",
+      content: `import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+
+const app = new Hono();
+
+// Tenant extraction middleware
+app.use("*", async (c, next) => {
+  const tenantId =
+    c.req.header("x-tenant-id") ||
+    new URL(c.req.url).hostname.split(".")[0];
+  c.set("tenantId", tenantId);
+  await next();
+});
+
+app.get("/health", (c) => {
+  return c.json({ status: "ok", project: "${projectName}" });
+});
+
+app.get("/tenants", (c) => {
+  const tenantId = c.get("tenantId");
+  return c.json({ tenantId, message: "Replace with your tenant queries" });
+});
+
+const port = Number(process.env.PORT) || 3000;
+console.log(\`${projectName} running on http://localhost:\${port}\`);
+serve({ fetch: app.fetch, port });
+`
+    }
+  ];
+}
+function generateNestjsMiddleware(projectName) {
+  return [
+    {
+      filename: "src/main.ts",
+      content: `import { NestFactory } from "@nestjs/core";
+import { AppModule } from "./app.module.js";
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule);
+  const port = Number(process.env.PORT) || 3000;
+  await app.listen(port);
+  console.log(\`${projectName} running on http://localhost:\${port}\`);
+}
+bootstrap();
+`
+    },
+    {
+      filename: "src/app.module.ts",
+      content: `import { Module } from "@nestjs/common";
+import { AppController } from "./app.controller.js";
+import { TenantGuard } from "./tenant.guard.js";
+import { APP_GUARD } from "@nestjs/core";
+
+@Module({
+  controllers: [AppController],
+  providers: [
+    { provide: APP_GUARD, useClass: TenantGuard },
+  ],
+})
+export class AppModule {}
+`
+    },
+    {
+      filename: "src/app.controller.ts",
+      content: `import { Controller, Get, Req } from "@nestjs/common";
+
+@Controller()
+export class AppController {
+  @Get("health")
+  health() {
+    return { status: "ok", project: "${projectName}" };
+  }
+
+  @Get("tenants")
+  tenants(@Req() req: any) {
+    return { tenantId: req.tenantId, message: "Replace with your tenant queries" };
+  }
+}
+`
+    },
+    {
+      filename: "src/tenant.guard.ts",
+      content: `import { Injectable, CanActivate, ExecutionContext } from "@nestjs/common";
+
+@Injectable()
+export class TenantGuard implements CanActivate {
+  canActivate(context: ExecutionContext): boolean {
+    const request = context.switchToHttp().getRequest();
+    const tenantId =
+      request.headers["x-tenant-id"] ||
+      request.hostname?.split(".")[0];
+    request.tenantId = tenantId || null;
+    return true;
+  }
+}
+`
+    }
+  ];
+}
+function generateNoFramework(projectName) {
+  return [
+    {
+      filename: "src/index.ts",
+      content: `// ${projectName} - Stratum multi-tenant setup (no framework)
+// Use this as a starting point and integrate with your framework of choice.
+
+console.log("${projectName} initialized");
+console.log("Import your database setup from ./stratum-db or equivalent");
+console.log("Add tenant resolution logic for your use case");
+`
+    }
+  ];
+}
+
+// src/generators/package-json.ts
+function generatePresetPackageJson(projectName, preset) {
+  const deps = {
+    "@stratum-hq/lib": "^0.2.0"
+  };
+  const devDeps = {
+    typescript: "^5.3.0",
+    "@types/node": "^20.11.0"
+  };
+  addDatabaseDeps(deps, preset);
+  addOrmDeps(deps, devDeps, preset);
+  addFrameworkDeps(deps, devDeps, preset);
+  addStratumDeps(deps, preset);
+  const scripts = getScripts(preset);
+  return JSON.stringify(
+    {
+      name: projectName,
+      version: "0.1.0",
+      private: true,
+      type: "module",
+      scripts,
+      dependencies: sortKeys(deps),
+      devDependencies: sortKeys(devDeps),
+      engines: {
+        node: ">=20.0.0"
+      }
+    },
+    null,
+    2
+  );
+}
+function addDatabaseDeps(deps, preset) {
+  switch (preset.database) {
+    case "postgres":
+      if (preset.orm !== "prisma" && preset.orm !== "drizzle" && preset.orm !== "sequelize") {
+        deps["pg"] = "^8.11.0";
+      }
+      if (preset.orm === "drizzle") {
+        deps["pg"] = "^8.11.0";
+      }
+      if (preset.orm === "pg") {
+        deps["pg"] = "^8.11.0";
+      }
+      if (preset.orm === "knex") {
+        deps["pg"] = "^8.11.0";
+      }
+      break;
+    case "mongodb":
+      break;
+    case "mysql":
+      if (preset.orm === "drizzle" || preset.orm === "pg") {
+        deps["mysql2"] = "^3.9.0";
+      }
+      break;
+  }
+}
+function addOrmDeps(deps, devDeps, preset) {
+  switch (preset.orm) {
+    case "prisma":
+      deps["@prisma/client"] = "^5.10.0";
+      devDeps["prisma"] = "^5.10.0";
+      if (preset.database === "postgres") {
+        deps["pg"] = "^8.11.0";
+      }
+      break;
+    case "drizzle":
+      deps["drizzle-orm"] = "^0.30.0";
+      devDeps["drizzle-kit"] = "^0.21.0";
+      if (preset.database === "postgres") {
+        deps["pg"] = "^8.11.0";
+      }
+      break;
+    case "sequelize":
+      deps["sequelize"] = "^6.37.0";
+      if (preset.database === "mysql") {
+        deps["mysql2"] = "^3.9.0";
+      } else {
+        deps["pg"] = "^8.11.0";
+      }
+      break;
+    case "knex":
+      deps["knex"] = "^3.1.0";
+      break;
+    case "mongoose":
+      deps["mongoose"] = "^8.2.0";
+      break;
+    case "pg":
+      break;
+  }
+}
+function addFrameworkDeps(deps, devDeps, preset) {
+  switch (preset.framework) {
+    case "express":
+      deps["express"] = "^4.18.0";
+      devDeps["@types/express"] = "^4.17.21";
+      break;
+    case "fastify":
+      deps["fastify"] = "^4.26.0";
+      break;
+    case "nextjs":
+      deps["next"] = "^15.5.16";
+      deps["react"] = "^19.0.0";
+      deps["react-dom"] = "^19.0.0";
+      devDeps["@types/react"] = "^19.0.0";
+      devDeps["@types/react-dom"] = "^19.0.0";
+      break;
+    case "hono":
+      deps["hono"] = "^4.1.0";
+      deps["@hono/node-server"] = "^1.8.0";
+      break;
+    case "nestjs":
+      deps["@nestjs/core"] = "^11.0.0";
+      deps["@nestjs/common"] = "^11.0.0";
+      deps["@nestjs/platform-express"] = "^11.0.0";
+      deps["reflect-metadata"] = "^0.2.0";
+      deps["rxjs"] = "^7.8.0";
+      break;
+    case "none":
+      break;
+  }
+}
+function addStratumDeps(deps, preset) {
+  if (preset.database === "postgres" && preset.orm !== "mongoose") {
+    deps["@stratum-hq/db-adapters"] = "^0.2.0";
+  }
+  if (preset.database === "mongodb") {
+    deps["@stratum-hq/mongodb"] = "^0.2.0";
+  }
+  if (preset.database === "mysql") {
+    deps["@stratum-hq/mysql"] = "^0.2.0";
+  }
+  if (preset.framework === "hono") {
+    deps["@stratum-hq/hono"] = "^0.2.0";
+  }
+  if (preset.framework === "nestjs") {
+    deps["@stratum-hq/nestjs"] = "^0.2.0";
+  }
+}
+function getScripts(preset) {
+  if (preset.framework === "nextjs") {
+    return { dev: "next dev", build: "next build", start: "next start" };
+  }
+  if (preset.framework === "nestjs") {
+    return { dev: "node --watch src/main.ts", build: "tsc", start: "node dist/main.js" };
+  }
+  return { dev: "node --watch src/index.js", build: "tsc", start: "node dist/index.js" };
+}
+function sortKeys(obj) {
+  const sorted = {};
+  for (const key of Object.keys(obj).sort()) {
+    sorted[key] = obj[key];
+  }
+  return sorted;
+}
+
+// src/generators/readme.ts
+function generatePresetReadme(projectName, preset) {
+  const devCmd = getDevCommand(preset);
+  const dbStartCmd = getDbStartInfo(preset);
+  const dbSetupNote = getDbSetupNote(preset);
+  return `# ${projectName}
+
+A multi-tenant application built with [Stratum](https://github.com/stratum-hq/Stratum).
+
+**Stack:** ${preset.database} + ${preset.strategy} strategy + ${preset.orm} + ${preset.framework === "none" ? "no framework" : preset.framework}
+
+## Getting started
+
+### 1. Start the database
+
+\`\`\`bash
+docker compose up -d
+\`\`\`
+${dbStartCmd}
+
+### 2. Configure environment
+
+\`\`\`bash
+cp .env.example .env
+# Edit .env with your database credentials and Stratum API key
+\`\`\`
+
+### 3. Install dependencies
+
+\`\`\`bash
+npm install
+\`\`\`
+${dbSetupNote}
+
+### 4. Run the app
+
+\`\`\`bash
+${devCmd}
+\`\`\`
+
+## Multi-tenancy
+
+This project uses Stratum for hierarchical multi-tenancy with the **${preset.strategy}** isolation strategy:
+
+${getStrategyDescription(preset.strategy)}
+
+See the [Stratum docs](https://github.com/stratum-hq/Stratum) for full reference.
+`;
+}
+function getDevCommand(preset) {
+  if (preset.framework === "nextjs")
+    return "npm run dev";
+  if (preset.framework === "nestjs")
+    return "node --env-file=.env src/main.ts";
+  if (preset.framework === "none")
+    return "node --env-file=.env src/index.ts";
+  return "node --env-file=.env src/index.ts";
+}
+function getDbStartInfo(preset) {
+  switch (preset.database) {
+    case "postgres":
+      return "\nThis starts PostgreSQL 16 on port 5432.\n";
+    case "mongodb":
+      return "\nThis starts MongoDB 7 on port 27017.\n";
+    case "mysql":
+      return "\nThis starts MySQL 8 on port 3306.\n";
+  }
+}
+function getDbSetupNote(preset) {
+  if (preset.orm === "prisma") {
+    return `
+### 3b. Generate Prisma client
+
+\`\`\`bash
+npx prisma generate
+npx prisma db push
+\`\`\`
+`;
+  }
+  if (preset.orm === "drizzle") {
+    return `
+### 3b. Run Drizzle migrations
+
+\`\`\`bash
+npx drizzle-kit push
+\`\`\`
+`;
+  }
+  return "";
+}
+function getStrategyDescription(strategy) {
+  switch (strategy) {
+    case "rls":
+      return `- **Row-Level Security** -- PostgreSQL RLS policies filter rows by tenant automatically
+- Each query sets \`app.current_tenant\` and RLS enforces isolation
+- All tenants share one database and schema`;
+    case "schema":
+      return `- **Schema-per-tenant** -- each tenant gets a dedicated PostgreSQL schema
+- Queries are routed to the correct schema via search_path
+- Shared database, isolated schemas`;
+    case "database":
+      return `- **Database-per-tenant** -- each tenant gets a fully isolated database
+- Connection routing directs queries to the correct database
+- Maximum isolation at the cost of more resource usage`;
+    case "collection":
+      return `- **Collection-per-tenant** -- each tenant gets dedicated MongoDB collections
+- Collection names are prefixed or namespaced by tenant ID
+- Shared database, isolated collections`;
+    case "table-prefix":
+      return `- **Table-prefix** -- tenant-specific tables with a naming prefix
+- Tables are prefixed with the tenant identifier
+- Shared database, prefixed table names`;
+    default:
+      return "";
+  }
+}
+
+// src/preset-project.ts
+function writeFile(filePath, content) {
+  const dir = path.dirname(filePath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  fs.writeFileSync(filePath, content, "utf8");
+  console.log(`  created  ${path.relative(process.cwd(), filePath)}`);
+}
+function generatePresetEnv(projectName, preset) {
+  const dbName = projectName.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+  const jwtSecret = crypto.randomBytes(32).toString("base64url");
+  let dbUrl;
+  switch (preset.database) {
+    case "postgres":
+      dbUrl = `postgres://${dbName}:dev_password@localhost:5432/${dbName}`;
+      break;
+    case "mongodb":
+      dbUrl = `mongodb://${dbName}:dev_password@localhost:27017/${dbName}?authSource=admin`;
+      break;
+    case "mysql":
+      dbUrl = `mysql://${dbName}:dev_password@localhost:3306/${dbName}`;
+      break;
+  }
+  const urlKey = preset.database === "mongodb" ? "MONGODB_URI" : "DATABASE_URL";
+  return `# Environment variables for ${projectName}
+# Copy to .env and fill in values
+
+# Database
+${urlKey}=${dbUrl}
+
+# Authentication
+JWT_SECRET=${jwtSecret}
+
+# Stratum Control Plane
+STRATUM_URL=http://localhost:3001
+STRATUM_API_KEY=sk_test_your_key_here
+
+NODE_ENV=development
+`;
+}
+function createPresetProject(projectName, preset, targetDir, skipInstall) {
+  const presetLabel = `${preset.database}/${preset.strategy}/${preset.orm}/${preset.framework}`;
+  console.log(`
+Creating ${projectName} with preset ${presetLabel}...
+`);
+  writeFile(
+    path.join(targetDir, "package.json"),
+    generatePresetPackageJson(projectName, preset)
+  );
+  writeFile(
+    path.join(targetDir, "docker-compose.yml"),
+    generatePresetDockerCompose(projectName, preset)
+  );
+  const initSql = generatePresetInitSql(projectName, preset);
+  if (initSql !== null) {
+    writeFile(path.join(targetDir, "init.sql"), initSql);
+  }
+  writeFile(
+    path.join(targetDir, ".env.example"),
+    generatePresetEnv(projectName, preset)
+  );
+  const dbFiles = generateDbSetup(preset);
+  for (const file of dbFiles) {
+    writeFile(path.join(targetDir, file.filename), file.content);
+  }
+  const middlewareFiles = generateMiddleware(projectName, preset);
+  for (const file of middlewareFiles) {
+    writeFile(path.join(targetDir, file.filename), file.content);
+  }
+  writeFile(
+    path.join(targetDir, "README.md"),
+    generatePresetReadme(projectName, preset)
+  );
+  writeFile(
+    path.join(targetDir, "tsconfig.json"),
+    JSON.stringify(
+      {
+        compilerOptions: {
+          target: "ESNext",
+          module: "NodeNext",
+          moduleResolution: "NodeNext",
+          strict: true,
+          outDir: "dist",
+          rootDir: "src",
+          declaration: true,
+          skipLibCheck: true,
+          esModuleInterop: true,
+          ...preset.framework === "nestjs" ? { experimentalDecorators: true, emitDecoratorMetadata: true } : {},
+          ...preset.framework === "nextjs" ? { jsx: "preserve", plugins: [{ name: "next" }] } : {}
+        },
+        include: ["src"],
+        exclude: ["node_modules", "dist"]
+      },
+      null,
+      2
+    )
+  );
+  if (!skipInstall) {
+    console.log("\nInstalling dependencies...\n");
+    try {
+      execSync("npm install", { cwd: targetDir, stdio: "inherit" });
+    } catch {
+      console.warn("\nWarning: npm install failed. Run it manually in the project directory.");
+    }
+  }
+}
+
+// src/index.ts
 function parseArgs(argv) {
   const args = [...argv];
   let projectName = null;
   let template = "express";
+  let preset = null;
   let skipInstall = false;
   let force = false;
+  let templateExplicit = false;
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
     if (arg === "--skip-install") {
@@ -21,6 +1188,7 @@ function parseArgs(argv) {
       const val = args[i + 1];
       if (val === "express" || val === "fastify" || val === "nextjs") {
         template = val;
+        templateExplicit = true;
         i++;
       } else {
         console.error(`Unknown template: ${val}. Available: express, fastify, nextjs`);
@@ -30,36 +1198,49 @@ function parseArgs(argv) {
       const val = arg.slice("--template=".length);
       if (val === "express" || val === "fastify" || val === "nextjs") {
         template = val;
+        templateExplicit = true;
       } else {
         console.error(`Unknown template: ${val}. Available: express, fastify, nextjs`);
         process.exit(1);
       }
+    } else if (arg === "--preset") {
+      preset = args[i + 1] || null;
+      i++;
+    } else if (arg.startsWith("--preset=")) {
+      preset = arg.slice("--preset=".length) || null;
     } else if (!arg.startsWith("--")) {
       projectName = arg;
     }
   }
-  return { projectName, template, skipInstall, force };
+  if (preset && templateExplicit) {
+    console.error("Error: --template and --preset cannot be used together. Use one or the other.");
+    process.exit(1);
+  }
+  return { projectName, template, preset, skipInstall, force };
 }
 function printUsage() {
   console.log("Usage: create-stratum <project-name> [options]");
   console.log("");
   console.log("Options:");
   console.log("  --template <express|fastify|nextjs>  Framework template (default: express)");
+  console.log("  --preset <db-strategy-orm-framework> Full stack preset (e.g. postgres-rls-prisma-express)");
   console.log("  --skip-install                       Skip npm install");
   console.log("  --force                              Overwrite existing directory");
   console.log("");
   console.log("Examples:");
   console.log("  npx @stratum-hq/create my-app");
   console.log("  npx @stratum-hq/create my-app --template fastify");
-  console.log("  npx @stratum-hq/create my-app --template nextjs --skip-install");
+  console.log("  npx @stratum-hq/create my-app --preset postgres-rls-prisma-express");
+  console.log("  npx @stratum-hq/create my-app --preset mongodb-database-mongoose-hono");
+  console.log("  npx @stratum-hq/create my-app --preset mysql-table-prefix-sequelize-nestjs");
 }
-function writeFile(filePath, content) {
-  const dir = path.dirname(filePath);
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
+function writeFile2(filePath, content) {
+  const dir = path2.dirname(filePath);
+  if (!fs2.existsSync(dir)) {
+    fs2.mkdirSync(dir, { recursive: true });
   }
-  fs.writeFileSync(filePath, content, "utf8");
-  console.log(`  created  ${path.relative(process.cwd(), filePath)}`);
+  fs2.writeFileSync(filePath, content, "utf8");
+  console.log(`  created  ${path2.relative(process.cwd(), filePath)}`);
 }
 function generatePackageJson(projectName, template) {
   const frameworkDeps = {
@@ -71,11 +1252,11 @@ function generatePackageJson(projectName, template) {
       fastify: "^4.26.0"
     },
     nextjs: {
-      next: "^14.1.0",
-      react: "^18.2.0",
-      "react-dom": "^18.2.0",
-      "@types/react": "^18.2.0",
-      "@types/react-dom": "^18.2.0"
+      next: "^15.5.16",
+      react: "^19.0.0",
+      "react-dom": "^19.0.0",
+      "@types/react": "^19.0.0",
+      "@types/react-dom": "^19.0.0"
     }
   };
   const deps = {
@@ -145,6 +1326,7 @@ COMMENT ON DATABASE ${dbName} IS 'Multi-tenant database for ${projectName}';
 }
 function generateEnv(projectName) {
   const dbName = projectName.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+  const jwtSecret = crypto2.randomBytes(32).toString("base64url");
   return `# Environment variables for ${projectName}
 # Copy to .env and fill in values
 
@@ -152,7 +1334,7 @@ function generateEnv(projectName) {
 DATABASE_URL=postgres://${dbName}:dev_password@localhost:5432/${dbName}
 
 # Authentication
-JWT_SECRET=change-me-in-production
+JWT_SECRET=${jwtSecret}
 
 # Stratum Control Plane
 STRATUM_URL=http://localhost:3001
@@ -245,7 +1427,7 @@ export default function Home() {
 }
 `;
 }
-function generateNextjsMiddleware() {
+function generateNextjsMiddleware2() {
   return `// middleware.ts \u2014 tenant resolution via subdomain or header
 import { NextRequest, NextResponse } from "next/server";
 
@@ -329,26 +1511,26 @@ function createProject(projectName, template, targetDir, skipInstall) {
   console.log(`
 Creating ${projectName} with ${template} template...
 `);
-  writeFile(
-    path.join(targetDir, "package.json"),
+  writeFile2(
+    path2.join(targetDir, "package.json"),
     generatePackageJson(projectName, template)
   );
-  writeFile(path.join(targetDir, "docker-compose.yml"), generateDockerCompose(projectName));
-  writeFile(path.join(targetDir, "init.sql"), generateInitSql(projectName));
-  writeFile(path.join(targetDir, ".env.example"), generateEnv(projectName));
+  writeFile2(path2.join(targetDir, "docker-compose.yml"), generateDockerCompose(projectName));
+  writeFile2(path2.join(targetDir, "init.sql"), generateInitSql(projectName));
+  writeFile2(path2.join(targetDir, ".env.example"), generateEnv(projectName));
   if (template === "express") {
-    writeFile(path.join(targetDir, "src", "index.ts"), generateExpressServer(projectName));
+    writeFile2(path2.join(targetDir, "src", "index.ts"), generateExpressServer(projectName));
   } else if (template === "fastify") {
-    writeFile(path.join(targetDir, "src", "index.ts"), generateFastifyServer(projectName));
+    writeFile2(path2.join(targetDir, "src", "index.ts"), generateFastifyServer(projectName));
   } else if (template === "nextjs") {
-    writeFile(path.join(targetDir, "src", "app", "page.tsx"), generateNextjsPage(projectName));
-    writeFile(path.join(targetDir, "middleware.ts"), generateNextjsMiddleware());
+    writeFile2(path2.join(targetDir, "src", "app", "page.tsx"), generateNextjsPage(projectName));
+    writeFile2(path2.join(targetDir, "middleware.ts"), generateNextjsMiddleware2());
   }
-  writeFile(path.join(targetDir, "README.md"), generateReadme(projectName, template));
+  writeFile2(path2.join(targetDir, "README.md"), generateReadme(projectName, template));
   if (!skipInstall) {
     console.log("\nInstalling dependencies...\n");
     try {
-      execSync("npm install", { cwd: targetDir, stdio: "inherit" });
+      execSync2("npm install", { cwd: targetDir, stdio: "inherit" });
     } catch {
       console.warn("\nWarning: npm install failed. Run it manually in the project directory.");
     }
@@ -362,14 +1544,14 @@ function validateProjectName(projectName) {
   if (!VALID_PROJECT_NAME.test(projectName)) {
     return `"${projectName}" is not a valid project name. Use only letters, numbers, dots, hyphens, and underscores. Must start with a letter or number.`;
   }
-  const targetDir = path.resolve(process.cwd(), projectName);
-  if (path.dirname(targetDir) !== process.cwd()) {
+  const targetDir = path2.resolve(process.cwd(), projectName);
+  if (path2.dirname(targetDir) !== process.cwd()) {
     return "Project name must not contain path separators.";
   }
   return null;
 }
 function main(argv) {
-  const { projectName, template, skipInstall, force } = parseArgs(argv);
+  const { projectName, template, preset, skipInstall, force } = parseArgs(argv);
   if (!projectName) {
     printUsage();
     process.exit(1);
@@ -379,17 +1561,34 @@ function main(argv) {
     console.error(`Error: ${validationError}`);
     process.exit(1);
   }
-  const targetDir = path.resolve(process.cwd(), projectName);
-  if (fs.existsSync(targetDir) && !force) {
+  const targetDir = path2.resolve(process.cwd(), projectName);
+  if (fs2.existsSync(targetDir) && !force) {
     console.error(`Error: Directory "${projectName}" already exists.`);
     console.error(`Use --force to overwrite.`);
     process.exit(1);
   }
-  if (fs.existsSync(targetDir) && force) {
-    fs.rmSync(targetDir, { recursive: true, force: true });
+  if (fs2.existsSync(targetDir) && force) {
+    fs2.rmSync(targetDir, { recursive: true, force: true });
+  }
+  fs2.mkdirSync(targetDir, { recursive: true });
+  if (preset) {
+    const parsed = parsePresetString(preset);
+    if (!parsed) {
+      console.error(`Error: Invalid preset string "${preset}".`);
+      console.error("Format: {database}-{strategy}-{orm}-{framework}");
+      console.error("Example: postgres-rls-prisma-express, mongodb-database-mongoose-hono");
+      process.exit(1);
+    }
+    if (!isValidPreset(parsed)) {
+      console.error(`Error: Invalid preset combination "${preset}".`);
+      console.error(`${parsed.database} does not support ${parsed.strategy}/${parsed.orm} together.`);
+      console.error("Run with --help to see valid combinations.");
+      process.exit(1);
+    }
+    createPresetProject(projectName, parsed, targetDir, skipInstall);
+  } else {
+    createProject(projectName, template, targetDir, skipInstall);
   }
-  fs.mkdirSync(targetDir, { recursive: true });
-  createProject(projectName, template, targetDir, skipInstall);
   console.log(`
 Success! Created ${projectName} at ${targetDir}
 `);
@@ -400,7 +1599,16 @@ Success! Created ${projectName} at ${targetDir}
   if (skipInstall) {
     console.log("  npm install");
   }
-  if (template === "nextjs") {
+  if (preset) {
+    const parsed = parsePresetString(preset);
+    if (parsed.framework === "nextjs") {
+      console.log("  npm run dev");
+    } else if (parsed.framework === "nestjs") {
+      console.log("  node --env-file=.env src/main.ts");
+    } else {
+      console.log("  node --env-file=.env src/index.ts");
+    }
+  } else if (template === "nextjs") {
     console.log("  npm run dev");
   } else {
     console.log("  node --env-file=.env src/index.ts");