create-forgeon 0.1.37 → 0.2.0

package/templates/base/infra/docker/compose.nginx.yml

@@ -1,45 +1,21 @@
-services:
-  db:
-    image: postgres:16-alpine
-    restart: unless-stopped
-    environment:
-      POSTGRES_USER: ${POSTGRES_USER}
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
-      POSTGRES_DB: ${POSTGRES_DB}
-    ports:
-      - "5432:5432"
-    volumes:
-      - db_data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]
-      interval: 10s
-      timeout: 5s
-      retries: 10
-
-  api:
-    build:
-      context: ../..
-      dockerfile: apps/api/Dockerfile
-    restart: unless-stopped
+services:
+  api:
+    build:
+      context: ../..
+      dockerfile: apps/api/Dockerfile
+    restart: unless-stopped
     environment:
       PORT: ${PORT}
       API_PREFIX: ${API_PREFIX}
-      DATABASE_URL: ${DATABASE_URL}
       I18N_DEFAULT_LANG: ${I18N_DEFAULT_LANG}
       I18N_FALLBACK_LANG: ${I18N_FALLBACK_LANG}
-    depends_on:
-      db:
-        condition: service_healthy
-
-  nginx:
+
+  nginx:
     build:
       context: ../..
       dockerfile: infra/docker/nginx.Dockerfile
-    restart: unless-stopped
-    depends_on:
-      - api
-    ports:
-      - "8080:80"
-
-volumes:
-  db_data:
+    restart: unless-stopped
+    depends_on:
+      - api
+    ports:
+      - "8080:80"

package/templates/base/infra/docker/compose.none.yml

@@ -1,37 +1,13 @@
-services:
-  db:
-    image: postgres:16-alpine
-    restart: unless-stopped
-    environment:
-      POSTGRES_USER: ${POSTGRES_USER}
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
-      POSTGRES_DB: ${POSTGRES_DB}
-    ports:
-      - "5432:5432"
-    volumes:
-      - db_data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]
-      interval: 10s
-      timeout: 5s
-      retries: 10
-
-  api:
-    build:
-      context: ../..
-      dockerfile: apps/api/Dockerfile
-    restart: unless-stopped
+services:
+  api:
+    build:
+      context: ../..
+      dockerfile: apps/api/Dockerfile
+    restart: unless-stopped
     environment:
       PORT: ${PORT}
       API_PREFIX: ${API_PREFIX}
-      DATABASE_URL: ${DATABASE_URL}
       I18N_DEFAULT_LANG: ${I18N_DEFAULT_LANG}
       I18N_FALLBACK_LANG: ${I18N_FALLBACK_LANG}
-    depends_on:
-      db:
-        condition: service_healthy
-    ports:
-      - "3000:3000"
-
-volumes:
-  db_data:
+    ports:
+      - "3000:3000"

package/templates/base/infra/docker/compose.yml

@@ -1,45 +1,21 @@
-services:
-  db:
-    image: postgres:16-alpine
-    restart: unless-stopped
-    environment:
-      POSTGRES_USER: ${POSTGRES_USER}
-      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
-      POSTGRES_DB: ${POSTGRES_DB}
-    ports:
-      - "5432:5432"
-    volumes:
-      - db_data:/var/lib/postgresql/data
-    healthcheck:
-      test: ["CMD-SHELL", "pg_isready -U ${POSTGRES_USER}"]
-      interval: 10s
-      timeout: 5s
-      retries: 10
-
-  api:
-    build:
-      context: ../..
-      dockerfile: apps/api/Dockerfile
-    restart: unless-stopped
+services:
+  api:
+    build:
+      context: ../..
+      dockerfile: apps/api/Dockerfile
+    restart: unless-stopped
     environment:
       PORT: ${PORT}
       API_PREFIX: ${API_PREFIX}
-      DATABASE_URL: ${DATABASE_URL}
       I18N_DEFAULT_LANG: ${I18N_DEFAULT_LANG}
       I18N_FALLBACK_LANG: ${I18N_FALLBACK_LANG}
-    depends_on:
-      db:
-        condition: service_healthy
-
-  nginx:
-    build:
-      context: ../..
-      dockerfile: infra/docker/nginx.Dockerfile
-    restart: unless-stopped
-    depends_on:
-      - api
-    ports:
-      - "8080:80"
-
-volumes:
-  db_data:
+
+  caddy:
+    build:
+      context: ../..
+      dockerfile: infra/docker/caddy.Dockerfile
+    restart: unless-stopped
+    depends_on:
+      - api
+    ports:
+      - "8080:80"

package/templates/base/package.json

@@ -3,15 +3,18 @@
   "version": "0.1.0",
   "private": true,
   "packageManager": "pnpm@10.0.0",
-  "scripts": {
-    "dev": "pnpm --parallel --filter @forgeon/api --filter @forgeon/web dev",
-    "build": "pnpm -r build",
-    "postinstall": "pnpm --filter @forgeon/api prisma:generate",
-    "create:forgeon": "node scripts/create-forgeon.mjs",
-    "docker:up": "docker compose --env-file infra/docker/.env.example -f infra/docker/compose.yml up --build",
-    "docker:down": "docker compose -f infra/docker/compose.yml down -v"
-  },
-  "pnpm": {
+  "scripts": {
+    "dev": "pnpm --parallel --filter @forgeon/api --filter @forgeon/web dev",
+    "build": "pnpm -r build",
+    "forgeon:sync-integrations": "node scripts/forgeon-sync-integrations.mjs",
+    "create:forgeon": "node scripts/create-forgeon.mjs",
+    "docker:up": "docker compose --env-file infra/docker/.env.example -f infra/docker/compose.yml up --build",
+    "docker:down": "docker compose -f infra/docker/compose.yml down -v"
+  },
+  "devDependencies": {
+    "ts-morph": "^24.0.0"
+  },
+  "pnpm": {
     "onlyBuiltDependencies": [
       "@nestjs/core",
       "@prisma/client",

package/templates/base/scripts/forgeon-sync-integrations.mjs

@@ -0,0 +1,399 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { Project, QuoteKind } from 'ts-morph';
+
+function hasAnyImport(sourceFile, moduleSpecifier) {
+  return sourceFile.getImportDeclarations().some((item) => item.getModuleSpecifierValue() === moduleSpecifier);
+}
+
+function ensureNamedImports(sourceFile, moduleSpecifier, names) {
+  const declaration = sourceFile
+    .getImportDeclarations()
+    .find((item) => item.getModuleSpecifierValue() === moduleSpecifier);
+
+  if (!declaration) {
+    sourceFile.addImportDeclaration({
+      moduleSpecifier,
+      namedImports: [...names].sort(),
+    });
+    return;
+  }
+
+  const existing = new Set(declaration.getNamedImports().map((item) => item.getName()));
+  for (const name of names) {
+    if (!existing.has(name)) {
+      declaration.addNamedImport(name);
+    }
+  }
+}
+
+function hasDecorator(node, decoratorName) {
+  return node.getDecorators().some((item) => item.getName() === decoratorName);
+}
+
+function addDecoratorIfMissing(node, decoratorName, args = []) {
+  if (hasDecorator(node, decoratorName)) {
+    return false;
+  }
+  node.addDecorator({
+    name: decoratorName,
+    arguments: args,
+  });
+  return true;
+}
+
+function syncJwtSwagger({ rootDir, changedFiles }) {
+  const controllerPath = path.join(
+    rootDir,
+    'packages',
+    'auth-api',
+    'src',
+    'auth.controller.ts',
+  );
+  const loginDtoPath = path.join(rootDir, 'packages', 'auth-api', 'src', 'dto', 'login.dto.ts');
+  const refreshDtoPath = path.join(rootDir, 'packages', 'auth-api', 'src', 'dto', 'refresh.dto.ts');
+
+  if (!fs.existsSync(controllerPath) || !fs.existsSync(loginDtoPath) || !fs.existsSync(refreshDtoPath)) {
+    return { applied: false, reason: 'jwt-auth source files are missing' };
+  }
+
+  const project = new Project({
+    manipulationSettings: { quoteKind: QuoteKind.Single },
+    skipAddingFilesFromTsConfig: true,
+  });
+
+  const controller = project.addSourceFileAtPath(controllerPath);
+  const loginDto = project.addSourceFileAtPath(loginDtoPath);
+  const refreshDto = project.addSourceFileAtPath(refreshDtoPath);
+
+  const controllerDecorators = [
+    'ApiBearerAuth',
+    'ApiBody',
+    'ApiOkResponse',
+    'ApiOperation',
+    'ApiTags',
+    'ApiUnauthorizedResponse',
+  ];
+  const dtoDecorators = ['ApiProperty'];
+
+  ensureNamedImports(controller, '@nestjs/swagger', controllerDecorators);
+  ensureNamedImports(loginDto, '@nestjs/swagger', dtoDecorators);
+  ensureNamedImports(refreshDto, '@nestjs/swagger', dtoDecorators);
+
+  const authController = controller.getClass('AuthController');
+  if (!authController) {
+    return { applied: false, reason: 'AuthController not found' };
+  }
+
+  addDecoratorIfMissing(authController, 'ApiTags', ["'auth'"]);
+
+  const loginMethod = authController.getMethod('login');
+  const refreshMethod = authController.getMethod('refresh');
+  const logoutMethod = authController.getMethod('logout');
+  const meMethod = authController.getMethod('me');
+
+  if (loginMethod) {
+    addDecoratorIfMissing(loginMethod, 'ApiOperation', ["{ summary: 'Authenticate demo user' }"]);
+    addDecoratorIfMissing(loginMethod, 'ApiBody', ['{ type: LoginDto }']);
+    addDecoratorIfMissing(loginMethod, 'ApiOkResponse', ["{ description: 'JWT token pair' }"]);
+    addDecoratorIfMissing(loginMethod, 'ApiUnauthorizedResponse', ["{ description: 'Invalid credentials' }"]);
+  }
+
+  if (refreshMethod) {
+    addDecoratorIfMissing(refreshMethod, 'ApiOperation', ["{ summary: 'Refresh access token' }"]);
+    addDecoratorIfMissing(refreshMethod, 'ApiBody', ['{ type: RefreshDto }']);
+    addDecoratorIfMissing(refreshMethod, 'ApiOkResponse', ["{ description: 'New JWT token pair' }"]);
+    addDecoratorIfMissing(refreshMethod, 'ApiUnauthorizedResponse', [
+      "{ description: 'Refresh token is invalid or expired' }",
+    ]);
+  }
+
+  if (logoutMethod) {
+    addDecoratorIfMissing(logoutMethod, 'ApiBearerAuth');
+    addDecoratorIfMissing(logoutMethod, 'ApiOperation', ["{ summary: 'Logout and clear refresh token state' }"]);
+    addDecoratorIfMissing(logoutMethod, 'ApiOkResponse', ["{ description: 'Logout accepted' }"]);
+  }
+
+  if (meMethod) {
+    addDecoratorIfMissing(meMethod, 'ApiBearerAuth');
+    addDecoratorIfMissing(meMethod, 'ApiOperation', ["{ summary: 'Get current authenticated user' }"]);
+    addDecoratorIfMissing(meMethod, 'ApiOkResponse', ["{ description: 'Current user payload' }"]);
+  }
+
+  const loginDtoClass = loginDto.getClass('LoginDto');
+  if (loginDtoClass) {
+    const emailProp = loginDtoClass.getProperty('email');
+    const passwordProp = loginDtoClass.getProperty('password');
+    if (emailProp) {
+      addDecoratorIfMissing(emailProp, 'ApiProperty', [
+        "{ example: 'demo@forgeon.local', description: 'Demo account email' }",
+      ]);
+    }
+    if (passwordProp) {
+      addDecoratorIfMissing(passwordProp, 'ApiProperty', [
+        "{ example: 'forgeon-demo-password', description: 'Demo account password' }",
+      ]);
+    }
+  }
+
+  const refreshDtoClass = refreshDto.getClass('RefreshDto');
+  if (refreshDtoClass) {
+    const tokenProp = refreshDtoClass.getProperty('refreshToken');
+    if (tokenProp) {
+      addDecoratorIfMissing(tokenProp, 'ApiProperty', [
+        "{ example: 'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9...', description: 'Refresh token' }",
+      ]);
+    }
+  }
+
+  project.saveSync();
+  changedFiles.add(controllerPath);
+  changedFiles.add(loginDtoPath);
+  changedFiles.add(refreshDtoPath);
+
+  return { applied: true };
+}
+
+const PRISMA_AUTH_STORE_CONTENT = `import {
+  AuthRefreshTokenStore,
+} from '@forgeon/auth-api';
+import { PrismaService } from '@forgeon/db-prisma';
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class PrismaAuthRefreshTokenStore implements AuthRefreshTokenStore {
+  readonly kind = 'prisma';
+
+  constructor(private readonly prisma: PrismaService) {}
+
+  async saveRefreshTokenHash(subject: string, hash: string): Promise<void> {
+    await this.prisma.user.upsert({
+      where: { email: subject },
+      create: { email: subject, refreshTokenHash: hash },
+      update: { refreshTokenHash: hash },
+      select: { id: true },
+    });
+  }
+
+  async getRefreshTokenHash(subject: string): Promise<string | null> {
+    const user = await this.prisma.user.findUnique({
+      where: { email: subject },
+      select: { refreshTokenHash: true },
+    });
+    return user?.refreshTokenHash ?? null;
+  }
+
+  async removeRefreshTokenHash(subject: string): Promise<void> {
+    await this.prisma.user.updateMany({
+      where: { email: subject },
+      data: { refreshTokenHash: null },
+    });
+  }
+}
+`;
+
+const PRISMA_AUTH_MIGRATION_CONTENT = `-- AlterTable
+ALTER TABLE "User"
+ADD COLUMN "refreshTokenHash" TEXT;
+`;
+
+function syncJwtDbPrisma({ rootDir, changedFiles }) {
+  const appModulePath = path.join(rootDir, 'apps', 'api', 'src', 'app.module.ts');
+  const schemaPath = path.join(rootDir, 'apps', 'api', 'prisma', 'schema.prisma');
+  const storePath = path.join(rootDir, 'apps', 'api', 'src', 'auth', 'prisma-auth-refresh-token.store.ts');
+  const migrationPath = path.join(
+    rootDir,
+    'apps',
+    'api',
+    'prisma',
+    'migrations',
+    '0002_auth_refresh_token_hash',
+    'migration.sql',
+  );
+  const readmePath = path.join(rootDir, 'README.md');
+
+  if (!fs.existsSync(appModulePath) || !fs.existsSync(schemaPath)) {
+    return { applied: false, reason: 'app module or prisma schema is missing' };
+  }
+
+  let touched = false;
+
+  if (!fs.existsSync(storePath)) {
+    fs.mkdirSync(path.dirname(storePath), { recursive: true });
+    fs.writeFileSync(storePath, PRISMA_AUTH_STORE_CONTENT, 'utf8');
+    changedFiles.add(storePath);
+    touched = true;
+  }
+
+  let appModule = fs.readFileSync(appModulePath, 'utf8').replace(/\r\n/g, '\n');
+  const originalAppModule = appModule;
+
+  if (appModule.includes("import { AUTH_REFRESH_TOKEN_STORE,")) {
+    // already includes token symbol
+  } else {
+    appModule = appModule.replace(
+      /import\s*\{([^}]*)\}\s*from '@forgeon\/auth-api';/m,
+      (full, namesRaw) => {
+        const names = namesRaw
+          .split(',')
+          .map((item) => item.trim())
+          .filter(Boolean);
+        if (!names.includes('AUTH_REFRESH_TOKEN_STORE')) {
+          names.unshift('AUTH_REFRESH_TOKEN_STORE');
+        }
+        return `import { ${names.join(', ')} } from '@forgeon/auth-api';`;
+      },
+    );
+  }
+
+  const storeImportLine = "import { PrismaAuthRefreshTokenStore } from './auth/prisma-auth-refresh-token.store';";
+  if (!appModule.includes(storeImportLine)) {
+    const controllerImport = "import { HealthController } from './health/health.controller';";
+    if (appModule.includes(controllerImport)) {
+      appModule = appModule.replace(controllerImport, `${storeImportLine}\n${controllerImport}`);
+    } else {
+      appModule = `${appModule.trimEnd()}\n${storeImportLine}\n`;
+    }
+  }
+
+  const authRegisterWithPrisma = `ForgeonAuthModule.register({
+      imports: [DbPrismaModule],
+      refreshTokenStoreProvider: {
+        provide: AUTH_REFRESH_TOKEN_STORE,
+        useClass: PrismaAuthRefreshTokenStore,
+      },
+    }),`;
+
+  if (!appModule.includes('refreshTokenStoreProvider')) {
+    if (/ForgeonAuthModule\.register\(\s*\),/.test(appModule)) {
+      appModule = appModule.replace(/ForgeonAuthModule\.register\(\s*\),/, authRegisterWithPrisma);
+    } else if (/ForgeonAuthModule\.register\(\{[\s\S]*?\}\),/m.test(appModule)) {
+      appModule = appModule.replace(/ForgeonAuthModule\.register\(\{[\s\S]*?\}\),/m, authRegisterWithPrisma);
+    }
+  }
+
+  if (appModule !== originalAppModule) {
+    fs.writeFileSync(appModulePath, `${appModule.trimEnd()}\n`, 'utf8');
+    changedFiles.add(appModulePath);
+    touched = true;
+  }
+
+  let schema = fs.readFileSync(schemaPath, 'utf8').replace(/\r\n/g, '\n');
+  const originalSchema = schema;
+  if (!schema.includes('refreshTokenHash')) {
+    schema = schema.replace(
+      /email\s+String\s+@unique/g,
+      'email            String   @unique\n  refreshTokenHash String?',
+    );
+  }
+  if (schema !== originalSchema) {
+    fs.writeFileSync(schemaPath, `${schema.trimEnd()}\n`, 'utf8');
+    changedFiles.add(schemaPath);
+    touched = true;
+  }
+
+  if (!fs.existsSync(migrationPath)) {
+    fs.mkdirSync(path.dirname(migrationPath), { recursive: true });
+    fs.writeFileSync(migrationPath, PRISMA_AUTH_MIGRATION_CONTENT, 'utf8');
+    changedFiles.add(migrationPath);
+    touched = true;
+  }
+
+  if (fs.existsSync(readmePath)) {
+    let readme = fs.readFileSync(readmePath, 'utf8').replace(/\r\n/g, '\n');
+    const originalReadme = readme;
+    readme = readme.replace(
+      '- refresh token persistence: disabled (no supported DB adapter found)',
+      '- refresh token persistence: enabled (`db-prisma` adapter)',
+    );
+    readme = readme.replace(
+      /- to enable persistence later:[\s\S]*?2\. run `create-forgeon add jwt-auth --project \.` again to auto-wire the adapter\./m,
+      '- migration: `apps/api/prisma/migrations/0002_auth_refresh_token_hash`',
+    );
+    if (readme !== originalReadme) {
+      fs.writeFileSync(readmePath, `${readme.trimEnd()}\n`, 'utf8');
+      changedFiles.add(readmePath);
+      touched = true;
+    }
+  }
+
+  if (!touched) {
+    return { applied: false, reason: 'already synced' };
+  }
+  return { applied: true };
+}
+
+function detectModules(rootDir) {
+  const appModulePath = path.join(rootDir, 'apps', 'api', 'src', 'app.module.ts');
+  const appModuleText = fs.existsSync(appModulePath) ? fs.readFileSync(appModulePath, 'utf8') : '';
+
+  return {
+    swagger:
+      fs.existsSync(path.join(rootDir, 'packages', 'swagger', 'package.json')) ||
+      appModuleText.includes("from '@forgeon/swagger'"),
+    jwtAuth:
+      fs.existsSync(path.join(rootDir, 'packages', 'auth-api', 'package.json')) ||
+      appModuleText.includes("from '@forgeon/auth-api'"),
+    dbPrisma:
+      fs.existsSync(path.join(rootDir, 'packages', 'db-prisma', 'package.json')) ||
+      appModuleText.includes("from '@forgeon/db-prisma'"),
+  };
+}
+
+function run() {
+  const rootDir = process.cwd();
+  const changedFiles = new Set();
+  const detected = detectModules(rootDir);
+  const summary = [];
+
+  if (detected.swagger && detected.jwtAuth) {
+    summary.push({
+      feature: 'jwt-auth + swagger',
+      result: syncJwtSwagger({ rootDir, changedFiles }),
+    });
+  } else {
+    summary.push({
+      feature: 'jwt-auth + swagger',
+      result: { applied: false, reason: 'required modules are not both installed' },
+    });
+  }
+
+  if (detected.jwtAuth && detected.dbPrisma) {
+    summary.push({
+      feature: 'jwt-auth + db-prisma',
+      result: syncJwtDbPrisma({ rootDir, changedFiles }),
+    });
+  } else {
+    summary.push({
+      feature: 'jwt-auth + db-prisma',
+      result: { applied: false, reason: 'required modules are not both installed' },
+    });
+  }
+
+  console.log('[forgeon:sync-integrations] done');
+  for (const item of summary) {
+    if (item.result.applied) {
+      console.log(`- ${item.feature}: applied`);
+    } else {
+      console.log(`- ${item.feature}: skipped (${item.result.reason})`);
+    }
+  }
+
+  if (changedFiles.size > 0) {
+    console.log('- changed files:');
+    for (const filePath of [...changedFiles].sort()) {
+      const relative = path.relative(rootDir, filePath);
+      console.log(`  - ${relative}`);
+    }
+  }
+}
+
+const isMain =
+  process.argv[1] &&
+  path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+
+if (isMain) {
+  run();
+}

package/templates/docs-fragments/AI_ARCHITECTURE/20_env_base.md

@@ -2,7 +2,6 @@
 
 - `PORT` - API port (default 3000)
 - `API_PREFIX` - global API prefix (default `api`)
-- `DATABASE_URL` - DB connection string for Prisma
 
 ## Config Strategy
 

package/templates/docs-fragments/AI_ARCHITECTURE/20b_env_db_prisma.md

@@ -0,0 +1 @@
+- `DATABASE_URL` - DB connection string for Prisma

package/templates/docs-fragments/AI_ARCHITECTURE/30_default_db.md

@@ -4,6 +4,6 @@ Current default stack is `{{DB_LABEL}}`.
 
 - Prisma schema and migrations live in `apps/api/prisma`
 - DB access is encapsulated via `DbPrismaModule` in `@forgeon/db-prisma`
-- `db-prisma` is currently default-applied during scaffold generation.
-- Future direction: this DB layer may be extracted into an explicit add-module/preset and optionally exposed via CLI flag(s).
+- `db-prisma` is a full add-module and is enabled by default during scaffold generation (`db-prisma=true`).
+- It can be disabled at generation time and added later via `create-forgeon add db-prisma --project .`.
 - Additional DB presets are intentionally out of scope for the current milestone.

package/templates/docs-fragments/AI_ARCHITECTURE/30_default_db_none.md

@@ -0,0 +1,7 @@
+## Default DB Stack
+
+This preset was generated without `db-prisma`.
+
+- API runs in DB-neutral mode.
+- Add Prisma later via: `create-forgeon add db-prisma --project .`
+- Future DB presets remain out of scope for this milestone.

package/templates/docs-fragments/AI_PROJECT/20_structure_base.md

@@ -3,4 +3,3 @@
 - `apps/api` - NestJS backend
 - `apps/web` - React frontend (`{{FRONTEND_LABEL}}`, fixed)
 - `packages/core` - shared backend core package (`core-config`, `core-errors`, `core-validation`)
-- `packages/db-prisma` - default DB module (`DbPrismaModule`, Prisma service + config)

package/templates/docs-fragments/AI_PROJECT/20b_structure_db_none.md

@@ -0,0 +1,2 @@
+- `db-prisma` is not installed in this preset (`db-prisma=false`)
+- add later with: `create-forgeon add db-prisma --project .`

package/templates/docs-fragments/AI_PROJECT/20b_structure_db_prisma.md

@@ -0,0 +1 @@
+- `packages/db-prisma` - DB module (`DbPrismaModule`, Prisma service + config)

package/templates/docs-fragments/README/10_stack.md

@@ -1,8 +1,8 @@
 ## Generated Preset
 
-- Stack: `NestJS + React + Prisma/Postgres + Docker`
-- Frontend: `{{FRONTEND_LABEL}}` (fixed)
-- Database: `{{DB_LABEL}}` (fixed)
-- i18n: `{{I18N_STATUS}}`
+- Stack: `NestJS + React + Docker`
+- Frontend: `{{FRONTEND_LABEL}}` (fixed)
+- Database: `{{DB_LABEL}}` (`db-prisma`: `{{DB_PRISMA_STATUS}}`)
+- i18n: `{{I18N_STATUS}}`
 - Docker/infra: `enabled` (fixed)
 - Reverse proxy: `{{PROXY_LABEL}}` (`caddy|nginx|none`)

package/templates/docs-fragments/README/21_quick_start_dev_no_db.md

@@ -0,0 +1,6 @@
+2. No DB module is enabled by default in this preset.
+   - API/web start without database dependencies.
+   - Add Prisma later when needed:
+     ```bash
+     npx create-forgeon@latest add db-prisma --project .
+     ```

package/templates/module-presets/i18n/apps/web/src/App.tsx

@@ -17,7 +17,6 @@ export default function App() {
   const [healthResult, setHealthResult] = useState<ProbeResult | null>(null);
   const [errorProbeResult, setErrorProbeResult] = useState<ProbeResult | null>(null);
   const [validationProbeResult, setValidationProbeResult] = useState<ProbeResult | null>(null);
-  const [dbProbeResult, setDbProbeResult] = useState<ProbeResult | null>(null);
   const [networkError, setNetworkError] = useState<string | null>(null);
 
   const changeLocale = (nextLocale: I18nLocale) => {
@@ -93,14 +92,10 @@ export default function App() {
         <button onClick={() => runProbe(setValidationProbeResult, '/health/validation')}>
           Check validation (expect 400)
         </button>
-        <button onClick={() => runProbe(setDbProbeResult, '/health/db', { method: 'POST' })}>
-          Check database (create user)
-        </button>
       </div>
       {renderResult('Health response', healthResult)}
       {renderResult('Error probe response', errorProbeResult)}
       {renderResult('Validation probe response', validationProbeResult)}
-      {renderResult('DB probe response', dbProbeResult)}
       {networkError ? <p className="error">{networkError}</p> : null}
     </main>
   );