@stratum-hq/create 0.2.3 → 0.3.0

package/package.json

@@ -1,10 +1,30 @@
 {
   "name": "@stratum-hq/create",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "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": {
+      "import": "./src/matrix.ts",
+      "types": "./src/matrix.ts"
+    }
+  },
   "type": "module",
   "scripts": {
     "build": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --external:@stratum-hq/*",

package/src/__tests__/matrix.test.ts

@@ -0,0 +1,283 @@
+import { describe, it, expect } from "vitest";
+import {
+  parsePresetString,
+  formatPresetString,
+  isValidPreset,
+  getValidOptions,
+  VALID_COMBINATIONS,
+  type StackPreset,
+} from "../matrix.js";
+
+// ─── parsePresetString ───────────────────────────────────────────────────────
+
+describe("parsePresetString", () => {
+  it("parses a valid postgres preset", () => {
+    const result = parsePresetString("postgres-rls-prisma-express");
+    expect(result).toEqual({
+      database: "postgres",
+      strategy: "rls",
+      orm: "prisma",
+      framework: "express",
+    });
+  });
+
+  it("parses a valid mongodb preset", () => {
+    const result = parsePresetString("mongodb-database-mongoose-hono");
+    expect(result).toEqual({
+      database: "mongodb",
+      strategy: "database",
+      orm: "mongoose",
+      framework: "hono",
+    });
+  });
+
+  it("parses mysql with table-prefix (hyphenated strategy)", () => {
+    const result = parsePresetString("mysql-table-prefix-sequelize-nestjs");
+    expect(result).toEqual({
+      database: "mysql",
+      strategy: "table-prefix",
+      orm: "sequelize",
+      framework: "nestjs",
+    });
+  });
+
+  it("parses preset with none framework", () => {
+    const result = parsePresetString("postgres-schema-drizzle-none");
+    expect(result).toEqual({
+      database: "postgres",
+      strategy: "schema",
+      orm: "drizzle",
+      framework: "none",
+    });
+  });
+
+  it("handles uppercase input by lowering", () => {
+    const result = parsePresetString("POSTGRES-RLS-PRISMA-EXPRESS");
+    expect(result).toEqual({
+      database: "postgres",
+      strategy: "rls",
+      orm: "prisma",
+      framework: "express",
+    });
+  });
+
+  it("returns null for empty string", () => {
+    expect(parsePresetString("")).toBeNull();
+  });
+
+  it("returns null for garbage input", () => {
+    expect(parsePresetString("invalid-garbage")).toBeNull();
+  });
+
+  it("returns null for too few parts", () => {
+    expect(parsePresetString("postgres-rls")).toBeNull();
+  });
+
+  it("returns null for too many parts (non table-prefix)", () => {
+    expect(parsePresetString("postgres-rls-prisma-express-extra-stuff")).toBeNull();
+  });
+
+  it("returns null for unknown database", () => {
+    expect(parsePresetString("redis-rls-prisma-express")).toBeNull();
+  });
+
+  it("returns null for unknown orm", () => {
+    expect(parsePresetString("postgres-rls-typeorm-express")).toBeNull();
+  });
+
+  it("returns null for unknown framework", () => {
+    expect(parsePresetString("postgres-rls-prisma-koa")).toBeNull();
+  });
+
+  it("returns null for unknown strategy", () => {
+    expect(parsePresetString("postgres-sharding-prisma-express")).toBeNull();
+  });
+});
+
+// ─── formatPresetString ──────────────────────────────────────────────────────
+
+describe("formatPresetString", () => {
+  it("formats a simple preset", () => {
+    const preset: StackPreset = {
+      database: "postgres",
+      strategy: "rls",
+      orm: "prisma",
+      framework: "express",
+    };
+    expect(formatPresetString(preset)).toBe("postgres-rls-prisma-express");
+  });
+
+  it("formats a table-prefix preset", () => {
+    const preset: StackPreset = {
+      database: "mysql",
+      strategy: "table-prefix",
+      orm: "sequelize",
+      framework: "nestjs",
+    };
+    expect(formatPresetString(preset)).toBe("mysql-table-prefix-sequelize-nestjs");
+  });
+
+  it("round-trips with parsePresetString", () => {
+    const original = "mongodb-collection-mongoose-fastify";
+    const parsed = parsePresetString(original)!;
+    expect(parsed).not.toBeNull();
+    expect(formatPresetString(parsed)).toBe(original);
+  });
+
+  it("round-trips table-prefix", () => {
+    const original = "mysql-table-prefix-knex-hono";
+    const parsed = parsePresetString(original)!;
+    expect(parsed).not.toBeNull();
+    expect(formatPresetString(parsed)).toBe(original);
+  });
+});
+
+// ─── isValidPreset ───────────────────────────────────────────────────────────
+
+describe("isValidPreset", () => {
+  // Valid PostgreSQL combos
+  it("accepts postgres-rls-prisma-express", () => {
+    expect(isValidPreset({ database: "postgres", strategy: "rls", orm: "prisma", framework: "express" })).toBe(true);
+  });
+
+  it("accepts postgres-schema-drizzle-fastify", () => {
+    expect(isValidPreset({ database: "postgres", strategy: "schema", orm: "drizzle", framework: "fastify" })).toBe(true);
+  });
+
+  it("accepts postgres-database-pg-none", () => {
+    expect(isValidPreset({ database: "postgres", strategy: "database", orm: "pg", framework: "none" })).toBe(true);
+  });
+
+  it("accepts postgres-rls-knex-hono", () => {
+    expect(isValidPreset({ database: "postgres", strategy: "rls", orm: "knex", framework: "hono" })).toBe(true);
+  });
+
+  it("accepts postgres-rls-sequelize-nestjs", () => {
+    expect(isValidPreset({ database: "postgres", strategy: "rls", orm: "sequelize", framework: "nestjs" })).toBe(true);
+  });
+
+  // Valid MongoDB combos
+  it("accepts mongodb-database-mongoose-express", () => {
+    expect(isValidPreset({ database: "mongodb", strategy: "database", orm: "mongoose", framework: "express" })).toBe(true);
+  });
+
+  it("accepts mongodb-collection-mongoose-hono", () => {
+    expect(isValidPreset({ database: "mongodb", strategy: "collection", orm: "mongoose", framework: "hono" })).toBe(true);
+  });
+
+  // Valid MySQL combos
+  it("accepts mysql-database-sequelize-express", () => {
+    expect(isValidPreset({ database: "mysql", strategy: "database", orm: "sequelize", framework: "express" })).toBe(true);
+  });
+
+  it("accepts mysql-table-prefix-knex-nextjs", () => {
+    expect(isValidPreset({ database: "mysql", strategy: "table-prefix", orm: "knex", framework: "nextjs" })).toBe(true);
+  });
+
+  it("accepts mysql-database-pg-fastify", () => {
+    expect(isValidPreset({ database: "mysql", strategy: "database", orm: "pg", framework: "fastify" })).toBe(true);
+  });
+
+  // Invalid combos
+  it("rejects mongodb-rls-prisma-express (rls not valid for mongodb)", () => {
+    expect(isValidPreset({ database: "mongodb", strategy: "rls", orm: "prisma", framework: "express" })).toBe(false);
+  });
+
+  it("rejects mongodb-database-prisma-express (prisma not valid for mongodb)", () => {
+    expect(isValidPreset({ database: "mongodb", strategy: "database", orm: "prisma", framework: "express" })).toBe(false);
+  });
+
+  it("rejects postgres-collection-prisma-express (collection not valid for postgres)", () => {
+    expect(isValidPreset({ database: "postgres", strategy: "collection", orm: "prisma", framework: "express" })).toBe(false);
+  });
+
+  it("rejects mysql-rls-sequelize-express (rls not valid for mysql)", () => {
+    expect(isValidPreset({ database: "mysql", strategy: "rls", orm: "sequelize", framework: "express" })).toBe(false);
+  });
+
+  it("rejects mysql-database-mongoose-express (mongoose not valid for mysql)", () => {
+    expect(isValidPreset({ database: "mysql", strategy: "database", orm: "mongoose", framework: "express" })).toBe(false);
+  });
+
+  it("rejects postgres-rls-mongoose-express (mongoose not valid for postgres)", () => {
+    expect(isValidPreset({ database: "postgres", strategy: "rls", orm: "mongoose", framework: "express" })).toBe(false);
+  });
+});
+
+// ─── getValidOptions ─────────────────────────────────────────────────────────
+
+describe("getValidOptions", () => {
+  it("returns all options when no selection made", () => {
+    const opts = getValidOptions({});
+    expect(opts.databases).toContain("postgres");
+    expect(opts.databases).toContain("mongodb");
+    expect(opts.databases).toContain("mysql");
+    expect(opts.orms.length).toBeGreaterThan(0);
+    expect(opts.strategies.length).toBeGreaterThan(0);
+    expect(opts.frameworks.length).toBeGreaterThan(0);
+  });
+
+  it("narrows orms to mongoose when mongodb selected", () => {
+    const opts = getValidOptions({ database: "mongodb" });
+    expect(opts.orms).toEqual(["mongoose"]);
+  });
+
+  it("narrows strategies when mongodb selected", () => {
+    const opts = getValidOptions({ database: "mongodb" });
+    expect(opts.strategies).toEqual(["database", "collection"]);
+  });
+
+  it("narrows databases when mongoose selected", () => {
+    const opts = getValidOptions({ orm: "mongoose" });
+    expect(opts.databases).toEqual(["mongodb"]);
+  });
+
+  it("narrows databases when rls strategy selected", () => {
+    const opts = getValidOptions({ strategy: "rls" });
+    expect(opts.databases).toEqual(["postgres"]);
+  });
+
+  it("includes all frameworks for any database", () => {
+    for (const db of ["postgres", "mongodb", "mysql"] as const) {
+      const opts = getValidOptions({ database: db });
+      expect(opts.frameworks).toContain("express");
+      expect(opts.frameworks).toContain("none");
+    }
+  });
+
+  it("narrows databases when table-prefix selected", () => {
+    const opts = getValidOptions({ strategy: "table-prefix" });
+    expect(opts.databases).toEqual(["mysql"]);
+  });
+
+  it("includes postgres and mysql for sequelize", () => {
+    const opts = getValidOptions({ orm: "sequelize" });
+    expect(opts.databases).toContain("postgres");
+    expect(opts.databases).toContain("mysql");
+    expect(opts.databases).not.toContain("mongodb");
+  });
+});
+
+// ─── VALID_COMBINATIONS structure ────────────────────────────────────────────
+
+describe("VALID_COMBINATIONS", () => {
+  it("has all three databases", () => {
+    expect(Object.keys(VALID_COMBINATIONS)).toEqual(["postgres", "mongodb", "mysql"]);
+  });
+
+  it("postgres has rls, schema, database strategies", () => {
+    expect(VALID_COMBINATIONS.postgres.strategies).toEqual(["rls", "schema", "database"]);
+  });
+
+  it("mongodb has database, collection strategies", () => {
+    expect(VALID_COMBINATIONS.mongodb.strategies).toEqual(["database", "collection"]);
+  });
+
+  it("mysql has database, table-prefix strategies", () => {
+    expect(VALID_COMBINATIONS.mysql.strategies).toEqual(["database", "table-prefix"]);
+  });
+
+  it("mongodb only supports mongoose", () => {
+    expect(VALID_COMBINATIONS.mongodb.orms).toEqual(["mongoose"]);
+  });
+});

package/src/__tests__/preset.test.ts

@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs";
+import * as path from "path";
+import * as os from "os";
+import { parseArgs, createProject } from "../index.js";
+import { createPresetProject } from "../preset-project.js";
+import type { StackPreset } from "../matrix.js";
+
+// ─── parseArgs --preset tests ────────────────────────────────────────────────
+
+describe("parseArgs --preset", () => {
+  it("parses --preset flag", () => {
+    const result = parseArgs(["my-app", "--preset", "postgres-rls-prisma-express"]);
+    expect(result.preset).toBe("postgres-rls-prisma-express");
+  });
+
+  it("parses --preset=value syntax", () => {
+    const result = parseArgs(["my-app", "--preset=mongodb-database-mongoose-hono"]);
+    expect(result.preset).toBe("mongodb-database-mongoose-hono");
+  });
+
+  it("preset defaults to null", () => {
+    const result = parseArgs(["my-app"]);
+    expect(result.preset).toBeNull();
+  });
+
+  it("existing --template still works when no preset", () => {
+    const result = parseArgs(["my-app", "--template", "fastify"]);
+    expect(result.template).toBe("fastify");
+    expect(result.preset).toBeNull();
+  });
+});
+
+// ─── Regression: existing template tests ─────────────────────────────────────
+
+describe("regression: --template path unchanged", () => {
+  let tmpDir: string;
+  let projectDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "stratum-preset-regress-"));
+    projectDir = path.join(tmpDir, "test-project");
+    fs.mkdirSync(projectDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  it("--template express still generates correct files", () => {
+    createProject("test-project", "express", projectDir, true);
+    expect(fs.existsSync(path.join(projectDir, "package.json"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "docker-compose.yml"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "index.ts"))).toBe(true);
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+    expect(pkg.dependencies["express"]).toBeDefined();
+    expect(pkg.dependencies["@stratum-hq/lib"]).toBeDefined();
+  });
+
+  it("--template nextjs still generates correct files", () => {
+    createProject("test-project", "nextjs", projectDir, true);
+    expect(fs.existsSync(path.join(projectDir, "src", "app", "page.tsx"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "middleware.ts"))).toBe(true);
+  });
+});
+
+// ─── Preset project generation ───────────────────────────────────────────────
+
+describe("createPresetProject", () => {
+  let tmpDir: string;
+  let projectDir: string;
+
+  beforeEach(() => {
+    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "stratum-preset-test-"));
+    projectDir = path.join(tmpDir, "test-project");
+    fs.mkdirSync(projectDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    fs.rmSync(tmpDir, { recursive: true, force: true });
+  });
+
+  // ── PostgreSQL presets ──
+
+  it("generates postgres-rls-prisma-express project", () => {
+    const preset: StackPreset = { database: "postgres", strategy: "rls", orm: "prisma", framework: "express" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    expect(fs.existsSync(path.join(projectDir, "package.json"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "docker-compose.yml"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "init.sql"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, ".env.example"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "index.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "prisma", "schema.prisma"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "stratum-prisma.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "README.md"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "tsconfig.json"))).toBe(true);
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+    expect(pkg.dependencies["@prisma/client"]).toBeDefined();
+    expect(pkg.dependencies["express"]).toBeDefined();
+    expect(pkg.dependencies["@stratum-hq/lib"]).toBeDefined();
+    expect(pkg.dependencies["@stratum-hq/db-adapters"]).toBeDefined();
+
+    const docker = fs.readFileSync(path.join(projectDir, "docker-compose.yml"), "utf8");
+    expect(docker).toContain("postgres:16-alpine");
+
+    const sql = fs.readFileSync(path.join(projectDir, "init.sql"), "utf8");
+    expect(sql).toContain("uuid-ossp");
+    expect(sql).toContain("ltree");
+    expect(sql).toContain("Row-Level Security");
+  });
+
+  it("generates postgres-schema-drizzle-fastify project", () => {
+    const preset: StackPreset = { database: "postgres", strategy: "schema", orm: "drizzle", framework: "fastify" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    expect(fs.existsSync(path.join(projectDir, "src", "stratum-drizzle.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "drizzle.config.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "index.ts"))).toBe(true);
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+    expect(pkg.dependencies["drizzle-orm"]).toBeDefined();
+    expect(pkg.dependencies["fastify"]).toBeDefined();
+
+    const server = fs.readFileSync(path.join(projectDir, "src", "index.ts"), "utf8");
+    expect(server).toContain("Fastify");
+  });
+
+  it("generates postgres-database-pg-express project", () => {
+    const preset: StackPreset = { database: "postgres", strategy: "database", orm: "pg", framework: "express" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    expect(fs.existsSync(path.join(projectDir, "src", "stratum-db.ts"))).toBe(true);
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+    expect(pkg.dependencies["pg"]).toBeDefined();
+    expect(pkg.dependencies["@stratum-hq/db-adapters"]).toBeDefined();
+  });
+
+  // ── MongoDB presets ──
+
+  it("generates mongodb-database-mongoose-hono project", () => {
+    const preset: StackPreset = { database: "mongodb", strategy: "database", orm: "mongoose", framework: "hono" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    expect(fs.existsSync(path.join(projectDir, "docker-compose.yml"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "stratum-mongoose.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "index.ts"))).toBe(true);
+    // MongoDB should NOT have init.sql
+    expect(fs.existsSync(path.join(projectDir, "init.sql"))).toBe(false);
+
+    const docker = fs.readFileSync(path.join(projectDir, "docker-compose.yml"), "utf8");
+    expect(docker).toContain("mongo:7");
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+    expect(pkg.dependencies["mongoose"]).toBeDefined();
+    expect(pkg.dependencies["hono"]).toBeDefined();
+    expect(pkg.dependencies["@stratum-hq/mongodb"]).toBeDefined();
+
+    const env = fs.readFileSync(path.join(projectDir, ".env.example"), "utf8");
+    expect(env).toContain("MONGODB_URI");
+  });
+
+  // ── MySQL presets ──
+
+  it("generates mysql-table-prefix-sequelize-nestjs project", () => {
+    const preset: StackPreset = { database: "mysql", strategy: "table-prefix", orm: "sequelize", framework: "nestjs" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    expect(fs.existsSync(path.join(projectDir, "docker-compose.yml"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "init.sql"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "stratum-sequelize.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "main.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "app.module.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "tenant.guard.ts"))).toBe(true);
+
+    const docker = fs.readFileSync(path.join(projectDir, "docker-compose.yml"), "utf8");
+    expect(docker).toContain("mysql:8");
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+    expect(pkg.dependencies["sequelize"]).toBeDefined();
+    expect(pkg.dependencies["@nestjs/core"]).toBeDefined();
+    expect(pkg.dependencies["@stratum-hq/mysql"]).toBeDefined();
+    expect(pkg.dependencies["@stratum-hq/nestjs"]).toBeDefined();
+  });
+
+  it("generates mysql-database-knex-express project", () => {
+    const preset: StackPreset = { database: "mysql", strategy: "database", orm: "knex", framework: "express" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    expect(fs.existsSync(path.join(projectDir, "knexfile.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "stratum-knex.ts"))).toBe(true);
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+    expect(pkg.dependencies["knex"]).toBeDefined();
+    expect(pkg.dependencies["express"]).toBeDefined();
+  });
+
+  // ── Next.js preset ──
+
+  it("generates postgres-rls-prisma-nextjs project", () => {
+    const preset: StackPreset = { database: "postgres", strategy: "rls", orm: "prisma", framework: "nextjs" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    expect(fs.existsSync(path.join(projectDir, "middleware.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "app", "page.tsx"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "prisma", "schema.prisma"))).toBe(true);
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+    expect(pkg.dependencies["next"]).toBeDefined();
+    expect(pkg.dependencies["react"]).toBeDefined();
+    expect(pkg.scripts.dev).toBe("next dev");
+  });
+
+  // ── "none" framework ──
+
+  it("generates postgres-rls-pg-none project", () => {
+    const preset: StackPreset = { database: "postgres", strategy: "rls", orm: "pg", framework: "none" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    expect(fs.existsSync(path.join(projectDir, "src", "index.ts"))).toBe(true);
+    expect(fs.existsSync(path.join(projectDir, "src", "stratum-db.ts"))).toBe(true);
+
+    const pkg = JSON.parse(fs.readFileSync(path.join(projectDir, "package.json"), "utf8"));
+    // Should not have any framework dependency
+    expect(pkg.dependencies["express"]).toBeUndefined();
+    expect(pkg.dependencies["fastify"]).toBeUndefined();
+    expect(pkg.dependencies["next"]).toBeUndefined();
+    expect(pkg.dependencies["hono"]).toBeUndefined();
+    expect(pkg.dependencies["@nestjs/core"]).toBeUndefined();
+  });
+
+  // ── README content ──
+
+  it("README mentions the preset stack", () => {
+    const preset: StackPreset = { database: "postgres", strategy: "rls", orm: "prisma", framework: "express" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    const readme = fs.readFileSync(path.join(projectDir, "README.md"), "utf8");
+    expect(readme).toContain("postgres");
+    expect(readme).toContain("rls");
+    expect(readme).toContain("prisma");
+    expect(readme).toContain("Row-Level Security");
+  });
+
+  // ── tsconfig.json ──
+
+  it("generates tsconfig with decorators for nestjs", () => {
+    const preset: StackPreset = { database: "postgres", strategy: "rls", orm: "prisma", framework: "nestjs" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    const tsconfig = JSON.parse(fs.readFileSync(path.join(projectDir, "tsconfig.json"), "utf8"));
+    expect(tsconfig.compilerOptions.experimentalDecorators).toBe(true);
+    expect(tsconfig.compilerOptions.emitDecoratorMetadata).toBe(true);
+  });
+
+  it("generates tsconfig with jsx for nextjs", () => {
+    const preset: StackPreset = { database: "postgres", strategy: "rls", orm: "prisma", framework: "nextjs" };
+    createPresetProject("test-project", preset, projectDir, true);
+
+    const tsconfig = JSON.parse(fs.readFileSync(path.join(projectDir, "tsconfig.json"), "utf8"));
+    expect(tsconfig.compilerOptions.jsx).toBe("preserve");
+  });
+});