@stratum-hq/create 0.2.3 → 0.3.0

package/src/generators/middleware.ts

@@ -0,0 +1,267 @@
+import type { StackPreset } from "../matrix.js";
+
+export interface MiddlewareFile {
+  filename: string;
+  content: string;
+}
+
+export function generateMiddleware(projectName: string, preset: StackPreset): MiddlewareFile[] {
+  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: string): MiddlewareFile[] {
+  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: string): MiddlewareFile[] {
+  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: string): MiddlewareFile[] {
+  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: string): MiddlewareFile[] {
+  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: string): MiddlewareFile[] {
+  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: string): MiddlewareFile[] {
+  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");
+`,
+    },
+  ];
+}

package/src/generators/package-json.ts

@@ -0,0 +1,174 @@
+import type { StackPreset } from "../matrix.js";
+
+export function generatePresetPackageJson(projectName: string, preset: StackPreset): string {
+  const deps: Record<string, string> = {
+    "@stratum-hq/lib": "^0.2.0",
+  };
+  const devDeps: Record<string, string> = {
+    typescript: "^5.3.0",
+    "@types/node": "^20.11.0",
+  };
+
+  // Database driver deps
+  addDatabaseDeps(deps, preset);
+
+  // ORM deps
+  addOrmDeps(deps, devDeps, preset);
+
+  // Framework deps
+  addFrameworkDeps(deps, devDeps, preset);
+
+  // Stratum adapter deps
+  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: Record<string, string>, preset: StackPreset): void {
+  switch (preset.database) {
+    case "postgres":
+      if (preset.orm !== "prisma" && preset.orm !== "drizzle" && preset.orm !== "sequelize") {
+        deps["pg"] = "^8.11.0";
+      }
+      // prisma/drizzle/sequelize bring their own pg driver
+      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":
+      // mongoose handles the driver
+      break;
+    case "mysql":
+      if (preset.orm === "drizzle" || preset.orm === "pg") {
+        deps["mysql2"] = "^3.9.0";
+      }
+      break;
+  }
+}
+
+function addOrmDeps(deps: Record<string, string>, devDeps: Record<string, string>, preset: StackPreset): void {
+  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":
+      // pg already handled in addDatabaseDeps
+      break;
+  }
+}
+
+function addFrameworkDeps(deps: Record<string, string>, devDeps: Record<string, string>, preset: StackPreset): void {
+  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: Record<string, string>, preset: StackPreset): void {
+  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: StackPreset): Record<string, string> {
+  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: Record<string, string>): Record<string, string> {
+  const sorted: Record<string, string> = {};
+  for (const key of Object.keys(obj).sort()) {
+    sorted[key] = obj[key];
+  }
+  return sorted;
+}

package/src/generators/readme.ts

@@ -0,0 +1,119 @@
+import type { StackPreset } from "../matrix.js";
+
+export function generatePresetReadme(projectName: string, preset: StackPreset): string {
+  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: StackPreset): string {
+  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: StackPreset): string {
+  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: StackPreset): string {
+  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: string): string {
+  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 "";
+  }
+}