@stratum-hq/create 0.2.3 → 0.3.0

package/src/index.ts

@@ -2,8 +2,11 @@
 
 import * as fs from "fs";
 import * as path from "path";
+import crypto from "node:crypto";
 import { execSync } from "child_process";
 import { fileURLToPath } from "url";
+import { parsePresetString, isValidPreset, formatPresetString } from "./matrix.js";
+import { createPresetProject } from "./preset-project.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────────
 
@@ -12,6 +15,7 @@ export type Template = "express" | "fastify" | "nextjs";
 export interface ParsedArgs {
   projectName: string | null;
   template: Template;
+  preset: string | null;
   skipInstall: boolean;
   force: boolean;
 }
@@ -23,8 +27,10 @@ export function parseArgs(argv: string[]): ParsedArgs {
   const args = [...argv];
   let projectName: string | null = null;
   let template: Template = "express";
+  let preset: string | null = null;
   let skipInstall = false;
   let force = false;
+  let templateExplicit = false;
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
@@ -36,6 +42,7 @@ export function parseArgs(argv: string[]): ParsedArgs {
       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`);
@@ -45,16 +52,27 @@ export function parseArgs(argv: string[]): ParsedArgs {
       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 };
 }
 
 // ─── Usage ────────────────────────────────────────────────────────────────────
@@ -64,13 +82,16 @@ function printUsage(): void {
   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");
 }
 
 // ─── File generation helpers ──────────────────────────────────────────────────
@@ -96,11 +117,11 @@ function generatePackageJson(projectName: string, template: Template): string {
       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",
     },
   };
 
@@ -178,6 +199,7 @@ COMMENT ON DATABASE ${dbName} IS 'Multi-tenant database for ${projectName}';
 
 function generateEnv(projectName: string): string {
   const dbName = projectName.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+  const jwtSecret = crypto.randomBytes(32).toString("base64url");
   return `# Environment variables for ${projectName}
 # Copy to .env and fill in values
 
@@ -185,7 +207,7 @@ function generateEnv(projectName: string): string {
 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
@@ -436,7 +458,7 @@ export function validateProjectName(projectName: string): string | null {
 // ─── Main entry point ─────────────────────────────────────────────────────────
 
 export function main(argv: string[]): void {
-  const { projectName, template, skipInstall, force } = parseArgs(argv);
+  const { projectName, template, preset, skipInstall, force } = parseArgs(argv);
 
   if (!projectName) {
     printUsage();
@@ -463,7 +485,26 @@ export function main(argv: string[]): void {
 
   fs.mkdirSync(targetDir, { recursive: true });
 
-  createProject(projectName, template, targetDir, skipInstall);
+  // Preset path: full stack generation
+  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 {
+    // Template path: existing behavior, untouched
+    createProject(projectName, template, targetDir, skipInstall);
+  }
 
   console.log(`\nSuccess! Created ${projectName} at ${targetDir}\n`);
   console.log("Next steps:\n");
@@ -473,7 +514,16 @@ export function main(argv: string[]): void {
   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");

package/src/matrix.ts

@@ -0,0 +1,186 @@
+// ─── Stack Combination Matrix ────────────────────────────────────────────────
+// Single source of truth for valid Stratum stack combinations.
+// Imported by create CLI, interactive wizard, and web docs.
+
+export type Database = "postgres" | "mongodb" | "mysql";
+export type Strategy = "rls" | "schema" | "database" | "collection" | "table-prefix";
+export type Orm = "prisma" | "drizzle" | "sequelize" | "knex" | "mongoose" | "pg";
+export type Framework = "express" | "fastify" | "nextjs" | "hono" | "nestjs" | "none";
+
+export interface StackPreset {
+  database: Database;
+  strategy: Strategy;
+  orm: Orm;
+  framework: Framework;
+}
+
+// ─── Valid combinations by database ──────────────────────────────────────────
+
+const POSTGRES_STRATEGIES: Strategy[] = ["rls", "schema", "database"];
+const POSTGRES_ORMS: Orm[] = ["prisma", "drizzle", "sequelize", "knex", "pg"];
+
+const MONGODB_STRATEGIES: Strategy[] = ["database", "collection"];
+const MONGODB_ORMS: Orm[] = ["mongoose"];
+
+const MYSQL_STRATEGIES: Strategy[] = ["database", "table-prefix"];
+const MYSQL_ORMS: Orm[] = ["sequelize", "knex", "pg"];
+
+const ALL_FRAMEWORKS: Framework[] = ["express", "fastify", "nextjs", "hono", "nestjs", "none"];
+
+export interface DatabaseConfig {
+  strategies: Strategy[];
+  orms: Orm[];
+  frameworks: Framework[];
+}
+
+export const VALID_COMBINATIONS: Record<Database, DatabaseConfig> = {
+  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,
+  },
+};
+
+// ─── All valid values (for parsing) ─────────────────────────────────────────
+
+const ALL_DATABASES: Database[] = ["postgres", "mongodb", "mysql"];
+const ALL_STRATEGIES: Strategy[] = ["rls", "schema", "database", "collection", "table-prefix"];
+const ALL_ORMS: Orm[] = ["prisma", "drizzle", "sequelize", "knex", "mongoose", "pg"];
+
+// ─── Validation ──────────────────────────────────────────────────────────────
+
+export function isValidPreset(preset: StackPreset): boolean {
+  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;
+}
+
+// ─── Parsing ─────────────────────────────────────────────────────────────────
+
+export function parsePresetString(s: string): StackPreset | null {
+  if (!s || typeof s !== "string") return null;
+
+  const parts = s.toLowerCase().split("-");
+
+  // Handle "table-prefix" which contains a hyphen -- it will split into
+  // 5 parts: [db, strategy1, "table", "prefix", orm, framework] or similar.
+  // We need to reconstruct multi-word tokens.
+  // Format: {database}-{strategy}-{orm}-{framework}
+  // Strategy "table-prefix" is the only multi-word token.
+
+  let database: string;
+  let strategy: string;
+  let orm: string;
+  let framework: string;
+
+  if (parts.length === 4) {
+    // Simple case: no hyphenated strategy
+    [database, strategy, orm, framework] = parts;
+  } else if (parts.length === 5) {
+    // "table-prefix" case: mysql-table-prefix-sequelize-express
+    database = parts[0];
+    strategy = `${parts[1]}-${parts[2]}`;
+    orm = parts[3];
+    framework = parts[4];
+  } else {
+    return null;
+  }
+
+  // Validate each part is a known value
+  if (!ALL_DATABASES.includes(database as Database)) return null;
+  if (!ALL_STRATEGIES.includes(strategy as Strategy)) return null;
+  if (!ALL_ORMS.includes(orm as Orm)) return null;
+  if (!ALL_FRAMEWORKS.includes(framework as Framework)) return null;
+
+  return {
+    database: database as Database,
+    strategy: strategy as Strategy,
+    orm: orm as Orm,
+    framework: framework as Framework,
+  };
+}
+
+// ─── Formatting ──────────────────────────────────────────────────────────────
+
+export function formatPresetString(preset: StackPreset): string {
+  return `${preset.database}-${preset.strategy}-${preset.orm}-${preset.framework}`;
+}
+
+// ─── Wizard helper: narrow valid options given partial selections ─────────────
+
+export interface ValidOptions {
+  databases: Database[];
+  strategies: Strategy[];
+  orms: Orm[];
+  frameworks: Framework[];
+}
+
+export function getValidOptions(partial: Partial<StackPreset>): ValidOptions {
+  let databases: Database[] = [...ALL_DATABASES];
+  let strategies: Strategy[] = [];
+  let orms: Orm[] = [];
+  let frameworks: Framework[] = [];
+
+  // If database is selected, narrow to that database's config
+  if (partial.database) {
+    databases = [partial.database];
+  }
+
+  // Collect valid strategies/orms/frameworks from matching databases
+  const strategySet = new Set<Strategy>();
+  const ormSet = new Set<Orm>();
+  const frameworkSet = new Set<Framework>();
+
+  for (const db of databases) {
+    const config = VALID_COMBINATIONS[db];
+
+    // If strategy is specified, only include this db if it supports it
+    if (partial.strategy && !config.strategies.includes(partial.strategy)) continue;
+    // If orm is specified, only include this db if it supports it
+    if (partial.orm && !config.orms.includes(partial.orm)) continue;
+
+    for (const s of config.strategies) strategySet.add(s);
+    for (const o of config.orms) ormSet.add(o);
+    for (const f of config.frameworks) frameworkSet.add(f);
+  }
+
+  strategies = [...strategySet];
+  orms = [...ormSet];
+  frameworks = [...frameworkSet];
+
+  // Further narrow if specific values are set
+  if (partial.strategy) {
+    strategies = strategies.filter((s) => s === partial.strategy);
+  }
+  if (partial.orm) {
+    orms = orms.filter((o) => o === partial.orm);
+  }
+  if (partial.framework) {
+    frameworks = frameworks.filter((f) => f === partial.framework);
+  }
+
+  // Narrow databases to only those that support all specified fields
+  if (partial.strategy || partial.orm) {
+    databases = databases.filter((db) => {
+      const config = VALID_COMBINATIONS[db];
+      if (partial.strategy && !config.strategies.includes(partial.strategy)) return false;
+      if (partial.orm && !config.orms.includes(partial.orm)) return false;
+      return true;
+    });
+  }
+
+  return { databases, strategies, orms, frameworks };
+}

package/src/preset-project.ts

@@ -0,0 +1,148 @@
+import * as fs from "fs";
+import * as path from "path";
+import crypto from "node:crypto";
+import { execSync } from "child_process";
+import type { StackPreset } from "./matrix.js";
+import { generatePresetDockerCompose } from "./generators/docker-compose.js";
+import { generatePresetInitSql } from "./generators/init-sql.js";
+import { generateDbSetup } from "./generators/db-setup.js";
+import { generateMiddleware } from "./generators/middleware.js";
+import { generatePresetPackageJson } from "./generators/package-json.js";
+import { generatePresetReadme } from "./generators/readme.js";
+
+function writeFile(filePath: string, content: string): void {
+  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: string, preset: StackPreset): string {
+  const dbName = projectName.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+  const jwtSecret = crypto.randomBytes(32).toString("base64url");
+
+  let dbUrl: string;
+  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
+`;
+}
+
+export function createPresetProject(
+  projectName: string,
+  preset: StackPreset,
+  targetDir: string,
+  skipInstall: boolean,
+): void {
+  const presetLabel = `${preset.database}/${preset.strategy}/${preset.orm}/${preset.framework}`;
+  console.log(`\nCreating ${projectName} with preset ${presetLabel}...\n`);
+
+  // package.json
+  writeFile(
+    path.join(targetDir, "package.json"),
+    generatePresetPackageJson(projectName, preset),
+  );
+
+  // docker-compose.yml
+  writeFile(
+    path.join(targetDir, "docker-compose.yml"),
+    generatePresetDockerCompose(projectName, preset),
+  );
+
+  // init.sql (if applicable)
+  const initSql = generatePresetInitSql(projectName, preset);
+  if (initSql !== null) {
+    writeFile(path.join(targetDir, "init.sql"), initSql);
+  }
+
+  // .env.example
+  writeFile(
+    path.join(targetDir, ".env.example"),
+    generatePresetEnv(projectName, preset),
+  );
+
+  // Database setup files (ORM config, tenant helpers)
+  const dbFiles = generateDbSetup(preset);
+  for (const file of dbFiles) {
+    writeFile(path.join(targetDir, file.filename), file.content);
+  }
+
+  // Framework middleware / server entry point
+  const middlewareFiles = generateMiddleware(projectName, preset);
+  for (const file of middlewareFiles) {
+    writeFile(path.join(targetDir, file.filename), file.content);
+  }
+
+  // README
+  writeFile(
+    path.join(targetDir, "README.md"),
+    generatePresetReadme(projectName, preset),
+  );
+
+  // tsconfig.json
+  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,
+    ),
+  );
+
+  // npm install
+  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.");
+    }
+  }
+}