nodejs-structure-cli 1.0.0

package/lib/modules/config-files.js

@@ -0,0 +1,151 @@
+import fs from 'fs-extra';
+import path from 'path';
+import ejs from 'ejs';
+
+export const renderPackageJson = async (templatesDir, targetDir, config) => {
+    const packageJsonPath = path.join(targetDir, 'package.json');
+    const packageTemplate = await fs.readFile(path.join(templatesDir, 'common', 'package.json.ejs'), 'utf-8');
+    const packageContent = ejs.render(packageTemplate, { ...config });
+    await fs.writeFile(packageJsonPath, packageContent);
+};
+
+export const renderDockerCompose = async (templatesDir, targetDir, config) => {
+    const dockerComposePath = path.join(targetDir, 'docker-compose.yml');
+    const dockerTemplate = await fs.readFile(path.join(templatesDir, 'common', 'docker-compose.yml.ejs'), 'utf-8');
+    const dockerContent = ejs.render(dockerTemplate, { ...config });
+    await fs.writeFile(dockerComposePath, dockerContent);
+};
+
+export const renderReadme = async (templatesDir, targetDir, config) => {
+    const readmePath = path.join(targetDir, 'README.md');
+    const readmeTemplate = await fs.readFile(path.join(templatesDir, 'common', 'README.md.ejs'), 'utf-8');
+    const readmeContent = ejs.render(readmeTemplate, { ...config });
+    await fs.writeFile(readmePath, readmeContent);
+};
+
+export const renderDockerfile = async (templatesDir, targetDir, config) => {
+    const dockerfileTemplate = await fs.readFile(path.join(templatesDir, 'common', 'Dockerfile'), 'utf-8');
+    const dockerfileContent = ejs.render(dockerfileTemplate, { ...config });
+    await fs.writeFile(path.join(targetDir, 'Dockerfile'), dockerfileContent);
+};
+
+export const renderPm2Config = async (templatesDir, targetDir, config) => {
+    const pm2ConfigPath = path.join(targetDir, 'ecosystem.config.js');
+    const pm2Template = await fs.readFile(path.join(templatesDir, 'common', 'ecosystem.config.js.ejs'), 'utf-8');
+    const pm2Content = ejs.render(pm2Template, { ...config });
+    await fs.writeFile(pm2ConfigPath, pm2Content);
+};
+
+export const renderProfessionalConfig = async (templatesDir, targetDir, config) => {
+    const eslintTemplate = await fs.readFile(path.join(templatesDir, 'common', 'eslint.config.mjs.ejs'), 'utf-8');
+    const eslintContent = ejs.render(eslintTemplate, { ...config });
+    await fs.writeFile(path.join(targetDir, 'eslint.config.mjs'), eslintContent);
+
+    await fs.copy(path.join(templatesDir, 'common', '.prettierrc'), path.join(targetDir, '.prettierrc'));
+    await fs.copy(path.join(templatesDir, 'common', '.lintstagedrc'), path.join(targetDir, '.lintstagedrc'));
+
+    const jestTemplate = await fs.readFile(path.join(templatesDir, 'common', 'jest.config.js.ejs'), 'utf-8');
+    const jestContent = ejs.render(jestTemplate, { ...config });
+    await fs.writeFile(path.join(targetDir, 'jest.config.js'), jestContent);
+    
+    // E2E Config
+    const jestE2eTemplate = await fs.readFile(path.join(templatesDir, 'common', 'jest.e2e.config.js.ejs'), 'utf-8');
+    const jestE2eContent = ejs.render(jestE2eTemplate, { ...config });
+    await fs.writeFile(path.join(targetDir, 'jest.e2e.config.js'), jestE2eContent);
+
+    // 1. Setup Husky pre-commit (Always for Professional Standard)
+    const huskyDir = path.join(targetDir, '.husky');
+    await fs.ensureDir(huskyDir);
+    await fs.copy(path.join(templatesDir, 'common', '_husky', 'pre-commit'), path.join(huskyDir, 'pre-commit'));
+
+    // 2. Enterprise Security Hardening (Optional)
+    if (config.includeSecurity) {
+        await fs.copy(path.join(templatesDir, 'common', 'SECURITY.md'), path.join(targetDir, 'SECURITY.md'));
+        
+        const sonarTemplate = await fs.readFile(path.join(templatesDir, 'common', 'sonar-project.properties.ejs'), 'utf-8');
+        const sonarContent = ejs.render(sonarTemplate, { ...config });
+        await fs.writeFile(path.join(targetDir, 'sonar-project.properties'), sonarContent);
+
+        const snykTemplate = await fs.readFile(path.join(templatesDir, 'common', '.snyk.ejs'), 'utf-8');
+        const snykContent = ejs.render(snykTemplate, { ...config });
+        await fs.writeFile(path.join(targetDir, '.snyk'), snykContent);
+    }
+};
+
+export const renderAiNativeFiles = async (templatesDir, targetDir, config) => {
+    // 1. .cursorrules
+    const cursorRulesPath = path.join(targetDir, '.cursorrules');
+    const cursorRulesTemplate = await fs.readFile(path.join(templatesDir, 'common', '.cursorrules.ejs'), 'utf-8');
+    const cursorRulesContent = ejs.render(cursorRulesTemplate, { ...config });
+    await fs.writeFile(cursorRulesPath, cursorRulesContent);
+
+    // 2. prompts/
+    const promptsDirTarget = path.join(targetDir, 'prompts');
+    await fs.ensureDir(promptsDirTarget);
+    
+    const promptsSourceDir = path.join(templatesDir, 'common', 'prompts');
+    const promptFiles = await fs.readdir(promptsSourceDir);
+    
+    for (const file of promptFiles) {
+        if (file.endsWith('.ejs')) {
+            const templatePath = path.join(promptsSourceDir, file);
+            const targetFilePath = path.join(promptsDirTarget, file.replace('.ejs', ''));
+            const templateContent = await fs.readFile(templatePath, 'utf-8');
+            const renderedContent = ejs.render(templateContent, { ...config });
+            await fs.writeFile(targetFilePath, renderedContent);
+        }
+    }
+};
+
+export const setupCiCd = async (templatesDir, targetDir, config) => {
+    const { ciProvider, includeSecurity } = config;
+    if (ciProvider === 'GitHub Actions') {
+        const workflowsDir = path.join(targetDir, '.github/workflows');
+        await fs.ensureDir(workflowsDir);
+        
+        const ciTemplate = await fs.readFile(path.join(templatesDir, 'common', '_github/workflows/ci.yml.ejs'), 'utf-8');
+        const ciContent = ejs.render(ciTemplate, { ...config });
+        await fs.writeFile(path.join(workflowsDir, 'ci.yml'), ciContent);
+        
+        if (includeSecurity) {
+            const securityTemplate = await fs.readFile(path.join(templatesDir, 'common', '_github/workflows/security.yml.ejs'), 'utf-8');
+            const securityContent = ejs.render(securityTemplate, { ...config });
+            await fs.writeFile(path.join(workflowsDir, 'security.yml'), securityContent);
+        }
+    } else if (ciProvider === 'Jenkins') {
+        const jenkinsTemplate = await fs.readFile(path.join(templatesDir, 'common', 'Jenkinsfile.ejs'), 'utf-8');
+        const jenkinsContent = ejs.render(jenkinsTemplate, { ...config });
+        await fs.writeFile(path.join(targetDir, 'Jenkinsfile'), jenkinsContent);
+    } else if (ciProvider === 'GitLab CI') {
+        const gitlabTemplate = await fs.readFile(path.join(templatesDir, 'common', '.gitlab-ci.yml.ejs'), 'utf-8');
+        const gitlabContent = ejs.render(gitlabTemplate, { ...config });
+        await fs.writeFile(path.join(targetDir, '.gitlab-ci.yml'), gitlabContent);
+    }
+};
+
+export const renderTestSample = async (templatesDir, targetDir, config) => {
+    await fs.ensureDir(path.join(targetDir, 'tests'));
+    if (config.language === 'TypeScript') {
+        const testsTsConfig = {
+            "extends": "../tsconfig.json",
+            "compilerOptions": {
+                "types": ["jest", "node"],
+                "rootDir": "..",
+                "noEmit": true
+            },
+            "include": ["**/*.ts", "../src/**/*.ts"]
+        };
+        await fs.writeFile(path.join(targetDir, 'tests', 'tsconfig.json'), JSON.stringify(testsTsConfig, null, 4));
+    }
+};
+
+export const renderEnvExample = async (templatesDir, targetDir, config) => {
+    const envExamplePath = path.join(targetDir, '.env.example');
+    const envPath = path.join(targetDir, '.env');
+    const envTemplate = await fs.readFile(path.join(templatesDir, 'common', '.env.example.ejs'), 'utf-8');
+    
+    const envContent = ejs.render(envTemplate, { ...config });
+    
+    await fs.writeFile(envExamplePath, envContent);
+    await fs.writeFile(envPath, envContent);
+};

package/lib/modules/database-setup.js

@@ -0,0 +1,116 @@
+import fs from 'fs-extra';
+import path from 'path';
+import ejs from 'ejs';
+
+export const setupDatabase = async (templatesDir, targetDir, config) => {
+    const { database, dbName, language, architecture } = config;
+    const langExt = language === 'TypeScript' ? 'ts' : 'js';
+
+    // 1. Migrations
+    if (database === 'MongoDB') {
+        // Copy migrate-mongo config
+        const migrateConfigTemplate = await fs.readFile(path.join(templatesDir, 'common', 'migrate-mongo-config.js.ejs'), 'utf-8');
+        const migrateConfigContent = ejs.render(migrateConfigTemplate, { ...config });
+        await fs.writeFile(path.join(targetDir, 'migrate-mongo-config.js'), migrateConfigContent);
+
+        // Setup migrations directory
+        await fs.ensureDir(path.join(targetDir, 'migrations'));
+        
+        // Create initial migration file with timestamp
+        const timestamp = new Date().toISOString().replace(/[-T:.Z]/g, '').slice(0, 14); // YYYYMMDDHHMMSS
+        const migrationTemplate = await fs.readFile(path.join(templatesDir, 'common', 'migrations', 'init.js.ejs'), 'utf-8');
+        await fs.writeFile(path.join(targetDir, 'migrations', `${timestamp}-initial-setup.js`), migrationTemplate);
+
+    } else if (database !== 'None') {
+        // Flyway for SQL
+        await fs.ensureDir(path.join(targetDir, 'flyway/sql'));
+        const dbType = database === 'PostgreSQL' ? 'postgres' : 'mysql';
+        const sourceDir = path.join(templatesDir, 'db', dbType);
+        
+        const files = await fs.readdir(sourceDir);
+        for (const file of files) {
+            if (file.endsWith('.ejs')) {
+                const template = await fs.readFile(path.join(sourceDir, file), 'utf-8');
+                const content = ejs.render(template, { ...config });
+                const targetFileName = file.replace('.ejs', '');
+                await fs.writeFile(path.join(targetDir, 'flyway/sql', targetFileName), content);
+            } else {
+                await fs.copy(path.join(sourceDir, file), path.join(targetDir, 'flyway/sql', file));
+            }
+        }
+    }
+
+    // 2. Database Config
+    if (database !== 'None') {
+        const dbConfigFileName = language === 'TypeScript' ? (database === 'MongoDB' ? 'mongoose.ts' : 'database.ts') : (database === 'MongoDB' ? 'mongoose.js' : 'database.js');
+        const dbConfigTemplateSource = path.join(templatesDir, 'common', 'database', langExt, `${dbConfigFileName}.ejs`);
+        
+        let dbConfigTarget;
+
+        if (architecture === 'MVC') {
+            await fs.ensureDir(path.join(targetDir, 'src/config'));
+            dbConfigTarget = path.join(targetDir, 'src/config', database === 'MongoDB' ? (language === 'TypeScript' ? 'database.ts' : 'database.js') : dbConfigFileName);
+        } else {
+            // Clean Architecture
+            await fs.ensureDir(path.join(targetDir, 'src/infrastructure/database'));
+            dbConfigTarget = path.join(targetDir, 'src/infrastructure/database', language === 'TypeScript' ? 'database.ts' : 'database.js');
+        }
+
+        if (await fs.pathExists(dbConfigTemplateSource)) {
+            const dbTemplate = await fs.readFile(dbConfigTemplateSource, 'utf-8');
+            const dbContent = ejs.render(dbTemplate, { ...config });
+            await fs.writeFile(dbConfigTarget, dbContent);
+
+            // Render Spec
+            const specTemplateName = dbConfigFileName.replace(`.${langExt}`, `.spec.${langExt}.ejs`);
+            const specTemplateSource = path.join(templatesDir, 'common', 'database', langExt, specTemplateName);
+            if (await fs.pathExists(specTemplateSource)) {
+                const specTemplate = await fs.readFile(specTemplateSource, 'utf-8');
+                const specContent = ejs.render(specTemplate, { ...config });
+                const specTarget = dbConfigTarget.replace(`${path.sep}src${path.sep}`, `${path.sep}tests${path.sep}unit${path.sep}`).replace(`.${langExt}`, `.spec.${langExt}`);
+                await fs.ensureDir(path.dirname(specTarget));
+                await fs.writeFile(specTarget, specContent);
+            }
+        }
+    } else if (architecture === 'MVC') {
+         // Even if DB is None, MVC needs src/config for other things (like swagger or general config)
+         await fs.ensureDir(path.join(targetDir, 'src/config'));
+    }
+
+    // 3. Models / Entities
+    await generateModels(templatesDir, targetDir, config);
+};
+
+export const generateModels = async (templatesDir, targetDir, config) => {
+    const { database, language, architecture } = config;
+    const langExt = language === 'TypeScript' ? 'ts' : 'js';
+    const modelFileName = language === 'TypeScript' ? 'User.ts' : 'User.js';
+
+    const sourceModelName = database === 'MongoDB' ? `${modelFileName}.mongoose.ejs` : `${modelFileName}.ejs`;
+    const modelTemplateSource = path.join(templatesDir, 'common', 'database', langExt, 'models', sourceModelName);
+    let modelTarget;
+
+    if (architecture === 'MVC') {
+        await fs.ensureDir(path.join(targetDir, 'src/models'));
+        modelTarget = path.join(targetDir, 'src/models', modelFileName);
+    } else {
+        await fs.ensureDir(path.join(targetDir, 'src/infrastructure/database/models'));
+        modelTarget = path.join(targetDir, 'src/infrastructure/database/models', modelFileName);
+    }
+
+    if (await fs.pathExists(modelTemplateSource)) {
+        const modelTemplate = await fs.readFile(modelTemplateSource, 'utf-8');
+        const modelContent = ejs.render(modelTemplate, { ...config });
+        await fs.writeFile(modelTarget, modelContent);
+
+        // Render Spec
+        const modelSpecTemplateSource = path.join(templatesDir, 'common', 'database', langExt, 'models', `User.spec.${langExt}.ejs`);
+        if (await fs.pathExists(modelSpecTemplateSource)) {
+            const modelSpecTemplate = await fs.readFile(modelSpecTemplateSource, 'utf-8');
+            const modelSpecContent = ejs.render(modelSpecTemplate, { ...config });
+            const modelSpecTarget = modelTarget.replace(`${path.sep}src${path.sep}`, `${path.sep}tests${path.sep}unit${path.sep}`).replace(`.${langExt}`, `.spec.${langExt}`);
+            await fs.ensureDir(path.dirname(modelSpecTarget));
+            await fs.writeFile(modelSpecTarget, modelSpecContent);
+        }
+    }
+};

package/lib/modules/kafka-setup.js

@@ -0,0 +1,249 @@
+import fs from 'fs-extra';
+import path from 'path';
+import ejs from 'ejs';
+
+export const setupKafka = async (templatesDir, targetDir, config) => {
+    const { communication, architecture, language } = config;
+    if (communication !== 'Kafka') return;
+
+    const langExt = language === 'TypeScript' ? 'ts' : 'js';
+    const kafkaSource = path.join(templatesDir, 'common', 'kafka', langExt);
+    
+    // 1. Copy necessary directories individually (to avoid orphaned templates in src)
+    if (await fs.pathExists(path.join(kafkaSource, 'services'))) {
+        await fs.copy(path.join(kafkaSource, 'services'), path.join(targetDir, 'src/services'));
+    }
+    if (await fs.pathExists(path.join(kafkaSource, 'config'))) {
+        await fs.copy(path.join(kafkaSource, 'config'), path.join(targetDir, 'src/config'));
+    }
+
+    // Render Kafka Service with dynamic logger path
+    const kafkaServiceFileName = `kafkaService.${langExt}`;
+    const kafkaServiceTemplate = path.join(targetDir, 'src', 'services', `${kafkaServiceFileName}.ejs`);
+    // Render Kafka Service Spec
+    const kafkaSpecFileName = `kafkaService.spec.${langExt}`;
+    const kafkaSpecTemplate = path.join(targetDir, 'src', 'services', `${kafkaSpecFileName}.ejs`);
+   
+    if (await fs.pathExists(kafkaServiceTemplate)) {
+        let serviceLoggerPath, serviceConfigPath;
+        if (language === 'TypeScript') {
+            serviceLoggerPath = architecture === 'Clean Architecture' ? '@/infrastructure/log/logger' : '@/utils/logger';
+            serviceConfigPath = architecture === 'Clean Architecture' ? '@/infrastructure/config/kafka' : '@/config/kafka';
+        } else {
+            serviceLoggerPath = architecture === 'Clean Architecture' ? '../../infrastructure/log/logger' : '../utils/logger';
+            serviceConfigPath = architecture === 'Clean Architecture' ? '../../infrastructure/config/kafka' : '../config/kafka';
+        }
+        
+        const content = ejs.render(await fs.readFile(kafkaServiceTemplate, 'utf-8'), { ...config, loggerPath: serviceLoggerPath, configPath: serviceConfigPath });
+        await fs.writeFile(path.join(targetDir, 'src', 'services', kafkaServiceFileName), content);
+        await fs.remove(kafkaServiceTemplate);
+    }
+
+    if (await fs.pathExists(kafkaSpecTemplate)) {
+        let specLoggerPath, specConfigPath, specServicePath;
+        if (language === 'TypeScript') {
+            specLoggerPath = architecture === 'Clean Architecture' ? '@/infrastructure/log/logger' : '@/utils/logger';
+            specConfigPath = architecture === 'Clean Architecture' ? '@/infrastructure/config/kafka' : '@/config/kafka';
+            specServicePath = architecture === 'Clean Architecture' ? '@/infrastructure/messaging/kafkaClient' : '@/services/kafkaService';
+        } else {
+            specLoggerPath = architecture === 'Clean Architecture' ? '../../infrastructure/log/logger' : '../utils/logger';
+            specConfigPath = architecture === 'Clean Architecture' ? '../../infrastructure/config/kafka' : '../config/kafka';
+            specServicePath = architecture === 'Clean Architecture' ? '../../infrastructure/messaging/kafkaClient' : '../services/kafkaService';
+        }
+
+        const specContent = ejs.render(await fs.readFile(kafkaSpecTemplate, 'utf-8'), { ...config, loggerPath: specLoggerPath, configPath: specConfigPath, servicePath: specServicePath });
+        await fs.writeFile(path.join(targetDir, 'src', 'services', kafkaSpecFileName), specContent);
+        await fs.remove(kafkaSpecTemplate);
+    }
+
+    // Render Kafka Config Spec
+    const kafkaConfigSpecFileName = `kafka.spec.${langExt}`;
+    const kafkaConfigSpecTemplate = path.join(templatesDir, 'common', 'kafka', langExt, 'config', `${kafkaConfigSpecFileName}.ejs`);
+    if (await fs.pathExists(kafkaConfigSpecTemplate)) {
+        const specContent = ejs.render(await fs.readFile(kafkaConfigSpecTemplate, 'utf-8'), { ...config });
+        let specTarget;
+        if (architecture === 'MVC') {
+            specTarget = path.join(targetDir, 'tests', 'unit', 'config', kafkaConfigSpecFileName);
+        } else {
+            specTarget = path.join(targetDir, 'tests', 'unit', 'infrastructure', 'config', kafkaConfigSpecFileName);
+        }
+        await fs.ensureDir(path.dirname(specTarget));
+        await fs.writeFile(specTarget, specContent);
+        
+        const targetSpecTemplate = path.join(targetDir, 'src', 'config', `${kafkaConfigSpecFileName}.ejs`);
+        if (await fs.pathExists(targetSpecTemplate)) {
+            await fs.remove(targetSpecTemplate);
+        }
+    }
+
+    if (architecture === 'Clean Architecture') {
+        // Clean Architecture Restructuring
+        await fs.ensureDir(path.join(targetDir, 'src/infrastructure/messaging'));
+        await fs.ensureDir(path.join(targetDir, 'tests/unit/infrastructure/messaging'));
+        await fs.ensureDir(path.join(targetDir, 'src/infrastructure/config'));
+
+        const serviceExt = language === 'TypeScript' ? 'ts' : 'js';
+        
+        await fs.move(
+            path.join(targetDir, `src/services/kafkaService.${serviceExt}`), 
+            path.join(targetDir, `src/infrastructure/messaging/kafkaClient.${serviceExt}`),
+            { overwrite: true }
+        );
+
+        if (await fs.pathExists(path.join(targetDir, `src/services/kafkaService.spec.${serviceExt}`))) {
+            await fs.move(
+                path.join(targetDir, `src/services/kafkaService.spec.${serviceExt}`),
+                path.join(targetDir, `tests/unit/infrastructure/messaging/kafkaClient.spec.${serviceExt}`),
+                { overwrite: true }
+            );
+        }
+
+        if (await fs.pathExists(path.join(targetDir, `src/config/kafka.${serviceExt}`))) {
+            await fs.move(
+                path.join(targetDir, `src/config/kafka.${serviceExt}`),
+                path.join(targetDir, `src/infrastructure/config/kafka.${serviceExt}`),
+                { overwrite: true }
+            );
+        }
+
+        await fs.remove(path.join(targetDir, 'src/services'));
+
+        // Messaging Infrastructure Enhancement
+        const messagingDir = path.join(targetDir, 'src/interfaces/messaging');
+        await fs.ensureDir(path.join(messagingDir, 'consumers/instances'));
+        await fs.ensureDir(path.join(messagingDir, 'schemas'));
+
+        const loggerPath = language === 'TypeScript' ? '@/infrastructure/log/logger' : '../../../../infrastructure/log/logger';
+        const errorMessagesPath = language === 'TypeScript' ? '@/utils/errorMessages' : '../../../../utils/errorMessages';
+        const userEventSchemaPath = language === 'TypeScript' ? '@/messaging/schemas/userEventSchema' : '../../schemas/userEventSchema';
+        const messagingTemplates = [
+            { src: 'baseConsumer', subDir: 'messaging', dest: 'interfaces/messaging/baseConsumer' },
+            { src: 'userEventSchema', subDir: 'messaging', dest: 'interfaces/messaging/schemas/userEventSchema' },
+            { src: 'welcomeEmailConsumer', subDir: 'messaging', dest: 'interfaces/messaging/consumers/instances/welcomeEmailConsumer' },
+            { src: 'kafkaEvents', subDir: 'utils', dest: 'utils/kafkaEvents' }
+        ];
+
+        for (const t of messagingTemplates) {
+            const templateSubDir = t.subDir || 'messaging';
+            const templateSource = path.join(templatesDir, 'common', 'kafka', langExt, templateSubDir, `${t.src}.${langExt}.ejs`);
+            if (await fs.pathExists(templateSource)) {
+                // Calculate dynamic relative paths for JS
+                let dynamicLoggerPath = loggerPath;
+                let dynamicErrorMessagesPath = errorMessagesPath;
+                let dynamicUserEventSchemaPath = userEventSchemaPath;
+                let dynamicKafkaEventsPath = language === 'TypeScript' ? '@/utils/kafkaEvents' : '../../utils/kafkaEvents';
+                let dynamicBaseConsumerPath = language === 'TypeScript' ? '@/interfaces/messaging/baseConsumer' : '../../baseConsumer';
+
+                if (language === 'JavaScript') {
+                    const destDir = path.dirname(path.join('src', t.dest));
+                    dynamicLoggerPath = path.relative(destDir, 'src/infrastructure/log/logger').replace(/\\/g, '/');
+                    dynamicErrorMessagesPath = path.relative(destDir, 'src/utils/errorMessages').replace(/\\/g, '/');
+                    dynamicUserEventSchemaPath = path.relative(destDir, 'src/interfaces/messaging/schemas/userEventSchema').replace(/\\/g, '/');
+                    dynamicKafkaEventsPath = path.relative(destDir, 'src/utils/kafkaEvents').replace(/\\/g, '/');
+                    dynamicBaseConsumerPath = path.relative(destDir, 'src/interfaces/messaging/baseConsumer').replace(/\\/g, '/');
+                }
+
+                const content = ejs.render(await fs.readFile(templateSource, 'utf-8'), { 
+                    ...config, 
+                    loggerPath: dynamicLoggerPath, 
+                    errorMessagesPath: dynamicErrorMessagesPath, 
+                    userEventSchemaPath: dynamicUserEventSchemaPath,
+                    kafkaEventsPath: dynamicKafkaEventsPath,
+                    baseConsumerPath: dynamicBaseConsumerPath
+                });
+                const destPath = path.join(targetDir, 'src', `${t.dest}.${langExt}`);
+                await fs.ensureDir(path.dirname(destPath));
+                await fs.writeFile(destPath, content);
+            }
+
+            // Render Specs for messaging components
+            const specTemplateSource = path.join(templatesDir, 'common', 'kafka', langExt, 'messaging', `${t.src}.spec.${langExt}.ejs`);
+            if (await fs.pathExists(specTemplateSource)) {
+                const specContent = ejs.render(await fs.readFile(specTemplateSource, 'utf-8'), { ...config, loggerPath });
+                const specDest = path.join(targetDir, 'tests', 'unit', `${t.dest}.spec.${langExt}`);
+                await fs.ensureDir(path.dirname(specDest));
+                await fs.writeFile(specDest, specContent);
+            }
+        }
+        
+    } else if (architecture === 'MVC') {
+        const serviceExt = language === 'TypeScript' ? 'ts' : 'js';
+        
+        const messagingDir = path.join(targetDir, 'src/messaging');
+        await fs.ensureDir(path.join(messagingDir, 'consumers/instances'));
+        await fs.ensureDir(path.join(messagingDir, 'schemas'));
+
+        const loggerPath = language === 'TypeScript' ? '@/utils/logger' : '../../../utils/logger';
+        const errorMessagesPath = language === 'TypeScript' ? '@/utils/errorMessages' : '../../../utils/errorMessages';
+        const userEventSchemaPath = language === 'TypeScript' ? '@/messaging/schemas/userEventSchema' : '../../schemas/userEventSchema';
+        const messagingTemplates = [
+            { src: 'baseConsumer', subDir: 'messaging', dest: 'messaging/baseConsumer' },
+            { src: 'userEventSchema', subDir: 'messaging', dest: 'messaging/schemas/userEventSchema' },
+            { src: 'welcomeEmailConsumer', subDir: 'messaging', dest: 'messaging/consumers/instances/welcomeEmailConsumer' },
+            { src: 'kafkaEvents', subDir: 'utils', dest: 'utils/kafkaEvents' }
+        ];
+
+        for (const t of messagingTemplates) {
+            const templateSubDir = t.subDir || 'messaging';
+            const templateSource = path.join(templatesDir, 'common', 'kafka', langExt, templateSubDir, `${t.src}.${langExt}.ejs`);
+            if (await fs.pathExists(templateSource)) {
+                // Calculate dynamic relative paths for JS
+                let dynamicLoggerPath = loggerPath;
+                let dynamicErrorMessagesPath = errorMessagesPath;
+                let dynamicUserEventSchemaPath = userEventSchemaPath;
+                let dynamicKafkaEventsPath = language === 'TypeScript' ? '@/utils/kafkaEvents' : '../../utils/kafkaEvents';
+                let dynamicBaseConsumerPath = language === 'TypeScript' ? '@/messaging/baseConsumer' : '../../baseConsumer';
+
+                if (language === 'JavaScript') {
+                    const destDir = path.dirname(path.join('src', t.dest));
+                    dynamicLoggerPath = path.relative(destDir, 'src/utils/logger').replace(/\\/g, '/');
+                    dynamicErrorMessagesPath = path.relative(destDir, 'src/utils/errorMessages').replace(/\\/g, '/');
+                    dynamicUserEventSchemaPath = path.relative(destDir, 'src/messaging/schemas/userEventSchema').replace(/\\/g, '/');
+                    dynamicKafkaEventsPath = path.relative(destDir, 'src/utils/kafkaEvents').replace(/\\/g, '/');
+                    dynamicBaseConsumerPath = path.relative(destDir, 'src/messaging/baseConsumer').replace(/\\/g, '/');
+                }
+
+                const content = ejs.render(await fs.readFile(templateSource, 'utf-8'), { 
+                    ...config, 
+                    loggerPath: dynamicLoggerPath, 
+                    errorMessagesPath: dynamicErrorMessagesPath, 
+                    userEventSchemaPath: dynamicUserEventSchemaPath,
+                    kafkaEventsPath: dynamicKafkaEventsPath,
+                    baseConsumerPath: dynamicBaseConsumerPath
+                });
+                const destPath = path.join(targetDir, 'src', `${t.dest}.${langExt}`);
+                await fs.ensureDir(path.dirname(destPath));
+                await fs.writeFile(destPath, content);
+            }
+
+            // Render Specs for messaging components
+            const specTemplateSource = path.join(templatesDir, 'common', 'kafka', langExt, 'messaging', `${t.src}.spec.${langExt}.ejs`);
+            if (await fs.pathExists(specTemplateSource)) {
+                const specContent = ejs.render(await fs.readFile(specTemplateSource, 'utf-8'), { ...config, loggerPath });
+                const specDest = path.join(targetDir, 'tests', 'unit', `${t.dest}.spec.${langExt}`);
+                await fs.ensureDir(path.dirname(specDest));
+                await fs.writeFile(specDest, specContent);
+            }
+        }
+
+        if (await fs.pathExists(path.join(targetDir, `src/services/kafkaService.spec.${serviceExt}`))) {
+            await fs.ensureDir(path.join(targetDir, 'tests/unit/services'));
+            await fs.move(
+                path.join(targetDir, `src/services/kafkaService.spec.${serviceExt}`),
+                path.join(targetDir, `tests/unit/services/kafkaService.spec.${serviceExt}`),
+                { overwrite: true }
+            );
+        }
+
+    }
+};
+
+export const setupViews = async (templatesDir, targetDir, config) => {
+    const { architecture, viewEngine } = config;
+    if (architecture === 'MVC' && viewEngine && viewEngine !== 'None') {
+        const publicDir = path.join(templatesDir, 'common', 'public');
+        if (await fs.pathExists(publicDir)) {
+            await fs.copy(publicDir, path.join(targetDir, 'public'));
+        }
+    }
+};

package/lib/modules/project-setup.js

@@ -0,0 +1,32 @@
+import fs from 'fs-extra';
+import path from 'path';
+
+export const setupProjectDirectory = async (targetDir, projectName) => {
+    if (await fs.pathExists(targetDir)) {
+        throw new Error(`Directory ${projectName} already exists.`);
+    }
+    await fs.ensureDir(targetDir);
+};
+
+export const copyBaseStructure = async (templatesDir, targetDir, architecture, language) => {
+    const structureMap = {
+        'MVC': 'mvc',
+        'Clean Architecture': 'clean-architecture'
+    };
+    const archTemplate = structureMap[architecture];
+    const langExt = language === 'TypeScript' ? 'ts' : 'js';
+    const templatePath = path.join(templatesDir, archTemplate, langExt);
+
+    await fs.copy(templatePath, targetDir);
+    return { archTemplate, langExt, templatePath };
+};
+
+export const copyCommonFiles = async (templatesDir, targetDir, language) => {
+    await fs.copy(path.join(templatesDir, 'common', '_gitignore'), path.join(targetDir, '.gitignore'));
+    await fs.copy(path.join(templatesDir, 'common', '.dockerignore'), path.join(targetDir, '.dockerignore'));
+    await fs.copy(path.join(templatesDir, 'common', '.gitattributes'), path.join(targetDir, '.gitattributes'));
+    
+    if (language === 'TypeScript') {
+        await fs.copy(path.join(templatesDir, 'common', 'tsconfig.json'), path.join(targetDir, 'tsconfig.json'));
+    }
+};