@0kmpo/openapi-clean-arch-generator 1.3.13 → 1.3.15

package/README.md

@@ -76,7 +76,10 @@ Options:
   -o, --output <dir>         Output directory [default: ./src/app]
   -t, --templates <dir>      Custom templates directory [default: ./templates]
   -s, --select-endpoints     Interactively select tags and endpoints to generate
+  -c, --config <file>        Use a JSON configuration file (skips interactive prompts)
+  --init-config [file]       Generate a JSON configuration file instead of generating code
   --skip-install             Skip dependency installation
+  --skip-lint                Skip post-generation linting and formatting
   --dry-run                  Simulate without writing files
   -h, --help                 Show help
 ```
@@ -96,6 +99,15 @@ generate-clean-arch -i api.yaml -t ./my-templates
 # Dry run (no files written)
 generate-clean-arch -i swagger.yaml --dry-run
 
+# Skip linting after generation
+generate-clean-arch -i swagger.yaml --skip-lint
+
+# Generate a config file to reuse later
+generate-clean-arch --init-config generation-config.json
+
+# Run using a config file (no interactive prompts)
+generate-clean-arch -c generation-config.json
+
 # Full example with all options
 generate-clean-arch -i ./docs/api.yaml -o ./frontend/src/app -t ./custom-templates
 ```

package/dist/main.js

@@ -17,6 +17,7 @@ const clean_arch_generator_1 = require("./src/generators/clean-arch.generator");
 const report_generator_1 = require("./src/generators/report.generator");
 const lint_generator_1 = require("./src/generators/lint.generator");
 const environment_finder_1 = require("./src/utils/environment-finder");
+const example_validator_1 = require("./src/utils/example-validator");
 const prompt_1 = require("./src/utils/prompt");
 const config_1 = require("./src/utils/config");
 const package_json_1 = __importDefault(require("./package.json"));
@@ -109,6 +110,7 @@ async function main() {
         return;
     }
     (0, filesystem_1.createDirectoryStructure)(options.output);
+    (0, example_validator_1.clearExampleMismatches)();
     // ── SELECTION: tags and endpoints ─────────────────────────────────────────
     let selectionFilter = {};
     let tagApiKeyMap;
@@ -150,10 +152,27 @@ async function main() {
     }
     // ──────────────────────────────────────────────────────────────────────────
     const tempDir = (0, dto_generator_1.generateCode)(options.input, options.templates);
-    (0, dto_generator_1.organizeFiles)(tempDir, options.output);
+    // Compute schema→tag map before organizeFiles so DTOs land in the right subfolder
+    const tagsMapForSchema = (0, clean_arch_generator_1.buildTagsMapFromAnalysis)(analysis, selectionFilter);
+    const schemaTagMap = (0, clean_arch_generator_1.buildSchemaTagMap)(analysis.swagger.components
+        ?.schemas || {}, tagsMapForSchema);
+    (0, dto_generator_1.organizeFiles)(tempDir, options.output, schemaTagMap);
     (0, dto_generator_1.addDtoImports)(options.output);
-    (0, clean_arch_generator_1.generateCleanArchitecture)(analysis, options.output, options.templates, tagApiKeyMap, selectionFilter);
+    (0, clean_arch_generator_1.generateCleanArchitecture)(analysis, options.output, options.templates, tagApiKeyMap, selectionFilter, schemaTagMap);
     (0, filesystem_1.cleanup)(tempDir);
+    // ── EXAMPLE/TYPE MISMATCH WARNINGS ─────────────────────────────────────────
+    const mismatches = (0, example_validator_1.getExampleMismatches)();
+    if (mismatches.length > 0) {
+        console.log('');
+        (0, logger_1.logWarning)(`${mismatches.length} example/type mismatch(es) detected in OpenAPI schemas:`);
+        for (const m of mismatches) {
+            const action = m.action === 'coerced'
+                ? `→ coerced to ${JSON.stringify(m.coercedValue)}`
+                : '→ example ignored, using type default';
+            (0, logger_1.logWarning)(`  ${m.schemaName}.${m.propertyName}: type '${m.declaredType}' but example is ${m.exampleJsType} (${JSON.stringify(m.exampleValue)}) ${action}`);
+            (0, logger_1.logDetail)('VALIDATE', `${m.schemaName}.${m.propertyName}: declared=${m.declaredType} example=${JSON.stringify(m.exampleValue)} (${m.exampleJsType}) action=${m.action}`);
+        }
+    }
     const noLintResult = {
         prettier: { ran: false, filesFormatted: 0 },
         eslint: { ran: false, filesFixed: 0 }
@@ -170,6 +189,9 @@ async function main() {
     console.log(`   - Use Cases:        ${report.structure.useCases}`);
     console.log(`   - Providers:        ${report.structure.providers}`);
     console.log(`   - Mocks:            ${report.structure.mocks}`);
+    if (report.warnings.total > 0) {
+        console.log(`\n   ${logger_1.colors.yellow}⚠️  ${report.warnings.total} example/type mismatch(es) (see above)${logger_1.colors.reset}`);
+    }
     console.log(`\n📁 Files generated in: ${logger_1.colors.cyan}${options.output}${logger_1.colors.reset}\n`);
 }
 main().catch((error) => {

package/dist/package.json

@@ -0,0 +1,78 @@
+{
+    "name": "@0kmpo/openapi-clean-arch-generator",
+    "version": "1.3.15",
+    "description": "Angular Clean Architecture generator from OpenAPI/Swagger",
+    "main": "dist/main.js",
+    "bin": {
+        "generate-clean-arch": "./dist/main.js"
+    },
+    "scripts": {
+        "build": "tsc && cp -r templates dist/",
+        "postbuild": "bun -e \"const fs=require('fs'); const f='dist/main.js'; const c=fs.readFileSync(f,'utf8'); if(!c.startsWith('#!/usr/bin/env node')) fs.writeFileSync(f,'#!/usr/bin/env node\\n'+c); fs.chmodSync(f, '755');\"",
+        "prepublishOnly": "bun run build",
+        "generate": "bun dist/main.js",
+        "generate:dev": "bun main.ts",
+        "binaries": "bun run binary:mac-arm64 && bun run binary:mac-x64 && bun run binary:linux-x64 && bun run binary:linux-arm64 && bun run binary:windows",
+        "binary:mac-arm64": "bun build --compile --target=bun-darwin-arm64 --outfile dist/bin/generate-clean-arch-macos-arm64 main.ts",
+        "binary:mac-x64": "bun build --compile --target=bun-darwin-x64 --outfile dist/bin/generate-clean-arch-macos-x64 main.ts",
+        "binary:linux-x64": "bun build --compile --target=bun-linux-x64 --outfile dist/bin/generate-clean-arch-linux-x64 main.ts",
+        "binary:linux-arm64": "bun build --compile --target=bun-linux-arm64 --outfile dist/bin/generate-clean-arch-linux-arm64 main.ts",
+        "binary:windows": "bun build --compile --target=bun-windows-x64 --outfile dist/bin/generate-clean-arch-windows-x64.exe main.ts",
+        "lint": "bunx --bun eslint 'main.ts' 'src/**/*.ts' -f unix",
+        "lint:fix": "bunx --bun eslint 'main.ts' 'src/**/*.ts' --fix -f unix",
+        "format": "prettier --write .",
+        "setup": "bun add -g @openapitools/openapi-generator-cli"
+    },
+    "keywords": [
+        "openapi",
+        "swagger",
+        "angular",
+        "clean-architecture",
+        "code-generator"
+    ],
+    "author": "Blas Santomé Ocampo",
+    "contributors": [
+        {
+            "name": "Diego Davila Freitas",
+            "email": "diego.davilafreitas@gmail.com",
+            "url": "https://www.linkedin.com/in/diegodavilafreitas"
+        }
+    ],
+    "license": "MIT",
+    "files": [
+        "dist/main.js",
+        "dist/package.json",
+        "dist/src/",
+        "dist/templates/",
+        "README.md",
+        "LICENSE"
+    ],
+    "dependencies": {
+        "chalk": "^4.1.2",
+        "commander": "^11.1.0",
+        "fs-extra": "^11.2.0",
+        "js-yaml": "^4.1.0",
+        "mustache": "^4.2.0",
+        "prompts": "^2.4.2"
+    },
+    "engines": {
+        "bun": ">=1.0.0"
+    },
+    "devDependencies": {
+        "@eslint/js": "^10.0.1",
+        "@types/fs-extra": "^11.0.4",
+        "@types/js-yaml": "^4.0.9",
+        "@types/mustache": "^4.2.6",
+        "@types/node": "^25.5.0",
+        "@types/prompts": "^2.4.9",
+        "@typescript-eslint/eslint-plugin": "^8.57.1",
+        "@typescript-eslint/parser": "^8.57.1",
+        "eslint": "^10.1.0",
+        "eslint-config-prettier": "^10.1.8",
+        "eslint-formatter-unix": "^9.0.1",
+        "eslint-plugin-prettier": "^5.5.5",
+        "prettier": "^3.8.1",
+        "typescript": "^5.9.3",
+        "typescript-eslint": "^8.57.1"
+    }
+}

package/dist/src/generators/clean-arch.generator.js

@@ -5,6 +5,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractTagsFromAnalysis = extractTagsFromAnalysis;
 exports.extractTagsWithOperations = extractTagsWithOperations;
+exports.buildTagsMapFromAnalysis = buildTagsMapFromAnalysis;
+exports.buildSchemaTagMap = buildSchemaTagMap;
 exports.generateCleanArchitecture = generateCleanArchitecture;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
@@ -57,8 +59,139 @@ function extractTagsWithOperations(analysis) {
     });
     return [...map.values()];
 }
+/**
+ * Builds and returns the tagsMap from the swagger analysis, applying the optional selection filter.
+ * Exported so callers (e.g. main.ts) can compute it before organizeFiles runs.
+ */
+function buildTagsMapFromAnalysis(analysis, selectionFilter = {}) {
+    const tagsMap = {};
+    Object.keys(analysis.paths).forEach((pathKey) => {
+        const pathObj = analysis.paths[pathKey];
+        Object.keys(pathObj).forEach((method) => {
+            const op = pathObj[method];
+            if (op.tags && op.tags.length > 0) {
+                const tag = op.tags[0];
+                if (!tagsMap[tag])
+                    tagsMap[tag] = [];
+                const allParams = (op.parameters || []).map((p) => ({
+                    paramName: p.name,
+                    dataType: (0, type_mapper_1.mapSwaggerTypeToTs)(p.schema?.type || ''),
+                    description: p.description || '',
+                    required: p.required,
+                    testValue: resolveTestParamValue((0, type_mapper_1.mapSwaggerTypeToTs)(p.schema?.type || ''))
+                }));
+                if (op.requestBody) {
+                    let bodyType = 'unknown';
+                    const content = op.requestBody.content?.['application/json']?.schema;
+                    if (content) {
+                        if (content.$ref)
+                            bodyType = content.$ref.split('/').pop() || 'unknown';
+                        else if (content.type)
+                            bodyType = (0, type_mapper_1.mapSwaggerTypeToTs)(content.type);
+                    }
+                    allParams.push({
+                        paramName: 'body',
+                        dataType: bodyType,
+                        description: op.requestBody.description || '',
+                        required: true,
+                        testValue: resolveTestParamValue(bodyType)
+                    });
+                }
+                let returnType = 'void';
+                let returnBaseType = 'void';
+                let isListContainer = false;
+                const successCode = ['200', '201', '202', '203'].find((code) => op.responses?.[code]);
+                const responseSchema = successCode !== undefined
+                    ? op.responses?.[successCode]?.content?.['application/json']?.schema
+                    : undefined;
+                if (responseSchema) {
+                    if (responseSchema.$ref) {
+                        returnType = responseSchema.$ref.split('/').pop() || 'unknown';
+                        returnBaseType = returnType;
+                    }
+                    else if (responseSchema.type === 'array' && responseSchema.items?.$ref) {
+                        returnBaseType = responseSchema.items.$ref.split('/').pop() || 'unknown';
+                        returnType = `${returnBaseType}[]`;
+                        isListContainer = true;
+                    }
+                }
+                const hasQueryParams = (op.parameters || []).some((p) => p.in === 'query');
+                const hasBodyParam = !!op.requestBody;
+                // Sort: required params first, optional params last (TypeScript requirement)
+                allParams.sort((a, b) => {
+                    if (a.required === b.required)
+                        return 0;
+                    return a.required ? -1 : 1;
+                });
+                tagsMap[tag].push({
+                    nickname: op.operationId || `${method}${pathKey.replace(/\//g, '_')}`,
+                    summary: op.summary || '',
+                    notes: op.description || '',
+                    httpMethod: method.toLowerCase(),
+                    uppercaseHttpMethod: method.toUpperCase(),
+                    path: pathKey,
+                    allParams: allParams.map((p, i) => ({
+                        ...p,
+                        '-last': i === allParams.length - 1
+                    })),
+                    hasQueryParams,
+                    queryParams: (op.parameters || [])
+                        .filter((p) => p.in === 'query')
+                        .map((p, i, arr) => ({
+                        paramName: p.name,
+                        '-last': i === arr.length - 1
+                    })),
+                    hasBodyParam,
+                    bodyParam: 'body',
+                    hasOptions: hasQueryParams || hasBodyParam,
+                    hasBothParamsAndBody: hasQueryParams && hasBodyParam,
+                    returnType: returnType !== 'void' ? returnType : false,
+                    returnBaseType: returnBaseType !== 'void' ? returnBaseType : false,
+                    returnTypeVarName: returnType !== 'void' ? (0, name_formatter_1.toCamelCase)(returnType) : false,
+                    returnBaseTypeVarName: returnBaseType !== 'void' ? (0, name_formatter_1.toCamelCase)(returnBaseType) : false,
+                    isListContainer: isListContainer,
+                    vendorExtensions: {}
+                });
+            }
+        });
+    });
+    if (Object.keys(selectionFilter).length > 0) {
+        Object.keys(tagsMap).forEach((tag) => {
+            if (!selectionFilter[tag]) {
+                delete tagsMap[tag];
+            }
+            else {
+                tagsMap[tag] = tagsMap[tag].filter((op) => selectionFilter[tag].includes(op.nickname));
+                if (tagsMap[tag].length === 0)
+                    delete tagsMap[tag];
+            }
+        });
+    }
+    return tagsMap;
+}
+/**
+ * Maps each schema basename to the tag subfolder it belongs to.
+ * Schemas used by exactly one tag → that tag's camelCase name.
+ * Schemas used by 0 or multiple tags → 'shared'.
+ */
+function buildSchemaTagMap(schemas, tagsMap) {
+    const result = {};
+    Object.keys(schemas).forEach((schemaName) => {
+        const baseName = schemaName.replace(/Dto$/, '');
+        const tagsUsing = [];
+        Object.keys(tagsMap).forEach((tag) => {
+            const used = tagsMap[tag].some((op) => op.returnType === baseName ||
+                op.returnType === `${baseName}[]` ||
+                op.allParams.some((p) => p.dataType === baseName || p.dataType === `${baseName}[]`));
+            if (used)
+                tagsUsing.push(tag);
+        });
+        result[baseName] = tagsUsing.length === 1 ? (0, name_formatter_1.toCamelCase)(tagsUsing[0]) : 'shared';
+    });
+    return result;
+}
 /** Generates all Clean Architecture artefacts (models, mappers, repos, use cases, providers) using Mustache. */
-function generateCleanArchitecture(analysis, outputDir, templatesDir, tagApiKeyMap = {}, selectionFilter = {}) {
+function generateCleanArchitecture(analysis, outputDir, templatesDir, tagApiKeyMap = {}, selectionFilter = {}, precomputedSchemaTagMap = {}) {
     (0, logger_1.logStep)('Generating Clean Architecture artefacts using Mustache...');
     const generatedCount = {
         models: 0,
@@ -71,14 +204,22 @@ function generateCleanArchitecture(analysis, outputDir, templatesDir, tagApiKeyM
     };
     const schemas = analysis.swagger.components
         ?.schemas || {};
+    // Build tagsMap first — needed to compute schemaTagMap before the schema loop
+    const tagsMap = buildTagsMapFromAnalysis(analysis, selectionFilter);
+    // Map each schema basename → tag subfolder ('shared' if used by 0 or >1 tags)
+    const schemaTagMap = Object.keys(precomputedSchemaTagMap).length > 0
+        ? precomputedSchemaTagMap
+        : buildSchemaTagMap(schemas, tagsMap);
     // 1. Generate Models, Entities and Mappers from Schemas
     Object.keys(schemas).forEach((schemaName) => {
         const baseName = schemaName.replace(/Dto$/, '');
+        const tagFilename = schemaTagMap[baseName] || 'shared';
         const schemaObj = schemas[schemaName];
         const rawProperties = schemaObj.properties || {};
         const requiredProps = schemaObj.required || [];
         const varsMap = Object.keys(rawProperties).map((k) => {
             let tsType = (0, type_mapper_1.mapSwaggerTypeToTs)(rawProperties[k].type);
+            const isInlineObject = rawProperties[k].type === 'object' && !rawProperties[k].$ref;
             if (rawProperties[k].$ref) {
                 tsType = rawProperties[k].$ref.split('/').pop() || 'unknown';
             }
@@ -86,10 +227,12 @@ function generateCleanArchitecture(analysis, outputDir, templatesDir, tagApiKeyM
                 tsType = `${rawProperties[k].items.$ref.split('/').pop()}[]`;
             }
             return {
-                name: k,
+                name: (0, name_formatter_1.safePropertyName)(k),
+                originalName: k,
                 dataType: tsType,
                 description: rawProperties[k].description || '',
-                required: requiredProps.includes(k)
+                required: requiredProps.includes(k),
+                hasMockValue: !isInlineObject
             };
         });
         // Collect imports for types referenced via $ref in properties
@@ -102,10 +245,13 @@ function generateCleanArchitecture(analysis, outputDir, templatesDir, tagApiKeyM
                 referencedTypes.add(prop.items.$ref.split('/').pop() || '');
             }
         });
-        const modelImports = [...referencedTypes]
-            .filter(Boolean)
-            .map((name) => ({ classname: name, classFilename: (0, name_formatter_1.toCamelCase)(name) }));
+        const modelImports = [...referencedTypes].filter(Boolean).map((name) => ({
+            classname: name,
+            classFilename: (0, name_formatter_1.toCamelCase)(name),
+            tagFilename: schemaTagMap[name] || 'shared'
+        }));
         const modelViewData = {
+            tagFilename,
             models: [
                 {
                     model: {
@@ -128,7 +274,8 @@ function generateCleanArchitecture(analysis, outputDir, templatesDir, tagApiKeyM
                         operations: {
                             classname: baseName,
                             classFilename: (0, name_formatter_1.toCamelCase)(baseName),
-                            classVarName: (0, name_formatter_1.toCamelCase)(baseName)
+                            classVarName: (0, name_formatter_1.toCamelCase)(baseName),
+                            tagFilename
                         }
                     }
                 ]
@@ -139,7 +286,8 @@ function generateCleanArchitecture(analysis, outputDir, templatesDir, tagApiKeyM
         if (fs_extra_1.default.existsSync(modelTemplatePath)) {
             const template = fs_extra_1.default.readFileSync(modelTemplatePath, 'utf8');
             const output = mustache_1.default.render(template, modelViewData);
-            const destPath = path_1.default.join(outputDir, 'entities/models', `${(0, name_formatter_1.toCamelCase)(baseName)}.model.ts`);
+            const destPath = path_1.default.join(outputDir, 'entities/models', tagFilename, `${(0, name_formatter_1.toCamelCase)(baseName)}.model.ts`);
+            fs_extra_1.default.ensureDirSync(path_1.default.dirname(destPath));
             fs_extra_1.default.writeFileSync(destPath, output);
             generatedCount.models++;
             (0, logger_1.logDetail)('generate', `model-entity → ${path_1.default.relative(process.cwd(), destPath)}`);
@@ -149,19 +297,29 @@ function generateCleanArchitecture(analysis, outputDir, templatesDir, tagApiKeyM
         if (fs_extra_1.default.existsSync(mapperTemplatePath)) {
             const template = fs_extra_1.default.readFileSync(mapperTemplatePath, 'utf8');
             const output = mustache_1.default.render(template, mapperViewData);
-            const destPath = path_1.default.join(outputDir, 'data/mappers', `${(0, name_formatter_1.toCamelCase)(baseName)}.mapper.ts`);
+            const destPath = path_1.default.join(outputDir, 'data/mappers', tagFilename, `${(0, name_formatter_1.toCamelCase)(baseName)}.mapper.ts`);
+            fs_extra_1.default.ensureDirSync(path_1.default.dirname(destPath));
             fs_extra_1.default.writeFileSync(destPath, output);
             generatedCount.mappers++;
         }
         // DTO mock — values resolved from raw schema (example, format, type)
         const dtoMockVarsMap = Object.keys(rawProperties).map((k) => ({
-            name: k,
-            mockValue: (0, mock_value_resolver_1.resolveMockValue)(k, rawProperties[k], 'dto')
+            name: (0, name_formatter_1.safePropertyName)(k),
+            mockValue: (0, mock_value_resolver_1.resolveMockValue)(k, rawProperties[k], 'dto', schemaName)
         }));
-        const dtoMockImports = [...referencedTypes]
-            .filter(Boolean)
-            .map((name) => ({ classname: name, classFilename: (0, name_formatter_1.toCamelCase)(name) }));
+        const dtoMockImports = [...referencedTypes].filter(Boolean).map((name) => {
+            const targetTag = schemaTagMap[name] || 'shared';
+            const targetFile = `${(0, name_formatter_1.toCamelCase)(name)}.dto.mock`;
+            const importPath = targetTag === tagFilename ? `./${targetFile}` : `../${targetTag}/${targetFile}`;
+            return {
+                classname: name,
+                classFilename: (0, name_formatter_1.toCamelCase)(name),
+                tagFilename: targetTag,
+                importPath
+            };
+        });
         const dtoMockViewData = {
+            tagFilename,
             models: [
                 {
                     model: {
@@ -174,120 +332,29 @@ function generateCleanArchitecture(analysis, outputDir, templatesDir, tagApiKeyM
                 }
             ]
         };
-        renderTemplate(templatesDir, 'dto.mock.mustache', dtoMockViewData, path_1.default.join(outputDir, 'data/dtos', `${(0, name_formatter_1.toCamelCase)(baseName)}.dto.mock.ts`), generatedCount, 'mocks');
+        renderTemplate(templatesDir, 'dto.mock.mustache', dtoMockViewData, path_1.default.join(outputDir, 'data/dtos', tagFilename, `${(0, name_formatter_1.toCamelCase)(baseName)}.dto.mock.ts`), generatedCount, 'mocks');
         // Model mock — delegates to mapper + DTO mock (no property values needed)
-        renderTemplate(templatesDir, 'model.mock.mustache', modelViewData, path_1.default.join(outputDir, 'entities/models', `${(0, name_formatter_1.toCamelCase)(baseName)}.model.mock.ts`), generatedCount, 'mocks');
+        renderTemplate(templatesDir, 'model.mock.mustache', modelViewData, path_1.default.join(outputDir, 'entities/models', tagFilename, `${(0, name_formatter_1.toCamelCase)(baseName)}.model.mock.ts`), generatedCount, 'mocks');
         // Model spec
-        renderTemplate(templatesDir, 'model-entity.spec.mustache', modelViewData, path_1.default.join(outputDir, 'entities/models', `${(0, name_formatter_1.toCamelCase)(baseName)}.model.spec.ts`), generatedCount, 'specs');
+        renderTemplate(templatesDir, 'model-entity.spec.mustache', modelViewData, path_1.default.join(outputDir, 'entities/models', tagFilename, `${(0, name_formatter_1.toCamelCase)(baseName)}.model.spec.ts`), generatedCount, 'specs');
         // Mapper spec
-        renderTemplate(templatesDir, 'mapper.spec.mustache', mapperViewData, path_1.default.join(outputDir, 'data/mappers', `${(0, name_formatter_1.toCamelCase)(baseName)}.mapper.spec.ts`), generatedCount, 'specs');
+        renderTemplate(templatesDir, 'mapper.spec.mustache', mapperViewData, path_1.default.join(outputDir, 'data/mappers', tagFilename, `${(0, name_formatter_1.toCamelCase)(baseName)}.mapper.spec.ts`), generatedCount, 'specs');
     });
     // 2. Generate Use Cases and Repositories from Paths/Tags
-    const tagsMap = {};
-    Object.keys(analysis.paths).forEach((pathKey) => {
-        const pathObj = analysis.paths[pathKey];
-        Object.keys(pathObj).forEach((method) => {
-            const op = pathObj[method];
-            if (op.tags && op.tags.length > 0) {
-                const tag = op.tags[0];
-                if (!tagsMap[tag])
-                    tagsMap[tag] = [];
-                const allParams = (op.parameters || []).map((p) => ({
-                    paramName: p.name,
-                    dataType: (0, type_mapper_1.mapSwaggerTypeToTs)(p.schema?.type || ''),
-                    description: p.description || '',
-                    required: p.required,
-                    testValue: resolveTestParamValue((0, type_mapper_1.mapSwaggerTypeToTs)(p.schema?.type || ''))
-                }));
-                if (op.requestBody) {
-                    let bodyType = 'unknown';
-                    const content = op.requestBody.content?.['application/json']?.schema;
-                    if (content) {
-                        if (content.$ref)
-                            bodyType = content.$ref.split('/').pop() || 'unknown';
-                        else if (content.type)
-                            bodyType = (0, type_mapper_1.mapSwaggerTypeToTs)(content.type);
-                    }
-                    allParams.push({
-                        paramName: 'body',
-                        dataType: bodyType,
-                        description: op.requestBody.description || '',
-                        required: true,
-                        testValue: resolveTestParamValue(bodyType)
-                    });
-                }
-                let returnType = 'void';
-                let returnBaseType = 'void';
-                let isListContainer = false;
-                const successCode = ['200', '201', '202', '203'].find((code) => op.responses?.[code]);
-                const responseSchema = successCode !== undefined
-                    ? op.responses?.[successCode]?.content?.['application/json']?.schema
-                    : undefined;
-                if (responseSchema) {
-                    if (responseSchema.$ref) {
-                        returnType = responseSchema.$ref.split('/').pop() || 'unknown';
-                        returnBaseType = returnType;
-                    }
-                    else if (responseSchema.type === 'array' && responseSchema.items?.$ref) {
-                        returnBaseType = responseSchema.items.$ref.split('/').pop() || 'unknown';
-                        returnType = `${returnBaseType}[]`;
-                        isListContainer = true;
-                    }
-                }
-                const hasQueryParams = (op.parameters || []).some((p) => p.in === 'query');
-                const hasBodyParam = !!op.requestBody;
-                tagsMap[tag].push({
-                    nickname: op.operationId || `${method}${pathKey.replace(/\//g, '_')}`,
-                    summary: op.summary || '',
-                    notes: op.description || '',
-                    httpMethod: method.toLowerCase(),
-                    uppercaseHttpMethod: method.toUpperCase(),
-                    path: pathKey,
-                    allParams: allParams.map((p, i) => ({
-                        ...p,
-                        '-last': i === allParams.length - 1
-                    })),
-                    hasQueryParams,
-                    queryParams: (op.parameters || [])
-                        .filter((p) => p.in === 'query')
-                        .map((p, i, arr) => ({
-                        paramName: p.name,
-                        '-last': i === arr.length - 1
-                    })),
-                    hasBodyParam,
-                    bodyParam: 'body',
-                    hasOptions: hasQueryParams || hasBodyParam,
-                    hasBothParamsAndBody: hasQueryParams && hasBodyParam,
-                    returnType: returnType !== 'void' ? returnType : false,
-                    returnBaseType: returnBaseType !== 'void' ? returnBaseType : false,
-                    returnTypeVarName: returnType !== 'void' ? (0, name_formatter_1.toCamelCase)(returnType) : false,
-                    returnBaseTypeVarName: returnBaseType !== 'void' ? (0, name_formatter_1.toCamelCase)(returnBaseType) : false,
-                    isListContainer: isListContainer,
-                    vendorExtensions: {}
-                });
-            }
-        });
-    });
-    if (Object.keys(selectionFilter).length > 0) {
-        Object.keys(tagsMap).forEach((tag) => {
-            if (!selectionFilter[tag]) {
-                delete tagsMap[tag];
-            }
-            else {
-                tagsMap[tag] = tagsMap[tag].filter((op) => selectionFilter[tag].includes(op.nickname));
-                if (tagsMap[tag].length === 0)
-                    delete tagsMap[tag];
-            }
-        });
-    }
     // Generate per tag
     Object.keys(tagsMap).forEach((tag) => {
+        const tagFilename = (0, name_formatter_1.toCamelCase)(tag);
         const returnImports = [];
         const paramImports = [];
         Object.keys(schemas).forEach((s) => {
             const usedAsReturn = tagsMap[tag].some((op) => op.returnType === s || op.returnType === `${s}[]`);
             const usedAsParam = tagsMap[tag].some((op) => op.allParams.some((p) => p.dataType === s || p.dataType === `${s}[]`));
-            const entry = { classname: s, classFilename: (0, name_formatter_1.toCamelCase)(s), classVarName: (0, name_formatter_1.toCamelCase)(s) };
+            const entry = {
+                classname: s,
+                classFilename: (0, name_formatter_1.toCamelCase)(s),
+                classVarName: (0, name_formatter_1.toCamelCase)(s),
+                tagFilename: schemaTagMap[s] || 'shared'
+            };
             if (usedAsReturn) {
                 returnImports.push(entry);
             }
@@ -301,39 +368,35 @@ function generateCleanArchitecture(analysis, outputDir, templatesDir, tagApiKeyM
                 apis: [
                     {
                         operations: {
-                            classname: tag,
-                            classFilename: (0, name_formatter_1.toCamelCase)(tag),
-                            classVarName: (0, name_formatter_1.toCamelCase)(tag),
+                            classname: (0, name_formatter_1.toPascalCase)(tag),
+                            classFilename: tagFilename,
+                            classVarName: tagFilename,
                             constantName: tag.toUpperCase().replace(/[^A-Z0-9]/g, '_'),
                             operation: tagsMap[tag],
-                            // All entity imports (return + param) — for contracts and use-cases
                             imports: [...returnImports, ...paramImports],
-                            // Return-type-only imports — for repo impl (Dto + Entity + Mapper)
                             returnImports,
-                            // Param-only imports — for repo impl (Entity only, no Dto/Mapper)
                             paramImports,
-                            // Environment API key for the repository base URL (e.g. "aprovalmApi")
                             environmentApiKey: tagApiKeyMap[tag] || 'apiUrl'
                         }
                     }
                 ]
             }
         };
-        renderTemplate(templatesDir, 'api.use-cases.contract.mustache', apiViewData, path_1.default.join(outputDir, 'domain/use-cases', `${(0, name_formatter_1.toCamelCase)(tag)}.use-cases.contract.ts`), generatedCount, 'useCases');
-        renderTemplate(templatesDir, 'api.use-cases.impl.mustache', apiViewData, path_1.default.join(outputDir, 'domain/use-cases', `${(0, name_formatter_1.toCamelCase)(tag)}.use-cases.impl.ts`), generatedCount, 'useCases');
-        renderTemplate(templatesDir, 'api.repository.contract.mustache', apiViewData, path_1.default.join(outputDir, 'domain/repositories', `${(0, name_formatter_1.toCamelCase)(tag)}.repository.contract.ts`), generatedCount, 'repositories');
-        renderTemplate(templatesDir, 'api.repository.impl.mustache', apiViewData, path_1.default.join(outputDir, 'data/repositories', `${(0, name_formatter_1.toCamelCase)(tag)}.repository.impl.ts`), generatedCount, 'repositories');
-        renderTemplate(templatesDir, 'use-cases.provider.mustache', apiViewData, path_1.default.join(outputDir, 'di/use-cases', `${(0, name_formatter_1.toCamelCase)(tag)}.use-cases.provider.ts`), generatedCount, 'providers');
-        renderTemplate(templatesDir, 'repository.provider.mustache', apiViewData, path_1.default.join(outputDir, 'di/repositories', `${(0, name_formatter_1.toCamelCase)(tag)}.repository.provider.ts`), generatedCount, 'providers');
-        // Mocks — repository impl, use-cases impl, repository provider, use-cases provider
-        renderTemplate(templatesDir, 'api.repository.impl.mock.mustache', apiViewData, path_1.default.join(outputDir, 'data/repositories', `${(0, name_formatter_1.toCamelCase)(tag)}.repository.impl.mock.ts`), generatedCount, 'mocks');
-        renderTemplate(templatesDir, 'api.use-cases.mock.mustache', apiViewData, path_1.default.join(outputDir, 'domain/use-cases', `${(0, name_formatter_1.toCamelCase)(tag)}.use-cases.mock.ts`), generatedCount, 'mocks');
-        renderTemplate(templatesDir, 'repository.provider.mock.mustache', apiViewData, path_1.default.join(outputDir, 'di/repositories', `${(0, name_formatter_1.toCamelCase)(tag)}.repository.provider.mock.ts`), generatedCount, 'mocks');
-        renderTemplate(templatesDir, 'use-cases.provider.mock.mustache', apiViewData, path_1.default.join(outputDir, 'di/use-cases', `${(0, name_formatter_1.toCamelCase)(tag)}.use-cases.provider.mock.ts`), generatedCount, 'mocks');
+        renderTemplate(templatesDir, 'api.use-cases.contract.mustache', apiViewData, path_1.default.join(outputDir, 'domain/use-cases', tagFilename, `${tagFilename}.use-cases.contract.ts`), generatedCount, 'useCases');
+        renderTemplate(templatesDir, 'api.use-cases.impl.mustache', apiViewData, path_1.default.join(outputDir, 'domain/use-cases', tagFilename, `${tagFilename}.use-cases.impl.ts`), generatedCount, 'useCases');
+        renderTemplate(templatesDir, 'api.repository.contract.mustache', apiViewData, path_1.default.join(outputDir, 'domain/repositories', tagFilename, `${tagFilename}.repository.contract.ts`), generatedCount, 'repositories');
+        renderTemplate(templatesDir, 'api.repository.impl.mustache', apiViewData, path_1.default.join(outputDir, 'data/repositories', tagFilename, `${tagFilename}.repository.impl.ts`), generatedCount, 'repositories');
+        renderTemplate(templatesDir, 'use-cases.provider.mustache', apiViewData, path_1.default.join(outputDir, 'di/use-cases', tagFilename, `${tagFilename}.use-cases.provider.ts`), generatedCount, 'providers');
+        renderTemplate(templatesDir, 'repository.provider.mustache', apiViewData, path_1.default.join(outputDir, 'di/repositories', tagFilename, `${tagFilename}.repository.provider.ts`), generatedCount, 'providers');
+        // Mocks
+        renderTemplate(templatesDir, 'api.repository.impl.mock.mustache', apiViewData, path_1.default.join(outputDir, 'data/repositories', tagFilename, `${tagFilename}.repository.impl.mock.ts`), generatedCount, 'mocks');
+        renderTemplate(templatesDir, 'api.use-cases.mock.mustache', apiViewData, path_1.default.join(outputDir, 'domain/use-cases', tagFilename, `${tagFilename}.use-cases.mock.ts`), generatedCount, 'mocks');
+        renderTemplate(templatesDir, 'repository.provider.mock.mustache', apiViewData, path_1.default.join(outputDir, 'di/repositories', tagFilename, `${tagFilename}.repository.provider.mock.ts`), generatedCount, 'mocks');
+        renderTemplate(templatesDir, 'use-cases.provider.mock.mustache', apiViewData, path_1.default.join(outputDir, 'di/use-cases', tagFilename, `${tagFilename}.use-cases.provider.mock.ts`), generatedCount, 'mocks');
         // Repository impl spec
-        renderTemplate(templatesDir, 'api.repository.impl.spec.mustache', apiViewData, path_1.default.join(outputDir, 'data/repositories', `${(0, name_formatter_1.toCamelCase)(tag)}.repository.impl.spec.ts`), generatedCount, 'specs');
+        renderTemplate(templatesDir, 'api.repository.impl.spec.mustache', apiViewData, path_1.default.join(outputDir, 'data/repositories', tagFilename, `${tagFilename}.repository.impl.spec.ts`), generatedCount, 'specs');
         // Use-cases impl spec
-        renderTemplate(templatesDir, 'api.use-cases.impl.spec.mustache', apiViewData, path_1.default.join(outputDir, 'domain/use-cases', `${(0, name_formatter_1.toCamelCase)(tag)}.use-cases.impl.spec.ts`), generatedCount, 'specs');
+        renderTemplate(templatesDir, 'api.use-cases.impl.spec.mustache', apiViewData, path_1.default.join(outputDir, 'domain/use-cases', tagFilename, `${tagFilename}.use-cases.impl.spec.ts`), generatedCount, 'specs');
     });
     (0, logger_1.logSuccess)(`${generatedCount.models} Models, ${generatedCount.repositories} Repos, ${generatedCount.useCases} Use Cases, ${generatedCount.mappers} Mappers, ${generatedCount.providers} Providers, ${generatedCount.mocks} Mocks, ${generatedCount.specs} Specs generated`);
     return generatedCount;
@@ -344,6 +407,7 @@ function renderTemplate(templatesDir, templateName, viewData, destPath, counter,
     if (fs_extra_1.default.existsSync(templatePath)) {
         const template = fs_extra_1.default.readFileSync(templatePath, 'utf8');
         const output = mustache_1.default.render(template, viewData);
+        fs_extra_1.default.ensureDirSync(path_1.default.dirname(destPath));
         fs_extra_1.default.writeFileSync(destPath, output);
         counter[key]++;
         (0, logger_1.logDetail)('generate', `${templateName.replace('.mustache', '')} → ${path_1.default.relative(process.cwd(), destPath)}`);