@stratum-hq/create 0.2.3 → 0.3.1

package/dist/matrix.js

@@ -0,0 +1,131 @@
+// 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
+  };
+}
+function formatPresetString(preset) {
+  return `${preset.database}-${preset.strategy}-${preset.orm}-${preset.framework}`;
+}
+function getValidOptions(partial) {
+  let databases = [...ALL_DATABASES];
+  let strategies = [];
+  let orms = [];
+  let frameworks = [];
+  if (partial.database) {
+    databases = [partial.database];
+  }
+  const strategySet = /* @__PURE__ */ new Set();
+  const ormSet = /* @__PURE__ */ new Set();
+  const frameworkSet = /* @__PURE__ */ new Set();
+  for (const db of databases) {
+    const config = VALID_COMBINATIONS[db];
+    if (partial.strategy && !config.strategies.includes(partial.strategy))
+      continue;
+    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];
+  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);
+  }
+  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 };
+}
+export {
+  VALID_COMBINATIONS,
+  formatPresetString,
+  getValidOptions,
+  isValidPreset,
+  parsePresetString
+};

package/package.json

@@ -1,13 +1,32 @@
 {
   "name": "@stratum-hq/create",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Create a new Stratum multi-tenancy project",
+  "keywords": [
+    "multi-tenancy",
+    "multi-tenant",
+    "saas",
+    "tenant",
+    "create",
+    "scaffolding",
+    "starter",
+    "boilerplate",
+    "node",
+    "typescript",
+    "stratum"
+  ],
   "bin": {
     "create-stratum": "./dist/index.js"
   },
+  "exports": {
+    ".": "./dist/index.js",
+    "./matrix": "./dist/matrix.js"
+  },
   "type": "module",
   "scripts": {
-    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@stratum-hq/*",
+    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@stratum-hq/* && esbuild src/matrix.ts --bundle --platform=node --format=esm --outfile=dist/matrix.js --external:@stratum-hq/*",
+    "typecheck": "tsc --noEmit",
+    "lint": "eslint .",
     "test": "vitest run"
   },
   "devDependencies": {
@@ -20,6 +39,12 @@
     "registry": "https://registry.npmjs.org/"
   },
   "license": "MIT",
+  "author": "Christian Crank",
+  "homepage": "https://github.com/stratum-hq/Stratum/tree/main/packages/create#readme",
+  "bugs": "https://github.com/stratum-hq/Stratum/issues",
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/stratum-hq/Stratum.git",

package/src/generators/db-setup.ts

@@ -0,0 +1,320 @@
+import type { StackPreset } from "../matrix.js";
+
+export interface DbSetupFile {
+  filename: string;
+  content: string;
+}
+
+export function generateDbSetup(preset: StackPreset): DbSetupFile[] {
+  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: StackPreset): DbSetupFile[] {
+  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 { prismaWithTenant } 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 prismaWithTenant(prisma, getTenantId, pool);
+}
+
+// Usage:
+// const tenantPrisma = createTenantPrisma(() => currentTenantId);
+// const orders = await tenantPrisma.order.findMany();
+
+export { prisma, pool };
+`,
+    },
+  ];
+}
+
+function generateDrizzleSetup(preset: StackPreset): DbSetupFile[] {
+  const files: DbSetupFile[] = [];
+
+  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 { drizzleWithTenant } 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 drizzleWithTenant(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: StackPreset): DbSetupFile[] {
+  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: StackPreset): DbSetupFile[] {
+  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: StackPreset): DbSetupFile[] {
+  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: StackPreset): DbSetupFile[] {
+  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 };
+`,
+    },
+  ];
+}

package/src/generators/docker-compose.ts

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

package/src/generators/init-sql.ts

@@ -0,0 +1,57 @@
+import type { StackPreset } from "../matrix.js";
+
+export function generatePresetInitSql(projectName: string, preset: StackPreset): string | null {
+  const dbName = projectName.replace(/[^a-z0-9]/gi, "_").toLowerCase();
+
+  switch (preset.database) {
+    case "postgres":
+      return generatePostgresInit(projectName, dbName, preset.strategy);
+    case "mongodb":
+      // MongoDB does not use SQL initialization
+      return null;
+    case "mysql":
+      return generateMysqlInit(projectName, dbName);
+  }
+}
+
+function generatePostgresInit(projectName: string, dbName: string, strategy: string): string {
+  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: string, dbName: string): string {
+  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
+);
+`;
+}