create-forgeon 0.0.1 → 0.0.2

package/README.md

@@ -5,7 +5,14 @@ CLI package for generating Forgeon fullstack monorepo projects.
 ## Usage
 
 ```bash
-npx create-forgeon@latest my-app --frontend react --db prisma --i18n true --docker true
+npx create-forgeon@latest my-app --frontend react --db prisma --i18n true --docker true --proxy nginx
 ```
 
-If flags are omitted, the CLI asks interactive questions.
+If flags are omitted, the CLI asks interactive questions.
+
+## Notes
+
+- Implemented presets right now:
+  - `--frontend react`
+  - `--db prisma`
+- `--proxy` works only when `--docker true`

package/bin/create-forgeon.mjs

@@ -6,8 +6,9 @@ import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { stdin as input, stdout as output } from 'node:process';
 
-const SUPPORTED_FRONTENDS = ['react', 'angular'];
-const SUPPORTED_DBS = ['prisma'];
+const IMPLEMENTED_FRONTENDS = ['react'];
+const IMPLEMENTED_DBS = ['prisma'];
+const SUPPORTED_PROXIES = ['nginx', 'caddy'];
 
 function printHelp() {
   console.log(`create-forgeon
@@ -16,10 +17,11 @@ Usage:
   npx create-forgeon@latest <project-name> [options]
 
 Options:
-  --frontend <react|angular>   Frontend preset (default: react)
-  --db <prisma>                DB preset (default: prisma)
+  --frontend <react|angular>   Frontend preset (implemented: react)
+  --db <prisma>                DB preset (implemented: prisma)
   --i18n <true|false>          Enable i18n (default: true)
-  --docker <true|false>        Include docker/infra files (default: true)
+  --docker <true|false>        Include Docker/infra files (default: true)
+  --proxy <nginx|caddy>        Reverse proxy preset when docker=true (default: nginx)
   --install                    Run pnpm install after generation
   -y, --yes                    Skip prompts and use defaults
   -h, --help                   Show this help
@@ -38,11 +40,13 @@ function parseBoolean(value, fallback) {
 }
 
 function toKebabCase(value) {
-  return value
-    .trim()
-    .toLowerCase()
-    .replace(/[^a-z0-9]+/g, '-')
-    .replace(/^-+|-+$/g, '') || 'forgeon-app';
+  return (
+    value
+      .trim()
+      .toLowerCase()
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '') || 'forgeon-app'
+  );
 }
 
 function copyRecursive(source, destination) {
@@ -63,6 +67,331 @@ function writeJson(filePath, data) {
   fs.writeFileSync(filePath, `${JSON.stringify(data, null, 2)}\n`, 'utf8');
 }
 
+function escapeRegex(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function removeMarkdownSection(content, title) {
+  const pattern = new RegExp(`\\n## ${escapeRegex(title)}[\\s\\S]*?(?=\\n## |$)`, 'm');
+  return content.replace(pattern, '');
+}
+
+function removeIfExists(targetPath) {
+  if (fs.existsSync(targetPath)) {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+  }
+}
+
+function patchReadme(targetRoot, { dockerEnabled, i18nEnabled }) {
+  const readmePath = path.join(targetRoot, 'README.md');
+  if (!fs.existsSync(readmePath)) return;
+
+  let content = fs.readFileSync(readmePath, 'utf8').replace(/\r\n/g, '\n');
+
+  if (!dockerEnabled) {
+    content = removeMarkdownSection(content, 'Quick Start (Docker)');
+    content = removeMarkdownSection(content, 'Prisma In Docker Start');
+    content = content.replace(
+      /2\. Start local Postgres \(Docker\):[\s\S]*?```\n3\. Run API \+ web in dev mode:/m,
+      '2. Ensure PostgreSQL is running locally and configure `DATABASE_URL` in `apps/api/.env`.\n3. Run API + web in dev mode:',
+    );
+    content = content.replace(
+      /```bash\ndocker compose[\s\S]*?Open `http:\/\/localhost:8080`\.\n?/m,
+      '',
+    );
+    content = content.replace(
+      /API container starts with:[\s\S]*?This keeps container startup production-like while still simple\.\n?/m,
+      '',
+    );
+  }
+
+  if (!i18nEnabled) {
+    content = removeMarkdownSection(content, 'i18n Toggle');
+    content = content.replace(
+      'optional i18n (enabled by default), and ',
+      '',
+    );
+    content = content.replace(
+      /Set in env:[\s\S]*?When `I18N_ENABLED=false`, API runs without loading i18n module\.\n?/m,
+      '',
+    );
+  }
+
+  content = content.replace(/\n{3,}/g, '\n\n');
+  fs.writeFileSync(readmePath, content.trimEnd() + '\n', 'utf8');
+}
+
+function patchAiDocs(targetRoot, { dockerEnabled, i18nEnabled }) {
+  const projectDoc = path.join(targetRoot, 'docs', 'AI', 'PROJECT.md');
+  if (fs.existsSync(projectDoc)) {
+    let content = fs.readFileSync(projectDoc, 'utf8').replace(/\r\n/g, '\n');
+    if (!i18nEnabled) {
+      content = content
+        .replace(/^\- `packages\/i18n`.*\r?\n/gm, '')
+        .replace(/^\- `resources\/i18n`.*\r?\n/gm, '');
+    }
+    if (!dockerEnabled) {
+      content = content.replace(
+        /(^|\n)### Docker mode\n[\s\S]*?(?=\n### |\n## |$)/,
+        '\n',
+      );
+      content = content.replace(/^\- `infra`.*\r?\n/gm, '');
+    }
+    content = content.replace(/\n{3,}/g, '\n\n');
+    fs.writeFileSync(projectDoc, content.trimEnd() + '\n', 'utf8');
+  }
+
+  const archDoc = path.join(targetRoot, 'docs', 'AI', 'ARCHITECTURE.md');
+  if (fs.existsSync(archDoc)) {
+    let content = fs.readFileSync(archDoc, 'utf8').replace(/\r\n/g, '\n');
+    if (!i18nEnabled) {
+      content = content
+        .replace(/^\- `I18N_ENABLED`.*\r?\n/gm, '')
+        .replace(/^\- `I18N_DEFAULT_LANG`.*\r?\n/gm, '')
+        .replace(/^\- `I18N_FALLBACK_LANG`.*\r?\n/gm, '')
+        .replace(/^\- `resources\/\*`.*\r?\n/gm, '');
+    }
+    if (!dockerEnabled) {
+      content = content.replace(/^\- `infra\/\*`.*\r?\n/gm, '');
+      content = content.replace(
+        /## Future DB Presets \(Not Implemented Yet\)[\s\S]*?(?=\n## |$)/,
+        `## Future DB Presets (Not Implemented Yet)
+
+A future preset can switch DB by:
+1. Replacing \`PrismaModule\` with another DB module package (for example Mongo package).
+2. Updating \`DATABASE_URL\` and related env keys.
+3. Keeping app-level services dependent only on repository/data-access abstractions.
+`,
+      );
+    }
+    content = content.replace(/\n{3,}/g, '\n\n');
+    fs.writeFileSync(archDoc, content.trimEnd() + '\n', 'utf8');
+  }
+}
+
+function applyProxyPreset(targetRoot, proxy) {
+  const dockerDir = path.join(targetRoot, 'infra', 'docker');
+  const composeTarget = path.join(dockerDir, 'compose.yml');
+  const composeSource = path.join(dockerDir, `compose.${proxy}.yml`);
+
+  if (!fs.existsSync(composeSource)) {
+    throw new Error(`Missing proxy compose preset: ${composeSource}`);
+  }
+
+  fs.copyFileSync(composeSource, composeTarget);
+
+  removeIfExists(path.join(dockerDir, 'compose.nginx.yml'));
+  removeIfExists(path.join(dockerDir, 'compose.caddy.yml'));
+
+  if (proxy === 'nginx') {
+    removeIfExists(path.join(dockerDir, 'caddy.Dockerfile'));
+    removeIfExists(path.join(targetRoot, 'infra', 'caddy'));
+  } else if (proxy === 'caddy') {
+    removeIfExists(path.join(dockerDir, 'nginx.Dockerfile'));
+    removeIfExists(path.join(targetRoot, 'infra', 'nginx'));
+  }
+}
+
+function applyI18nDisabled(targetRoot) {
+  removeIfExists(path.join(targetRoot, 'packages', 'i18n'));
+  removeIfExists(path.join(targetRoot, 'resources', 'i18n'));
+
+  const apiPackagePath = path.join(targetRoot, 'apps', 'api', 'package.json');
+  if (fs.existsSync(apiPackagePath)) {
+    const apiPackage = JSON.parse(fs.readFileSync(apiPackagePath, 'utf8'));
+
+    if (apiPackage.scripts) {
+      delete apiPackage.scripts.predev;
+    }
+
+    if (apiPackage.dependencies) {
+      delete apiPackage.dependencies['@forgeon/i18n'];
+      delete apiPackage.dependencies['nestjs-i18n'];
+    }
+
+    writeJson(apiPackagePath, apiPackage);
+  }
+
+  const apiDockerfile = path.join(targetRoot, 'apps', 'api', 'Dockerfile');
+  if (fs.existsSync(apiDockerfile)) {
+    let content = fs.readFileSync(apiDockerfile, 'utf8');
+    content = content
+      .replace(/^COPY packages\/i18n\/package\.json packages\/i18n\/package\.json\r?\n/gm, '')
+      .replace(/^COPY packages\/i18n packages\/i18n\r?\n/gm, '')
+      .replace(/^RUN pnpm --filter @forgeon\/i18n build\r?\n/gm, '');
+    fs.writeFileSync(apiDockerfile, content, 'utf8');
+  }
+
+  const appModulePath = path.join(targetRoot, 'apps', 'api', 'src', 'app.module.ts');
+  fs.writeFileSync(
+    appModulePath,
+    `import { Module } from '@nestjs/common';
+import { ConfigModule } from '@nestjs/config';
+import appConfig from './config/app.config';
+import { HealthController } from './health/health.controller';
+import { PrismaModule } from './prisma/prisma.module';
+import { AppExceptionFilter } from './common/filters/app-exception.filter';
+
+@Module({
+  imports: [
+    ConfigModule.forRoot({
+      isGlobal: true,
+      load: [appConfig],
+      envFilePath: '.env',
+    }),
+    PrismaModule,
+  ],
+  controllers: [HealthController],
+  providers: [AppExceptionFilter],
+})
+export class AppModule {}
+`,
+    'utf8',
+  );
+
+  const healthControllerPath = path.join(
+    targetRoot,
+    'apps',
+    'api',
+    'src',
+    'health',
+    'health.controller.ts',
+  );
+  fs.writeFileSync(
+    healthControllerPath,
+    `import { Controller, Get, Query } from '@nestjs/common';
+import { EchoQueryDto } from '../common/dto/echo-query.dto';
+
+@Controller('health')
+export class HealthController {
+  @Get()
+  getHealth(@Query('lang') _lang?: string) {
+    return {
+      status: 'ok',
+      message: 'OK',
+    };
+  }
+
+  @Get('echo')
+  getEcho(@Query() query: EchoQueryDto) {
+    return { value: query.value };
+  }
+}
+`,
+    'utf8',
+  );
+
+  const filterPath = path.join(
+    targetRoot,
+    'apps',
+    'api',
+    'src',
+    'common',
+    'filters',
+    'app-exception.filter.ts',
+  );
+  fs.writeFileSync(
+    filterPath,
+    `import {
+  ArgumentsHost,
+  Catch,
+  ExceptionFilter,
+  HttpException,
+  HttpStatus,
+  Injectable,
+} from '@nestjs/common';
+import { Response } from 'express';
+
+@Injectable()
+@Catch()
+export class AppExceptionFilter implements ExceptionFilter {
+  catch(exception: unknown, host: ArgumentsHost): void {
+    const context = host.switchToHttp();
+    const response = context.getResponse<Response>();
+
+    const status =
+      exception instanceof HttpException
+        ? exception.getStatus()
+        : HttpStatus.INTERNAL_SERVER_ERROR;
+
+    const payload =
+      exception instanceof HttpException
+        ? exception.getResponse()
+        : { message: 'Internal server error' };
+
+    const message =
+      typeof payload === 'object' && payload !== null && 'message' in payload
+        ? Array.isArray((payload as { message?: unknown }).message)
+          ? String((payload as { message: unknown[] }).message[0] ?? 'Internal server error')
+          : String((payload as { message?: unknown }).message ?? 'Internal server error')
+        : typeof payload === 'string'
+          ? payload
+          : 'Internal server error';
+
+    response.status(status).json({
+      error: {
+        code: this.resolveCode(status),
+        message,
+      },
+    });
+  }
+
+  private resolveCode(status: number): string {
+    switch (status) {
+      case HttpStatus.BAD_REQUEST:
+        return 'validation_error';
+      case HttpStatus.UNAUTHORIZED:
+        return 'unauthorized';
+      case HttpStatus.FORBIDDEN:
+        return 'forbidden';
+      case HttpStatus.NOT_FOUND:
+        return 'not_found';
+      case HttpStatus.CONFLICT:
+        return 'conflict';
+      default:
+        return 'internal_error';
+    }
+  }
+}
+`,
+    'utf8',
+  );
+
+  const appConfigPath = path.join(targetRoot, 'apps', 'api', 'src', 'config', 'app.config.ts');
+  fs.writeFileSync(
+    appConfigPath,
+    `import { registerAs } from '@nestjs/config';
+
+export default registerAs('app', () => ({
+  port: Number(process.env.PORT ?? 3000),
+}));
+`,
+    'utf8',
+  );
+}
+
+function patchDockerEnvForI18n(targetRoot, i18nEnabled) {
+  const dockerEnvPath = path.join(targetRoot, 'infra', 'docker', '.env.example');
+  if (fs.existsSync(dockerEnvPath) && !i18nEnabled) {
+    const content = fs
+      .readFileSync(dockerEnvPath, 'utf8')
+      .replace(/^I18N_ENABLED=.*\r?\n/gm, '')
+      .replace(/^I18N_DEFAULT_LANG=.*\r?\n/gm, '')
+      .replace(/^I18N_FALLBACK_LANG=.*\r?\n/gm, '');
+    fs.writeFileSync(dockerEnvPath, content.trimEnd() + '\n', 'utf8');
+  }
+
+  const composePath = path.join(targetRoot, 'infra', 'docker', 'compose.yml');
+  if (fs.existsSync(composePath) && !i18nEnabled) {
+    const content = fs
+      .readFileSync(composePath, 'utf8')
+      .replace(/^\s+I18N_ENABLED:.*\r?\n/gm, '')
+      .replace(/^\s+I18N_DEFAULT_LANG:.*\r?\n/gm, '')
+      .replace(/^\s+I18N_FALLBACK_LANG:.*\r?\n/gm, '');
+    fs.writeFileSync(composePath, content, 'utf8');
+  }
+}
+
 async function main() {
   const args = process.argv.slice(2);
   const options = {
@@ -71,6 +400,7 @@ async function main() {
     db: undefined,
     i18n: undefined,
     docker: undefined,
+    proxy: undefined,
     install: false,
     yes: false,
     help: false,
@@ -81,9 +411,7 @@ async function main() {
   for (let i = 0; i < args.length; i += 1) {
     const arg = args[i];
 
-    if (arg === '--') {
-      continue;
-    }
+    if (arg === '--') continue;
 
     if (arg === '-h' || arg === '--help') {
       options.help = true;
@@ -118,7 +446,7 @@ async function main() {
         i += 1;
       }
 
-      if (key in options) {
+      if (Object.prototype.hasOwnProperty.call(options, key)) {
         options[key] = value;
       }
 
@@ -161,6 +489,12 @@ async function main() {
       (await rl.question('Include Docker/infra (true/false) [true]: ')) || 'true';
   }
 
+  const dockerEnabledPre = parseBoolean(options.docker, true);
+  if (dockerEnabledPre && !options.yes && !options.proxy) {
+    options.proxy =
+      (await rl.question('Reverse proxy preset (nginx/caddy) [nginx]: ')) || 'nginx';
+  }
+
   await rl.close();
 
   if (!options.name || options.name.trim().length === 0) {
@@ -168,22 +502,27 @@ async function main() {
     process.exit(1);
   }
 
-  const frontendRaw = (options.frontend ?? 'react').toString().toLowerCase();
-  const dbRaw = (options.db ?? 'prisma').toString().toLowerCase();
+  const frontend = (options.frontend ?? 'react').toString().toLowerCase();
+  const db = (options.db ?? 'prisma').toString().toLowerCase();
   const i18nEnabled = parseBoolean(options.i18n, true);
   const dockerEnabled = parseBoolean(options.docker, true);
+  const proxy = dockerEnabled
+    ? (options.proxy ?? 'nginx').toString().toLowerCase()
+    : 'none';
 
-  const frontend = SUPPORTED_FRONTENDS.includes(frontendRaw) ? frontendRaw : 'react';
-  if (frontendRaw !== frontend) {
-    console.warn(`Unsupported frontend "${frontendRaw}". Falling back to "react".`);
+  if (!IMPLEMENTED_FRONTENDS.includes(frontend)) {
+    if (frontend === 'angular') {
+      throw new Error('Frontend preset "angular" is not implemented yet. Use --frontend react.');
+    }
+    throw new Error(`Unsupported frontend preset: ${frontend}`);
   }
-  if (frontend === 'angular') {
-    console.warn('Angular preset is planned, but not implemented yet. Falling back to React.');
+
+  if (!IMPLEMENTED_DBS.includes(db)) {
+    throw new Error(`Unsupported db preset: ${db}. Currently implemented: prisma.`);
   }
 
-  const db = SUPPORTED_DBS.includes(dbRaw) ? dbRaw : 'prisma';
-  if (dbRaw !== db) {
-    console.warn(`Unsupported db preset "${dbRaw}". Falling back to "prisma".`);
+  if (dockerEnabled && !SUPPORTED_PROXIES.includes(proxy)) {
+    throw new Error(`Unsupported proxy preset: ${proxy}. Use nginx or caddy.`);
   }
 
   const projectName = options.name.trim();
@@ -215,28 +554,34 @@ async function main() {
   writeJson(rootPackageJsonPath, rootPackageJson);
 
   if (!dockerEnabled) {
-    fs.rmSync(path.join(targetRoot, 'infra'), { recursive: true, force: true });
+    removeIfExists(path.join(targetRoot, 'infra'));
+    removeIfExists(path.join(targetRoot, 'apps', 'api', 'Dockerfile'));
+    removeIfExists(path.join(targetRoot, 'apps', 'web', 'Dockerfile'));
   } else {
-    const envExamplePath = path.join(targetRoot, 'infra', 'docker', '.env.example');
-    if (fs.existsSync(envExamplePath)) {
-      const current = fs.readFileSync(envExamplePath, 'utf8');
-      const next = current
-        .replace(/I18N_ENABLED=.*/g, `I18N_ENABLED=${i18nEnabled}`)
-        .replace(/I18N_DEFAULT_LANG=.*/g, 'I18N_DEFAULT_LANG=en')
-        .replace(/I18N_FALLBACK_LANG=.*/g, 'I18N_FALLBACK_LANG=en');
-      fs.writeFileSync(envExamplePath, next, 'utf8');
-    }
+    applyProxyPreset(targetRoot, proxy);
+    patchDockerEnvForI18n(targetRoot, i18nEnabled);
+  }
+
+  if (!i18nEnabled) {
+    applyI18nDisabled(targetRoot);
   }
 
   const apiEnvExamplePath = path.join(targetRoot, 'apps', 'api', '.env.example');
-  const apiEnv = [
+  const apiEnvLines = [
     'PORT=3000',
     'DATABASE_URL=postgresql://postgres:postgres@localhost:5432/app?schema=public',
-    `I18N_ENABLED=${i18nEnabled}`,
-    'I18N_DEFAULT_LANG=en',
-    'I18N_FALLBACK_LANG=en',
-  ].join('\n');
-  fs.writeFileSync(apiEnvExamplePath, `${apiEnv}\n`, 'utf8');
+  ];
+
+  if (i18nEnabled) {
+    apiEnvLines.push('I18N_ENABLED=true');
+    apiEnvLines.push('I18N_DEFAULT_LANG=en');
+    apiEnvLines.push('I18N_FALLBACK_LANG=en');
+  }
+
+  fs.writeFileSync(apiEnvExamplePath, `${apiEnvLines.join('\n')}\n`, 'utf8');
+
+  patchReadme(targetRoot, { dockerEnabled, i18nEnabled });
+  patchAiDocs(targetRoot, { dockerEnabled, i18nEnabled });
 
   if (parseBoolean(options.install, false)) {
     const pnpmCmd = process.platform === 'win32' ? 'pnpm.cmd' : 'pnpm';
@@ -257,9 +602,10 @@ async function main() {
   console.log(`- db: ${db}`);
   console.log(`- i18n: ${i18nEnabled}`);
   console.log(`- docker: ${dockerEnabled}`);
+  console.log(`- proxy: ${proxy}`);
 }
 
 main().catch((error) => {
   console.error(error instanceof Error ? error.message : error);
   process.exit(1);
-});
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-forgeon",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Forgeon project generator CLI",
   "license": "MIT",
   "author": "Forgeon",

package/templates/base/README.md

@@ -44,13 +44,4 @@ API container starts with:
 2. `node apps/api/dist/main.js`
 
 This keeps container startup production-like while still simple.
-
-## Generator Command
-
-Use:
-```bash
-pnpm create:forgeon -- --name my-app --frontend react --db prisma --i18n true
-```
-
-If flags are omitted, script asks questions interactively.
 

package/templates/base/docs/AI/PROJECT.md

@@ -10,7 +10,7 @@ A canonical fullstack monorepo scaffold intended to be reused as a project start
 - `apps/web` - frontend scaffold (default React + Vite + TS)
 - `packages/core` - shared backend core placeholder
 - `packages/i18n` - reusable nestjs-i18n integration package
-- `infra` - Docker Compose + Nginx
+- `infra` - Docker Compose + reverse proxy preset (nginx/caddy)
 - `resources/i18n` - translation dictionaries
 - `docs` - documentation and AI workflow prompts
 

package/templates/base/infra/caddy/Caddyfile

@@ -0,0 +1,11 @@
+:80 {
+  encode gzip zstd
+
+  handle /api/* {
+    reverse_proxy api:3000
+  }
+
+  root * /srv
+  try_files {path} /index.html
+  file_server
+}

package/templates/base/infra/docker/caddy.Dockerfile

@@ -0,0 +1,16 @@
+FROM node:20-alpine AS web-builder
+
+WORKDIR /app
+RUN corepack enable
+
+COPY package.json pnpm-workspace.yaml ./
+COPY apps/web/package.json apps/web/package.json
+RUN pnpm install --frozen-lockfile=false
+
+COPY apps/web apps/web
+WORKDIR /app/apps/web
+RUN pnpm build
+
+FROM caddy:2-alpine
+COPY infra/caddy/Caddyfile /etc/caddy/Caddyfile
+COPY --from=web-builder /app/apps/web/dist /srv

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

@@ -0,0 +1,45 @@
+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
+    environment:
+      PORT: ${PORT}
+      DATABASE_URL: ${DATABASE_URL}
+      I18N_ENABLED: ${I18N_ENABLED}
+      I18N_DEFAULT_LANG: ${I18N_DEFAULT_LANG}
+      I18N_FALLBACK_LANG: ${I18N_FALLBACK_LANG}
+    depends_on:
+      db:
+        condition: service_healthy
+
+  caddy:
+    build:
+      context: ../..
+      dockerfile: infra/docker/caddy.Dockerfile
+    restart: unless-stopped
+    depends_on:
+      - api
+    ports:
+      - "8080:80"
+
+volumes:
+  db_data:

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

@@ -0,0 +1,45 @@
+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
+    environment:
+      PORT: ${PORT}
+      DATABASE_URL: ${DATABASE_URL}
+      I18N_ENABLED: ${I18N_ENABLED}
+      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: