@node-initializr/generator 0.1.0

package/dist/generate.d.ts

@@ -0,0 +1,12 @@
+import { type ProjectConfig } from '@node-initializr/shared';
+import { type GeneratedFile } from './template-engine.js';
+export interface GenerateResult {
+    files: GeneratedFile[];
+    buffer: Buffer;
+    fileName: string;
+    filesGenerated: number;
+}
+export declare function buildProjectConfig(partial: Partial<ProjectConfig> & Pick<ProjectConfig, 'name'>): ProjectConfig;
+export declare function renderProject(config: ProjectConfig): GeneratedFile[];
+export declare function generateProject(config: ProjectConfig): Promise<GenerateResult>;
+export declare function writeProject(files: GeneratedFile[], targetDir: string): Promise<void>;

package/dist/generate.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildProjectConfig = buildProjectConfig;
+exports.renderProject = renderProject;
+exports.generateProject = generateProject;
+exports.writeProject = writeProject;
+const shared_1 = require("@node-initializr/shared");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const template_engine_js_1 = require("./template-engine.js");
+const validate_js_1 = require("./validate.js");
+const zip_js_1 = require("./zip.js");
+const engine = new template_engine_js_1.TemplateEngine();
+function buildProjectConfig(partial) {
+    return {
+        ...shared_1.DEFAULT_PROJECT_CONFIG,
+        description: '',
+        ...partial,
+    };
+}
+function renderProject(config) {
+    const errors = (0, validate_js_1.validateProjectConfig)(config);
+    if (errors.length > 0) {
+        throw new Error(errors.join('; '));
+    }
+    return engine.renderProject(config);
+}
+async function generateProject(config) {
+    const files = renderProject(config);
+    const buffer = await (0, zip_js_1.createZip)(files);
+    return {
+        files,
+        buffer,
+        fileName: `${config.name}.zip`,
+        filesGenerated: files.length,
+    };
+}
+async function writeProject(files, targetDir) {
+    for (const file of files) {
+        const filePath = path.join(targetDir, file.path);
+        fs.mkdirSync(path.dirname(filePath), { recursive: true });
+        fs.writeFileSync(filePath, file.content, 'utf-8');
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { TemplateEngine, type GeneratedFile } from './template-engine.js';
+export { createZip } from './zip.js';
+export { validateProjectConfig } from './validate.js';
+export { buildProjectConfig, generateProject, renderProject, writeProject, type GenerateResult, } from './generate.js';

package/dist/index.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeProject = exports.renderProject = exports.generateProject = exports.buildProjectConfig = exports.validateProjectConfig = exports.createZip = exports.TemplateEngine = void 0;
+var template_engine_js_1 = require("./template-engine.js");
+Object.defineProperty(exports, "TemplateEngine", { enumerable: true, get: function () { return template_engine_js_1.TemplateEngine; } });
+var zip_js_1 = require("./zip.js");
+Object.defineProperty(exports, "createZip", { enumerable: true, get: function () { return zip_js_1.createZip; } });
+var validate_js_1 = require("./validate.js");
+Object.defineProperty(exports, "validateProjectConfig", { enumerable: true, get: function () { return validate_js_1.validateProjectConfig; } });
+var generate_js_1 = require("./generate.js");
+Object.defineProperty(exports, "buildProjectConfig", { enumerable: true, get: function () { return generate_js_1.buildProjectConfig; } });
+Object.defineProperty(exports, "generateProject", { enumerable: true, get: function () { return generate_js_1.generateProject; } });
+Object.defineProperty(exports, "renderProject", { enumerable: true, get: function () { return generate_js_1.renderProject; } });
+Object.defineProperty(exports, "writeProject", { enumerable: true, get: function () { return generate_js_1.writeProject; } });

package/dist/template-engine.d.ts

@@ -0,0 +1,24 @@
+import type { ProjectConfig } from '@node-initializr/shared';
+export interface GeneratedFile {
+    path: string;
+    content: string;
+}
+export declare class TemplateEngine {
+    private readonly templatesDir;
+    constructor(templatesDir?: string);
+    renderProject(config: ProjectConfig): GeneratedFile[];
+    private resolveTemplatesRoot;
+    private resolveTemplateDirs;
+    private resolveArchDir;
+    private buildContext;
+    private getDbDriver;
+    private getTypeormDriver;
+    private getSequelizeDialect;
+    private getDrizzleDriver;
+    private getPmRunDev;
+    private getOrmPackage;
+    private walkAndRender;
+    private shouldSkipDir;
+    private shouldIncludeFile;
+    private resolveOutputPath;
+}

package/dist/template-engine.js

@@ -0,0 +1,472 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TemplateEngine = void 0;
+const fs = __importStar(require("fs"));
+const handlebars_1 = __importDefault(require("handlebars"));
+const path = __importStar(require("path"));
+class TemplateEngine {
+    templatesDir;
+    constructor(templatesDir) {
+        handlebars_1.default.registerHelper('eq', (a, b) => a === b);
+        this.templatesDir = templatesDir ?? this.resolveTemplatesRoot();
+    }
+    renderProject(config) {
+        const context = this.buildContext(config);
+        const templateDirs = this.resolveTemplateDirs(config);
+        const fileMap = new Map();
+        for (const dir of templateDirs) {
+            if (!fs.existsSync(dir)) {
+                throw new Error(`Template set not found: ${dir}`);
+            }
+            for (const file of this.walkAndRender(dir, '', context)) {
+                fileMap.set(file.path, file);
+            }
+        }
+        if (fileMap.size === 0) {
+            throw new Error('Nenhum arquivo gerado — verifique framework e arquitetura');
+        }
+        return Array.from(fileMap.values());
+    }
+    resolveTemplatesRoot() {
+        const candidates = [
+            path.join(__dirname, 'templates'),
+            path.join(__dirname, '..', 'templates'),
+            path.join(process.cwd(), 'packages', 'generator', 'dist', 'templates'),
+            path.join(process.cwd(), 'packages', 'generator', 'templates'),
+        ];
+        for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+                return candidate;
+            }
+        }
+        throw new Error(`Templates não encontrados. Procurou em: ${candidates.join(', ')}`);
+    }
+    resolveTemplateDirs(config) {
+        const arch = this.resolveArchDir(config.architecture);
+        const sharedDir = path.join(this.templatesDir, `shared-${config.framework}`);
+        const dirs = [
+            path.join(this.templatesDir, `base-${config.framework}`),
+            path.join(this.templatesDir, arch, config.framework),
+        ];
+        if (fs.existsSync(sharedDir)) {
+            dirs.splice(1, 0, sharedDir);
+        }
+        return dirs;
+    }
+    resolveArchDir(architecture) {
+        const map = {
+            clean: 'arch-clean',
+            mvc: 'arch-mvc',
+            'modular-monolith': 'arch-modular',
+        };
+        return map[architecture];
+    }
+    buildContext(config) {
+        const ext = config.language === 'typescript' ? 'ts' : 'js';
+        return {
+            ...config,
+            ext,
+            projectSlug: config.name,
+            npmName: config.name.replace(/-/g, '_'),
+            year: new Date().getFullYear(),
+            hasDatabase: config.database !== 'none',
+            hasOrm: config.orm !== 'none',
+            hasAuth: config.auth !== 'none',
+            hasRedis: config.redis,
+            needsRedis: config.redis || config.messageBroker === 'bullmq',
+            hasMessageBroker: config.messageBroker !== 'none',
+            isTypescript: config.language === 'typescript',
+            usePrisma: config.orm === 'prisma' && config.database !== 'none',
+            useTypeorm: config.orm === 'typeorm' && config.database !== 'none',
+            useDrizzle: config.orm === 'drizzle' &&
+                (config.database === 'postgresql' || config.database === 'mysql'),
+            useSequelize: config.orm === 'sequelize' &&
+                (config.database === 'postgresql' || config.database === 'mysql'),
+            useReflectMetadata: config.orm === 'typeorm' || config.orm === 'sequelize',
+            useJwt: config.auth === 'jwt',
+            useClerk: config.auth === 'clerk',
+            useBullmq: config.messageBroker === 'bullmq',
+            useRabbitmq: config.messageBroker === 'rabbitmq',
+            usePostgres: config.database === 'postgresql',
+            useMysql: config.database === 'mysql',
+            useMongodb: config.database === 'mongodb',
+            isCleanArch: config.architecture === 'clean',
+            isMvc: config.architecture === 'mvc',
+            isModular: config.architecture === 'modular-monolith',
+            hasRealOrm: config.orm === 'prisma' ||
+                config.orm === 'typeorm' ||
+                config.orm === 'drizzle' ||
+                config.orm === 'sequelize',
+            dbDriver: this.getDbDriver(config),
+            typeormDriver: this.getTypeormDriver(config),
+            sequelizeDialect: this.getSequelizeDialect(config),
+            drizzleDriver: this.getDrizzleDriver(config),
+            ormPackage: this.getOrmPackage(config),
+            isPnpm: config.packageManager === 'pnpm',
+            isYarn: config.packageManager === 'yarn',
+            isNpm: config.packageManager === 'npm',
+            pmInstall: config.packageManager === 'pnpm'
+                ? 'pnpm install'
+                : config.packageManager === 'yarn'
+                    ? 'yarn install --frozen-lockfile'
+                    : 'npm ci',
+            pmRunBuild: config.packageManager === 'pnpm'
+                ? 'pnpm run build'
+                : config.packageManager === 'yarn'
+                    ? 'yarn build'
+                    : 'npm run build',
+            pmRunTest: config.packageManager === 'pnpm'
+                ? 'pnpm test'
+                : config.packageManager === 'yarn'
+                    ? 'yarn test'
+                    : 'npm test',
+            pmRunDev: this.getPmRunDev(config),
+            pmInstallDev: config.packageManager === 'pnpm'
+                ? 'pnpm install'
+                : config.packageManager === 'yarn'
+                    ? 'yarn install'
+                    : 'npm install',
+        };
+    }
+    getDbDriver(config) {
+        const map = {
+            postgresql: 'pg',
+            mysql: 'mysql2',
+            mongodb: 'mongodb',
+        };
+        return map[config.database] ?? 'pg';
+    }
+    getTypeormDriver(config) {
+        const map = {
+            postgresql: 'postgres',
+            mysql: 'mysql',
+            mongodb: 'mongodb',
+        };
+        return map[config.database] ?? 'postgres';
+    }
+    getSequelizeDialect(config) {
+        const map = {
+            postgresql: 'postgres',
+            mysql: 'mysql',
+        };
+        return map[config.database] ?? 'postgres';
+    }
+    getDrizzleDriver(config) {
+        if (config.database === 'mysql')
+            return 'mysql2';
+        if (config.database === 'mongodb')
+            return 'mongodb';
+        return 'pg';
+    }
+    getPmRunDev(config) {
+        const script = config.framework === 'nestjs' ? 'start:dev' : 'dev';
+        if (config.packageManager === 'pnpm')
+            return `pnpm run ${script}`;
+        if (config.packageManager === 'yarn')
+            return `yarn ${script}`;
+        return `npm run ${script}`;
+    }
+    getOrmPackage(config) {
+        const map = {
+            prisma: '@prisma/client',
+            typeorm: 'typeorm',
+            drizzle: 'drizzle-orm',
+            sequelize: 'sequelize',
+        };
+        return map[config.orm] ?? '';
+    }
+    walkAndRender(dir, relativePath, context) {
+        if (!fs.existsSync(dir))
+            return [];
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        const files = [];
+        for (const entry of entries) {
+            const entryRelative = path.join(relativePath, entry.name);
+            if (entry.isDirectory()) {
+                if (this.shouldSkipDir(entry.name, context, relativePath))
+                    continue;
+                files.push(...this.walkAndRender(path.join(dir, entry.name), entryRelative, context));
+                continue;
+            }
+            if (!entry.name.endsWith('.hbs'))
+                continue;
+            if (!this.shouldIncludeFile(entryRelative, context))
+                continue;
+            const raw = fs.readFileSync(path.join(dir, entry.name), 'utf-8');
+            const template = handlebars_1.default.compile(raw, { noEscape: true });
+            files.push({
+                path: this.resolveOutputPath(entryRelative, context),
+                content: template(context),
+            });
+        }
+        return files;
+    }
+    shouldSkipDir(dirName, ctx, parentPath) {
+        const conditionalDirs = {
+            docker: 'docker',
+            'github-actions': 'githubActions',
+            prisma: 'usePrisma',
+            typeorm: 'useTypeorm',
+            drizzle: 'useDrizzle',
+            sequelize: 'useSequelize',
+            auth: 'hasAuth',
+            swagger: 'swagger',
+            tests: 'jest',
+        };
+        if (parentPath.includes('auth') && dirName === 'jwt' && !ctx.useJwt)
+            return true;
+        if (parentPath.includes('auth') && dirName === 'clerk' && !ctx.useClerk)
+            return true;
+        if (parentPath.includes('infra') && dirName === 'prisma' && !ctx.usePrisma)
+            return true;
+        if (parentPath.includes('infra') &&
+            dirName === 'typeorm' &&
+            !ctx.useTypeorm)
+            return true;
+        if (parentPath.includes('infra') &&
+            dirName === 'drizzle' &&
+            !ctx.useDrizzle)
+            return true;
+        if (parentPath.includes('infra') &&
+            dirName === 'sequelize' &&
+            !ctx.useSequelize)
+            return true;
+        if (parentPath.includes('infrastructure') &&
+            dirName === 'prisma' &&
+            !ctx.usePrisma) {
+            return true;
+        }
+        if (parentPath.includes('infrastructure') &&
+            dirName === 'typeorm' &&
+            !ctx.useTypeorm) {
+            return true;
+        }
+        if (parentPath.includes('infrastructure') &&
+            dirName === 'drizzle' &&
+            !ctx.useDrizzle) {
+            return true;
+        }
+        if (parentPath.includes('infrastructure') &&
+            dirName === 'sequelize' &&
+            !ctx.useSequelize) {
+            return true;
+        }
+        const normParent = parentPath.replace(/\\/g, '/');
+        if (normParent === 'src/infra' &&
+            (dirName === 'typeorm' ||
+                dirName === 'drizzle' ||
+                dirName === 'sequelize') &&
+            ctx.isCleanArch) {
+            return true;
+        }
+        if (normParent === 'src/infrastructure' &&
+            (dirName === 'typeorm' ||
+                dirName === 'drizzle' ||
+                dirName === 'sequelize') &&
+            !ctx.isCleanArch) {
+            return true;
+        }
+        const flag = conditionalDirs[dirName];
+        return flag ? !ctx[flag] : false;
+    }
+    shouldIncludeFile(filePath, ctx) {
+        const norm = filePath.replace(/\\/g, '/');
+        if (norm.includes('/prisma/') && !ctx.usePrisma)
+            return false;
+        if (norm.includes('/typeorm/') && !ctx.useTypeorm)
+            return false;
+        if (norm.includes('/drizzle/') && !ctx.useDrizzle)
+            return false;
+        if (norm.includes('/sequelize/') && !ctx.useSequelize)
+            return false;
+        if (norm.includes('prisma-user.repository') && !ctx.usePrisma)
+            return false;
+        if (norm.includes('typeorm-user.repository') && !ctx.useTypeorm)
+            return false;
+        if (norm.includes('drizzle-user.repository') && !ctx.useDrizzle)
+            return false;
+        if (norm.includes('sequelize-user.repository') && !ctx.useSequelize)
+            return false;
+        if (norm.includes('in-memory-user.repository') && ctx.hasRealOrm)
+            return false;
+        if (norm.includes('infra/prisma') && !ctx.usePrisma)
+            return false;
+        if (norm.includes('infra/typeorm') && !ctx.useTypeorm)
+            return false;
+        if (norm.includes('infra/drizzle') && !ctx.useDrizzle)
+            return false;
+        if (norm.includes('infra/sequelize') && !ctx.useSequelize)
+            return false;
+        if (norm.includes('auth/jwt') && !ctx.useJwt)
+            return false;
+        if (norm.includes('auth/clerk') && !ctx.useClerk)
+            return false;
+        if (norm.includes('infra/swagger') && !ctx.swagger)
+            return false;
+        if (norm.includes('jwt.middleware') && !ctx.useJwt)
+            return false;
+        if (norm.includes('jwt-auth.guard') && !ctx.useJwt)
+            return false;
+        if (norm.includes('jwt.guard') && !ctx.useJwt)
+            return false;
+        if (norm.includes('jwt.strategy') && !ctx.useJwt)
+            return false;
+        if (norm.includes('jwt.module') && !ctx.useJwt)
+            return false;
+        if (norm.includes('clerk-auth.guard') && !ctx.useClerk)
+            return false;
+        if (norm.includes('clerk.guard') && !ctx.useClerk)
+            return false;
+        if (norm.includes('clerk.middleware') && !ctx.useClerk)
+            return false;
+        if (norm.includes('tsconfig.json') && !ctx.isTypescript)
+            return false;
+        if (norm.includes('nest-cli.json') && !ctx.isTypescript)
+            return false;
+        if (norm.includes('drizzle.config') && !ctx.useDrizzle)
+            return false;
+        if (norm.includes('.js.hbs') && ctx.isTypescript)
+            return false;
+        return true;
+    }
+    resolveOutputPath(relativePath, ctx) {
+        let output = relativePath.replace(/\.hbs$/, '').replace(/\\/g, '/');
+        const pathMappings = {
+            'docker/Dockerfile': 'Dockerfile',
+            'docker/docker-compose.yml': 'docker-compose.yml',
+            'github-actions/ci.yml': '.github/workflows/ci.yml',
+            'tests/health.spec.ts': 'test/health.spec.ts',
+            'tests/health.test.ts': 'test/health.test.ts',
+            'tests/health.test': 'test/health.test.ts',
+            'drizzle/drizzle.config.ts': 'drizzle.config.ts',
+            'drizzle/drizzle.config': 'drizzle.config.ts',
+        };
+        for (const [from, to] of Object.entries(pathMappings)) {
+            if (output === from || output.endsWith(`/${from}`)) {
+                output = to;
+                break;
+            }
+        }
+        const sourceExt = ctx.ext;
+        const extensionlessSources = [
+            'src/index',
+            'src/main',
+            'src/app.module',
+            'src/infrastructure/http/health.routes',
+            'src/infrastructure/http/users.routes',
+            'src/infrastructure/http/health.controller',
+            'src/infrastructure/http/users.controller',
+            'src/controllers/health.controller',
+            'src/controllers/users.controller',
+            'src/services/users.service',
+            'src/models/user.model',
+            'src/domain/entities/user.entity',
+            'src/domain/repositories/user.repository',
+            'src/application/use-cases/get-users.use-case',
+            'src/infrastructure/persistence/prisma-user.repository',
+            'src/infrastructure/persistence/typeorm-user.repository',
+            'src/infrastructure/persistence/drizzle-user.repository',
+            'src/infrastructure/persistence/sequelize-user.repository',
+            'src/infrastructure/persistence/in-memory-user.repository',
+            'src/infrastructure/prisma/prisma.module',
+            'src/infrastructure/prisma/prisma.service',
+            'src/infrastructure/typeorm/typeorm.module',
+            'src/infrastructure/typeorm/entities/user.entity',
+            'src/infrastructure/drizzle/drizzle.module',
+            'src/infrastructure/drizzle/drizzle.service',
+            'src/infrastructure/drizzle/schema',
+            'src/infrastructure/sequelize/sequelize.module',
+            'src/infrastructure/sequelize/models/user.model',
+            'src/infra/prisma/prisma.module',
+            'src/infra/prisma/prisma.service',
+            'src/infra/prisma/client',
+            'src/infra/typeorm/data-source',
+            'src/infra/typeorm/entities/user.entity',
+            'src/infra/drizzle/client',
+            'src/infra/drizzle/schema',
+            'src/infra/sequelize/sequelize',
+            'src/infra/sequelize/models/user.model',
+            'src/infra/database/users.repository',
+            'src/infra/auth/jwt.middleware',
+            'src/infra/auth/clerk.middleware',
+            'src/infra/auth/jwt/jwt-auth.guard',
+            'src/infra/auth/jwt/jwt.strategy',
+            'src/infra/auth/jwt/jwt.module',
+            'src/infra/auth/clerk/clerk-auth.guard',
+            'src/infrastructure/typeorm/typeorm.module',
+            'src/infrastructure/typeorm/entities/user.entity',
+            'src/infrastructure/drizzle/drizzle.module',
+            'src/infrastructure/drizzle/drizzle.service',
+            'src/infrastructure/drizzle/schema',
+            'src/infra/typeorm/typeorm.module',
+            'src/infra/typeorm/entities/user.entity',
+            'src/infra/drizzle/drizzle.module',
+            'src/infra/drizzle/drizzle.service',
+            'src/infra/drizzle/schema',
+            'src/infra/swagger/setup',
+            'src/modules/health/health.module',
+            'src/modules/health/health.controller',
+            'src/modules/users/users.module',
+            'src/modules/users/users.controller',
+            'src/modules/users/users.service',
+            'src/config/config.module',
+            'src/shared/errors/app.error',
+            'src/shared/constants',
+            'src/config/env',
+            'src/modules/health/health.routes',
+            'src/modules/users/users.routes',
+            'src/infra/database',
+            'test/health.test',
+        ];
+        for (const source of extensionlessSources) {
+            if (output === source || output.endsWith(`/${source}`)) {
+                output = `${output}.${sourceExt}`;
+                break;
+            }
+        }
+        if (ctx.isTypescript) {
+            output = output.replace(/\.js$/, '.ts');
+        }
+        else {
+            output = output.replace(/\.ts$/, '.js');
+        }
+        return output.replace(/\\/g, '/');
+    }
+}
+exports.TemplateEngine = TemplateEngine;

package/dist/templates/arch-clean/express/src/application/use-cases/get-users.use-case.hbs

@@ -0,0 +1,39 @@
+import { User } from '../../domain/entities/user.entity.js';
+{{#if usePrisma}}
+import { prisma } from '../../infra/prisma/client.js';
+{{/if}}
+{{#if useTypeorm}}
+import { AppDataSource } from '../../infra/typeorm/data-source.js';
+import { UserEntity } from '../../infra/typeorm/entities/user.entity.js';
+{{/if}}
+{{#if useDrizzle}}
+import { db } from '../../infra/drizzle/client.js';
+import { users } from '../../infra/drizzle/schema.js';
+{{/if}}
+{{#if useSequelize}}
+import { User } from '../../infra/sequelize/models/user.model.js';
+{{/if}}
+
+export class GetUsersUseCase {
+  async execute(): Promise<User[]> {
+{{#if usePrisma}}
+    const rows = await prisma.user.findMany();
+    return rows.map((r) => new User(r.id, r.email, r.name ?? ''));
+{{/if}}
+{{#if useTypeorm}}
+    const rows = await AppDataSource.getRepository(UserEntity).find();
+    return rows.map((r) => new User(r.id, r.email, r.name ?? ''));
+{{/if}}
+{{#if useDrizzle}}
+    const rows = await db.select().from(users);
+    return rows.map((r) => new User(r.id, r.email, r.name ?? ''));
+{{/if}}
+{{#if useSequelize}}
+    const rows = await User.findAll();
+    return rows.map((r) => new User(r.id, r.email, r.name ?? ''));
+{{/if}}
+{{#unless hasRealOrm}}
+    return [new User('1', 'user@example.com', 'Demo User')];
+{{/unless}}
+  }
+}

package/dist/templates/arch-clean/express/src/config/env.hbs

@@ -0,0 +1,4 @@
+export const env = {
+  port: Number(process.env.PORT ?? 3000),
+  nodeEnv: process.env.NODE_ENV ?? 'development',
+};

package/dist/templates/arch-clean/express/src/domain/entities/user.entity.hbs

@@ -0,0 +1,7 @@
+export class User {
+  constructor(
+    public readonly id: string,
+    public readonly email: string,
+    public readonly name: string,
+  ) {}
+}