archforge-x 1.0.2 → 1.0.3

package/dist/generators/node/nestjs.js

@@ -0,0 +1,770 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestJSGenerator = void 0;
+const base_1 = require("../base");
+class NestJSGenerator extends base_1.BaseGenerator {
+    getGeneratorName() {
+        return "NestJS";
+    }
+    async generateProjectStructure(root, arch, options) {
+        const archStyle = options.architecture || "clean";
+        this.generateCommonFiles(root, options);
+        if (archStyle === "clean") {
+            this.generateCleanArchitecture(root, options);
+        }
+        else {
+            this.generateStandardArchitecture(root, options);
+        }
+        this.generateDocker(root, options);
+        this.generateCI(root, options);
+    }
+    generateCommonFiles(root, options) {
+        const projectName = options.projectName || "nestjs-app";
+        this.writeFile(root, "package.json", JSON.stringify({
+            name: projectName,
+            version: "0.0.1",
+            description: "",
+            author: "",
+            private: true,
+            license: "UNLICENSED",
+            scripts: {
+                "build": "nest build",
+                "format": "prettier --write \"src/**/*.ts\" \"test/**/*.ts\"",
+                "start": "nest start",
+                "start:dev": "nest start --watch",
+                "start:debug": "nest start --debug --watch",
+                "start:prod": "node dist/main",
+                "lint": "eslint \"{src,apps,libs,test}/**/*.ts\" --fix",
+                "test": "jest",
+                "test:watch": "jest --watch",
+                "test:cov": "jest --coverage",
+                "test:debug": "node --inspect-brk -r tsconfig-paths/register -r ts-node/register node_modules/.bin/jest --runInBand",
+                "test:e2e": "jest --config ./test/jest-e2e.json"
+            },
+            dependencies: {
+                "@nestjs/common": "^10.0.0",
+                "@nestjs/core": "^10.0.0",
+                "@nestjs/platform-express": "^10.0.0",
+                "@nestjs/config": "^3.0.0",
+                "@nestjs/terminus": "^10.0.0",
+                "reflect-metadata": "^0.1.13",
+                "rxjs": "^7.8.1",
+                "nestjs-pino": "^3.3.0",
+                "pino-http": "^8.3.3",
+                "zod": "^3.22.2",
+                "ioredis": "^5.3.2",
+                "class-validator": "^0.14.0",
+                "class-transformer": "^0.5.1",
+                ...(options.orm === "prisma" ? { "@prisma/client": "^5.0.0" } : {})
+            },
+            devDependencies: {
+                "@nestjs/cli": "^10.0.0",
+                "@nestjs/schematics": "^10.0.0",
+                "@nestjs/testing": "^10.0.0",
+                "@types/express": "^4.17.17",
+                "@types/jest": "^29.5.2",
+                "@types/node": "^20.3.1",
+                "@types/supertest": "^2.0.12",
+                "@typescript-eslint/eslint-plugin": "^6.0.0",
+                "@typescript-eslint/parser": "^6.0.0",
+                "eslint": "^8.42.0",
+                "eslint-config-prettier": "^9.0.0",
+                "eslint-plugin-prettier": "^5.0.0",
+                "eslint-plugin-import": "^2.27.5",
+                "jest": "^29.5.0",
+                "prettier": "^3.0.0",
+                "pino-pretty": "^10.0.0",
+                "source-map-support": "^0.5.21",
+                "supertest": "^6.3.3",
+                "ts-jest": "^29.1.0",
+                "ts-loader": "^9.4.3",
+                "ts-node": "^10.9.1",
+                "tsconfig-paths": "^4.2.0",
+                "typescript": "^5.1.3",
+                ...(options.orm === "prisma" ? { "prisma": "^5.0.0" } : {})
+            },
+            jest: {
+                "moduleFileExtensions": ["js", "json", "ts"],
+                "rootDir": "src",
+                "testRegex": ".*\\.spec\\.ts$",
+                "transform": { "^.+\\.(t|j)s$": "ts-jest" },
+                "collectCoverageFrom": ["**/*.(t|j)s"],
+                "coverageDirectory": "../coverage",
+                "testEnvironment": "node"
+            }
+        }, null, 2));
+        this.writeFile(root, "tsconfig.json", JSON.stringify({
+            compilerOptions: {
+                module: "commonjs",
+                declaration: true,
+                removeComments: true,
+                emitDecoratorMetadata: true,
+                experimentalDecorators: true,
+                allowSyntheticDefaultImports: true,
+                target: "ES2021",
+                sourceMap: true,
+                outDir: "./dist",
+                baseUrl: "./",
+                incremental: true,
+                skipLibCheck: true,
+                strictNullChecks: false,
+                noImplicitAny: false,
+                strictBindCallApply: false,
+                forceConsistentCasingInFileNames: false,
+                noFallthroughCasesInSwitch: false
+            }
+        }, null, 2));
+        this.writeFile(root, "nest-cli.json", JSON.stringify({
+            "$schema": "https://json.schemastore.org/nest-cli",
+            "collection": "@nestjs/schematics",
+            "sourceRoot": "src",
+            "compilerOptions": {
+                "deleteOutDir": true
+            }
+        }, null, 2));
+        // .eslintrc.json (Architecture Guardrails)
+        const archStyle = options.architecture || "clean";
+        let restrictedPaths = [];
+        if (archStyle === "clean") {
+            restrictedPaths = [
+                {
+                    target: "./src/domain",
+                    from: "./src/application",
+                    message: "Domain layer cannot import from Application layer"
+                },
+                {
+                    target: "./src/domain",
+                    from: "./src/infrastructure",
+                    message: "Domain layer cannot import from Infrastructure layer"
+                },
+                {
+                    target: "./src/domain",
+                    from: "./src/presentation",
+                    message: "Domain layer cannot import from Presentation layer"
+                },
+                {
+                    target: "./src/application",
+                    from: "./src/infrastructure",
+                    message: "Application layer cannot import from Infrastructure layer"
+                },
+                {
+                    target: "./src/application",
+                    from: "./src/presentation",
+                    message: "Application layer cannot import from Presentation layer"
+                },
+                {
+                    target: "./src/infrastructure",
+                    from: "./src/presentation",
+                    message: "Infrastructure layer cannot import from Presentation layer"
+                }
+            ];
+        }
+        this.writeFile(root, ".eslintrc.json", JSON.stringify({
+            "parser": "@typescript-eslint/parser",
+            "parserOptions": {
+                "project": "tsconfig.json",
+                "tsconfigRootDir": "__dirname",
+                "sourceType": "module"
+            },
+            "plugins": ["@typescript-eslint/eslint-plugin", "import"],
+            "extends": [
+                "plugin:@typescript-eslint/recommended",
+                "plugin:prettier/recommended"
+            ],
+            "root": true,
+            "env": {
+                "node": true,
+                "jest": true
+            },
+            "ignorePatterns": [".eslintrc.js", ".eslintrc.json"],
+            "rules": {
+                "@typescript-eslint/interface-name-prefix": "off",
+                "@typescript-eslint/explicit-function-return-type": "off",
+                "@typescript-eslint/explicit-module-boundary-types": "off",
+                "@typescript-eslint/no-explicit-any": "off",
+                "import/no-restricted-paths": ["error", {
+                        "zones": restrictedPaths
+                    }]
+            }
+        }, null, 2));
+        this.writeFile(root, ".env", `PORT=3000\nNODE_ENV=development\nDATABASE_URL="postgresql://user:password@localhost:5432/appdb?schema=public"\nREDIS_URL="redis://localhost:6379"\n`);
+        this.writeFile(root, ".env.example", `PORT=3000\nNODE_ENV=development\nDATABASE_URL="postgresql://user:password@localhost:5432/appdb?schema=public"\nREDIS_URL="redis://localhost:6379"\n`);
+        this.writeFile(root, ".gitignore", `node_modules/\ndist/\n.env\n`);
+        this.generateConfigModule(root, options);
+        this.generateCacheModule(root, options);
+        this.generateErrorFilter(root, options);
+        this.generateHealthModule(root, options);
+        if (options.orm === "prisma") {
+            this.generatePrismaSchema(root, options);
+        }
+    }
+    generateHealthModule(root, options) {
+        this.writeFile(root, "src/infrastructure/health/health.controller.ts", `
+import { Controller, Get } from '@nestjs/common';
+import { HealthCheckService, HealthCheck, TypeOrmHealthIndicator, MemoryHealthIndicator } from '@nestjs/terminus';
+
+@Controller('health')
+export class HealthController {
+  constructor(
+    private health: HealthCheckService,
+    private memory: MemoryHealthIndicator,
+  ) {}
+
+  @Get()
+  @HealthCheck()
+  check() {
+    return this.health.check([
+      () => this.memory.checkHeap('memory_heap', 150 * 1024 * 1024),
+    ]);
+  }
+}
+    `);
+        this.writeFile(root, "src/infrastructure/health/health.module.ts", `
+import { Module } from '@nestjs/common';
+import { TerminusModule } from '@nestjs/terminus';
+import { HealthController } from './health.controller';
+
+@Module({
+  imports: [TerminusModule],
+  controllers: [HealthController],
+})
+export class HealthModule {}
+    `);
+    }
+    generateConfigModule(root, options) {
+        this.writeFile(root, "src/infrastructure/config/env.schema.ts", `
+import { z } from "zod";
+
+export const envSchema = z.object({
+  PORT: z.string().default("3000"),
+  NODE_ENV: z.enum(["development", "production", "test"]).default("development"),
+  DATABASE_URL: z.string(),
+  REDIS_URL: z.string().default("redis://localhost:6379"),
+});
+
+export type Env = z.infer<typeof envSchema>;
+    `);
+        this.writeFile(root, "src/infrastructure/config/config.module.ts", `
+import { Module } from '@nestjs/common';
+import { ConfigModule as NestConfigModule } from '@nestjs/config';
+import { envSchema } from './env.schema';
+
+@Module({
+  imports: [
+    NestConfigModule.forRoot({
+      isGlobal: true,
+      validate: (config) => {
+        const parsed = envSchema.safeParse(config);
+        if (!parsed.success) {
+          console.error("❌ Invalid environment variables:", parsed.error.format());
+          throw new Error("Invalid environment variables");
+        }
+        return parsed.data;
+      },
+    }),
+  ],
+})
+export class ConfigModule {}
+    `);
+    }
+    generateCacheModule(root, options) {
+        this.writeFile(root, "src/infrastructure/cache/cache.interface.ts", `
+export interface ICache {
+  get<T>(key: string): Promise<T | null>;
+  set(key: string, value: any, ttlSeconds?: number): Promise<void>;
+  delete(key: string): Promise<void>;
+}
+    `);
+        this.writeFile(root, "src/infrastructure/cache/redis.cache.ts", `
+import { Injectable, OnModuleDestroy } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import Redis from 'ioredis';
+import { ICache } from './cache.interface';
+
+@Injectable()
+export class RedisCache implements ICache, OnModuleDestroy {
+  private readonly redis: Redis;
+
+  constructor(private configService: ConfigService) {
+    this.redis = new Redis(this.configService.get<string>('REDIS_URL'));
+  }
+
+  async get<T>(key: string): Promise<T | null> {
+    const data = await this.redis.get(key);
+    return data ? JSON.parse(data) : null;
+  }
+
+  async set(key: string, value: any, ttlSeconds?: number): Promise<void> {
+    const data = JSON.stringify(value);
+    if (ttlSeconds) {
+      await this.redis.setex(key, ttlSeconds, data);
+    } else {
+      await this.redis.set(key, data);
+    }
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.redis.del(key);
+  }
+
+  onModuleDestroy() {
+    this.redis.disconnect();
+  }
+}
+    `);
+        this.writeFile(root, "src/infrastructure/cache/cache.module.ts", `
+import { Global, Module } from '@nestjs/common';
+import { RedisCache } from './redis.cache';
+
+@Global()
+@Module({
+  providers: [
+    {
+      provide: 'ICache',
+      useClass: RedisCache,
+    },
+  ],
+  exports: ['ICache'],
+})
+export class CacheModule {}
+    `);
+    }
+    generateErrorFilter(root, options) {
+        this.writeFile(root, "src/infrastructure/filters/http-exception.filter.ts", `
+import { ExceptionFilter, Catch, ArgumentsHost, HttpException, HttpStatus } from '@nestjs/common';
+import { Request, Response } from 'express';
+import { PinoLogger } from 'nestjs-pino';
+
+@Catch()
+export class HttpExceptionFilter implements ExceptionFilter {
+  constructor(private readonly logger: PinoLogger) {}
+
+  catch(exception: any, host: ArgumentsHost) {
+    const ctx = host.switchToHttp();
+    const response = ctx.getResponse<Response>();
+    const request = ctx.getRequest<Request>();
+    
+    const status = exception instanceof HttpException
+      ? exception.getStatus()
+      : HttpStatus.INTERNAL_SERVER_ERROR;
+
+    const message = exception instanceof HttpException
+      ? exception.getResponse()
+      : 'Internal server error';
+
+    this.logger.error({
+      err: exception,
+      path: request.url,
+      status,
+    }, 'Unhandled Exception');
+
+    response.status(status).json({
+      statusCode: status,
+      timestamp: new Date().toISOString(),
+      path: request.url,
+      message: typeof message === 'object' ? (message as any).message : message,
+    });
+  }
+}
+    `);
+    }
+    generateStandardArchitecture(root, options) {
+        this.writeFile(root, "src/main.ts", `
+import { NestFactory } from '@nestjs/core';
+import { ValidationPipe } from '@nestjs/common';
+import { Logger } from 'nestjs-pino';
+import { ConfigService } from '@nestjs/config';
+import { AppModule } from './app.module';
+import { HttpExceptionFilter } from './infrastructure/filters/http-exception.filter';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, { bufferLogs: true });
+  const logger = app.get(Logger);
+  const configService = app.get(ConfigService);
+  
+  app.useLogger(logger);
+  app.useGlobalFilters(new HttpExceptionFilter(app.get(Logger)));
+  app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true }));
+  
+  const port = configService.get<string>('PORT') || 3000;
+  await app.listen(port);
+  
+  logger.log(\`🚀 NestJS Server running on port \${port}\`);
+}
+bootstrap();
+    `);
+        this.writeFile(root, "src/app.module.ts", `
+import { Module } from '@nestjs/common';
+import { LoggerModule } from 'nestjs-pino';
+import { ConfigModule } from './infrastructure/config/config.module';
+import { CacheModule } from './infrastructure/cache/cache.module';
+import { HealthModule } from './infrastructure/health/health.module';
+${options.orm === 'prisma' ? "import { PrismaModule } from './infrastructure/prisma/prisma.module';" : ""}
+import { AppController } from './app.controller';
+import { AppService } from './app.service';
+
+@Module({
+  imports: [
+    ConfigModule,
+    CacheModule,
+    HealthModule,
+    LoggerModule.forRoot({
+      pinoHttp: {
+        transport: process.env.NODE_ENV !== 'production' ? { target: 'pino-pretty' } : undefined,
+        autoLogging: true,
+        genReqId: (req) => req.headers['x-correlation-id'] || req.id,
+      },
+    }),
+    ${options.orm === 'prisma' ? "PrismaModule," : ""}
+  ],
+  controllers: [AppController],
+  providers: [AppService],
+})
+export class AppModule {}
+    `);
+        this.writeFile(root, "src/app.controller.ts", `
+import { Controller, Get } from '@nestjs/common';
+import { AppService } from './app.service';
+
+@Controller()
+export class AppController {
+  constructor(private readonly appService: AppService) {}
+
+  @Get()
+  getHello(): string {
+    return this.appService.getHello();
+  }
+}
+    `);
+        this.writeFile(root, "src/app.service.ts", `
+import { Injectable } from '@nestjs/common';
+
+@Injectable()
+export class AppService {
+  getHello(): string {
+    return 'Hello World!';
+  }
+}
+    `);
+    }
+    generateCleanArchitecture(root, options) {
+        // Domain
+        this.writeFile(root, "src/domain/entities/user.entity.ts", `
+export class User {
+    constructor(
+        public readonly id: string,
+        public readonly name: string,
+        public readonly email: string
+    ) {}
+}
+    `);
+        this.writeFile(root, "src/domain/repositories/user.repository.interface.ts", `
+import { User } from "../entities/user.entity";
+
+export interface IUserRepository {
+    save(user: User): Promise<User>;
+    findByEmail(email: string): Promise<User | null>;
+    findById(id: string): Promise<User | null>;
+}
+    `);
+        // Application
+        this.writeFile(root, "src/application/use-cases/create-user.use-case.ts", `
+import { Inject, Injectable, BadRequestException } from '@nestjs/common';
+import { User } from '../../domain/entities/user.entity';
+import { IUserRepository } from '../../domain/repositories/user.repository.interface';
+
+@Injectable()
+export class CreateUserUseCase {
+    constructor(
+        @Inject('IUserRepository')
+        private readonly userRepository: IUserRepository
+    ) {}
+
+    async execute(name: string, email: string): Promise<User> {
+        const existing = await this.userRepository.findByEmail(email);
+        if (existing) throw new BadRequestException("User already exists");
+        
+        const user = new User(Date.now().toString(), name, email);
+        return this.userRepository.save(user);
+    }
+}
+    `);
+        this.writeFile(root, "src/application/use-cases/get-user.use-case.ts", `
+import { Inject, Injectable, NotFoundException } from '@nestjs/common';
+import { User } from '../../domain/entities/user.entity';
+import { IUserRepository } from '../../domain/repositories/user.repository.interface';
+import { ICache } from '../../infrastructure/cache/cache.interface';
+
+@Injectable()
+export class GetUserUseCase {
+    constructor(
+        @Inject('IUserRepository')
+        private readonly userRepository: IUserRepository,
+        @Inject('ICache')
+        private readonly cache: ICache
+    ) {}
+
+    async execute(id: string): Promise<User> {
+        const cacheKey = \`user:\${id}\`;
+        const cached = await this.cache.get<User>(cacheKey);
+        if (cached) return cached;
+
+        const user = await this.userRepository.findById(id);
+        if (!user) throw new NotFoundException("User not found");
+
+        await this.cache.set(cacheKey, user, 3600);
+        return user;
+    }
+}
+    `);
+        // Infrastructure
+        this.writeFile(root, "src/infrastructure/repositories/in-memory-user.repository.ts", `
+import { Injectable } from '@nestjs/common';
+import { User } from '../../domain/entities/user.entity';
+import { IUserRepository } from '../../domain/repositories/user.repository.interface';
+
+@Injectable()
+export class InMemoryUserRepository implements IUserRepository {
+    private users: User[] = [];
+
+    async save(user: User): Promise<User> {
+        this.users.push(user);
+        return user;
+    }
+
+    async findByEmail(email: string): Promise<User | null> {
+        return this.users.find(u => u.email === email) || null;
+    }
+
+    async findById(id: string): Promise<User | null> {
+        return this.users.find(u => u.id === id) || null;
+    }
+}
+    `);
+        // Presentation (Controllers)
+        this.writeFile(root, "src/presentation/controllers/user.controller.ts", `
+import { Controller, Post, Get, Body, Param } from '@nestjs/common';
+import { CreateUserUseCase } from '../../application/use-cases/create-user.use-case';
+import { GetUserUseCase } from '../../application/use-cases/get-user.use-case';
+
+@Controller('users')
+export class UserController {
+    constructor(
+        private readonly createUserUseCase: CreateUserUseCase,
+        private readonly getUserUseCase: GetUserUseCase
+    ) {}
+
+    @Post()
+    async create(@Body() body: { name: string; email: string }) {
+        return await this.createUserUseCase.execute(body.name, body.email);
+    }
+
+    @Get(':id')
+    async get(@Param('id') id: string) {
+        return await this.getUserUseCase.execute(id);
+    }
+}
+    `);
+        // Modules
+        this.writeFile(root, "src/app.module.ts", `
+import { Module } from '@nestjs/common';
+import { LoggerModule } from 'nestjs-pino';
+import { ConfigModule } from './infrastructure/config/config.module';
+import { CacheModule } from './infrastructure/cache/cache.module';
+import { HealthModule } from './infrastructure/health/health.module';
+${options.orm === 'prisma' ? "import { PrismaModule } from './infrastructure/prisma/prisma.module';" : ""}
+import { UserController } from './presentation/controllers/user.controller';
+import { CreateUserUseCase } from './application/use-cases/create-user.use-case';
+import { GetUserUseCase } from './application/use-cases/get-user.use-case';
+import { InMemoryUserRepository } from './infrastructure/repositories/in-memory-user.repository';
+
+@Module({
+  imports: [
+    ConfigModule,
+    CacheModule,
+    HealthModule,
+    LoggerModule.forRoot({
+      pinoHttp: {
+        transport: process.env.NODE_ENV !== 'production' ? { target: 'pino-pretty' } : undefined,
+        autoLogging: true,
+        genReqId: (req) => req.headers['x-correlation-id'] || req.id,
+      },
+    }),
+    ${options.orm === 'prisma' ? "PrismaModule," : ""}
+  ],
+  controllers: [UserController],
+  providers: [
+    CreateUserUseCase,
+    GetUserUseCase,
+    {
+        provide: 'IUserRepository',
+        useClass: InMemoryUserRepository
+    }
+  ],
+})
+export class AppModule {}
+    `);
+        this.writeFile(root, "src/main.ts", `
+import { NestFactory } from '@nestjs/core';
+import { ValidationPipe } from '@nestjs/common';
+import { Logger } from 'nestjs-pino';
+import { ConfigService } from '@nestjs/config';
+import { AppModule } from './app.module';
+import { HttpExceptionFilter } from './infrastructure/filters/http-exception.filter';
+
+async function bootstrap() {
+  const app = await NestFactory.create(AppModule, { bufferLogs: true });
+  const logger = app.get(Logger);
+  const configService = app.get(ConfigService);
+  
+  app.useLogger(logger);
+  app.useGlobalFilters(new HttpExceptionFilter(app.get(Logger)));
+  app.useGlobalPipes(new ValidationPipe({ transform: true, whitelist: true }));
+  
+  const port = configService.get<string>('PORT') || 3000;
+  await app.listen(port);
+  
+  logger.log(\`🚀 NestJS Clean Architecture Server running on port \${port}\`);
+}
+bootstrap();
+    `);
+    }
+    generateDocker(root, options) {
+        const dbService = options.database === "postgresql" ? `
+  db:
+    image: postgres:15-alpine
+    environment:
+      - POSTGRES_USER=user
+      - POSTGRES_PASSWORD=password
+      - POSTGRES_DB=appdb
+    ports:
+      - "5432:5432"
+        ` : options.database === "mysql" ? `
+  db:
+    image: mysql:8
+    environment:
+      - MYSQL_ROOT_PASSWORD=password
+      - MYSQL_DATABASE=appdb
+    ports:
+      - "3306:3306"
+        ` : "";
+        const dbUrl = options.database === "postgresql" ? "postgresql://user:password@db:5432/appdb?schema=public" :
+            options.database === "mysql" ? "mysql://root:password@db:3306/appdb" : "";
+        this.writeFile(root, "Dockerfile", `
+FROM node:18-alpine AS builder
+WORKDIR /app
+COPY package*.json ./
+RUN npm ci
+COPY . .
+${options.orm === 'prisma' ? 'RUN npx prisma generate' : ''}
+RUN npm run build
+
+FROM node:18-alpine
+WORKDIR /app
+COPY --from=builder /app/dist ./dist
+COPY --from=builder /app/package*.json ./
+${options.orm === 'prisma' ? 'COPY --from=builder /app/prisma ./prisma' : ''}
+RUN npm ci --production
+${options.orm === 'prisma' ? 'RUN npx prisma generate' : ''}
+EXPOSE 3000
+CMD ["npm", "run", "start:prod"]
+        `);
+        this.writeFile(root, "docker-compose.yml", `
+version: '3.8'
+services:
+  app:
+    build: .
+    ports:
+      - "3000:3000"
+    environment:
+      - PORT=3000
+      - NODE_ENV=production
+      ${dbUrl ? `- DATABASE_URL=\${DATABASE_URL:-${dbUrl}}` : ""}
+      - REDIS_URL=redis://cache:6379
+    depends_on:
+      ${dbService ? "- db" : ""}
+      - cache
+    restart: always
+  ${dbService}
+  cache:
+    image: redis:7-alpine
+    ports:
+      - "6379:6379"
+        `);
+    }
+    generateCI(root, options) {
+        this.writeFile(root, ".github/workflows/ci.yml", `
+name: CI
+
+on:
+  push:
+    branches: [ main ]
+  pull_request:
+    branches: [ main ]
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+
+    steps:
+    - uses: actions/checkout@v3
+    - name: Use Node.js 18.x
+      uses: actions/setup-node@v3
+      with:
+        node-version: 18.x
+        cache: 'npm'
+    - run: npm ci
+    ${options.orm === 'prisma' ? '- run: npx prisma generate' : ''}
+    - name: Architecture Sync & Validation
+      run: npx archforge sync
+    - run: npm run lint
+    - run: npm test
+    - run: npm run build
+        `);
+    }
+    generatePrismaSchema(root, options) {
+        const provider = options.database === "mongodb" ? "mongodb" :
+            options.database === "mysql" ? "mysql" :
+                options.database === "sqlite" ? "sqlite" : "postgresql";
+        const url = options.database === "sqlite" ? "file:./dev.db" : "env(\"DATABASE_URL\")";
+        this.writeFile(root, "prisma/schema.prisma", `
+generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${provider}"
+  url      = ${url}
+}
+
+model User {
+  id    String @id @default(uuid())
+  email String @unique
+  name  String?
+}
+        `);
+        this.writeFile(root, "src/infrastructure/prisma/prisma.service.ts", `
+import { Injectable, OnModuleInit } from '@nestjs/common';
+import { PrismaClient } from '@prisma/client';
+
+@Injectable()
+export class PrismaService extends PrismaClient implements OnModuleInit {
+  async onModuleInit() {
+    await this.$connect();
+  }
+}
+        `);
+        this.writeFile(root, "src/infrastructure/prisma/prisma.module.ts", `
+import { Global, Module } from '@nestjs/common';
+import { PrismaService } from './prisma.service';
+
+@Global()
+@Module({
+  providers: [PrismaService],
+  exports: [PrismaService],
+})
+export class PrismaModule {}
+        `);
+    }
+}
+exports.NestJSGenerator = NestJSGenerator;