npm - @0kmpo/openapi-clean-arch-generator - Versions diffs - 1.3.14 → 1.3.15 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (28) hide show

package/README.md +12 -0
package/dist/main.js +24 -2
package/dist/package.json +1 -1
package/dist/src/generators/clean-arch.generator.js +200 -136
package/dist/src/generators/dto.generator.js +42 -22
package/dist/src/generators/report.generator.js +6 -0
package/dist/src/utils/example-validator.js +86 -0
package/dist/src/utils/mock-value-resolver.js +19 -7
package/dist/src/utils/name-formatter.js +99 -2
package/dist/templates/api.repository.contract.mustache +1 -1
package/dist/templates/api.repository.impl.mock.mustache +2 -2
package/dist/templates/api.repository.impl.mustache +5 -5
package/dist/templates/api.repository.impl.spec.mustache +2 -2
package/dist/templates/api.use-cases.contract.mustache +1 -1
package/dist/templates/api.use-cases.impl.mustache +2 -2
package/dist/templates/api.use-cases.impl.spec.mustache +2 -2
package/dist/templates/api.use-cases.mock.mustache +2 -2
package/dist/templates/dto.mock.mustache +1 -1
package/dist/templates/mapper.mustache +2 -2
package/dist/templates/mapper.spec.mustache +2 -2
package/dist/templates/model-entity.mustache +1 -1
package/dist/templates/model-entity.spec.mustache +4 -0
package/dist/templates/model.mock.mustache +2 -2
package/dist/templates/repository.provider.mock.mustache +2 -2
package/dist/templates/repository.provider.mustache +2 -2
package/dist/templates/use-cases.provider.mock.mustache +2 -2
package/dist/templates/use-cases.provider.mustache +2 -2
package/package.json +1 -1

package/README.md CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -1,6 +1,6 @@
 {
     "name": "@0kmpo/openapi-clean-arch-generator",
-    "version": "1.3.14",
+    "version": "1.3.15",
     "description": "Angular Clean Architecture generator from OpenAPI/Swagger",
     "main": "dist/main.js",
     "bin": {

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

@@ -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)}`);

package/dist/src/generators/dto.generator.js CHANGED Viewed

@@ -10,6 +10,7 @@ const child_process_1 = require("child_process");
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("../utils/logger");
+const name_formatter_1 = require("../utils/name-formatter");
 /** Invokes `openapi-generator-cli` to generate DTOs into a temporary directory. */
 function generateCode(swaggerFile, templatesDir) {
     (0, logger_1.logStep)('Generating code from OpenAPI spec...');
@@ -37,8 +38,8 @@ function generateCode(swaggerFile, templatesDir) {
         process.exit(1);
     }
 }
-/** Copies the generated DTOs from the temporary directory to the output directory. */
-function organizeFiles(tempDir, outputDir) {
+/** Copies the generated DTOs from the temporary directory to the output directory, organised by tag subfolder. */
+function organizeFiles(tempDir, outputDir, schemaTagMap = {}) {
     (0, logger_1.logStep)('Organising generated DTO files...');
     const sourceDir = path_1.default.join(tempDir, 'model');
     const destDir = path_1.default.join(outputDir, 'data/dtos');
@@ -47,8 +48,13 @@ function organizeFiles(tempDir, outputDir) {
         fs_extra_1.default.ensureDirSync(destDir);
         const files = fs_extra_1.default.readdirSync(sourceDir).filter((file) => file.endsWith('.dto.ts'));
         files.forEach((file) => {
+            // file is like "userResponse.dto.ts" → derive PascalCase schema name to look up tag
+            const camelName = file.replace('.dto.ts', '');
+            const pascalName = (0, name_formatter_1.toPascalCase)(camelName);
+            const tagFolder = schemaTagMap[pascalName] || 'shared';
             const sourcePath = path_1.default.join(sourceDir, file);
-            const destPath = path_1.default.join(destDir, file);
+            const destPath = path_1.default.join(destDir, tagFolder, file);
+            fs_extra_1.default.ensureDirSync(path_1.default.dirname(destPath));
             fs_extra_1.default.copySync(sourcePath, destPath);
             filesMoved++;
             (0, logger_1.logDetail)('dto', `${file} → ${path_1.default.relative(process.cwd(), destPath)}`);
@@ -62,46 +68,60 @@ function addDtoImports(outputDir) {
     const dtosDir = path_1.default.join(outputDir, 'data/dtos');
     if (!fs_extra_1.default.existsSync(dtosDir))
         return;
-    const files = fs_extra_1.default.readdirSync(dtosDir).filter((f) => f.endsWith('.dto.ts'));
-    // Build a map of DTO classname → file base name (without .ts)
+    // Collect all .dto.ts files from all subfolders (1 level deep)
+    const allFiles = [];
+    const entries = fs_extra_1.default.readdirSync(dtosDir);
+    entries.forEach((entry) => {
+        const entryPath = path_1.default.join(dtosDir, entry);
+        if (fs_extra_1.default.statSync(entryPath).isDirectory()) {
+            fs_extra_1.default.readdirSync(entryPath)
+                .filter((f) => f.endsWith('.dto.ts'))
+                .forEach((file) => allFiles.push({ subfolder: entry, file, fullPath: path_1.default.join(entryPath, file) }));
+        }
+        else if (entry.endsWith('.dto.ts')) {
+            allFiles.push({ subfolder: '', file: entry, fullPath: entryPath });
+        }
+    });
+    // Build map: ClassName → { subfolder, fileBase }
     const dtoMap = {};
-    files.forEach((file) => {
-        const content = fs_extra_1.default.readFileSync(path_1.default.join(dtosDir, file), 'utf8');
+    allFiles.forEach(({ subfolder, file, fullPath }) => {
+        const content = fs_extra_1.default.readFileSync(fullPath, 'utf8');
         const match = content.match(/export interface (\w+)/);
-        if (match) {
-            dtoMap[match[1]] = file.replace('.ts', '');
-        }
+        if (match)
+            dtoMap[match[1]] = { subfolder, fileBase: file.replace('.ts', '') };
     });
     let filesProcessed = 0;
-    files.forEach((file) => {
-        const filePath = path_1.default.join(dtosDir, file);
-        const originalContent = fs_extra_1.default.readFileSync(filePath, 'utf8');
+    allFiles.forEach(({ subfolder, file, fullPath }) => {
+        const originalContent = fs_extra_1.default.readFileSync(fullPath, 'utf8');
         let content = originalContent;
         const selfMatch = content.match(/export interface (\w+)/);
         const selfName = selfMatch ? selfMatch[1] : '';
-        // Normalize Array<T> → T[] (openapi-generator-cli always outputs Array<T>)
         content = content.replace(/Array<(\w+)>/g, '$1[]');
-        // Find all Dto type references in the file body (excluding the interface name itself)
         const references = new Set();
         const typeRegex = /\b(\w+Dto)\b/g;
         let match;
         while ((match = typeRegex.exec(content)) !== null) {
-            if (match[1] !== selfName) {
+            if (match[1] !== selfName)
                 references.add(match[1]);
-            }
         }
-        // Build import lines for each referenced type that exists in the dtoMap
         const imports = [];
         references.forEach((ref) => {
             if (dtoMap[ref]) {
-                imports.push(`import { ${ref} } from './${dtoMap[ref]}';`);
+                const { subfolder: refSubfolder, fileBase: refFileBase } = dtoMap[ref];
+                const fromDir = subfolder ? path_1.default.join(dtosDir, subfolder) : dtosDir;
+                const toFile = refSubfolder
+                    ? path_1.default.join(dtosDir, refSubfolder, refFileBase)
+                    : path_1.default.join(dtosDir, refFileBase);
+                let relPath = path_1.default.relative(fromDir, toFile).replace(/\\/g, '/');
+                if (!relPath.startsWith('.'))
+                    relPath = './' + relPath;
+                imports.push(`import { ${ref} } from '${relPath}';`);
             }
         });
-        if (imports.length > 0) {
+        if (imports.length > 0)
             content = imports.join('\n') + '\n' + content;
-        }
         if (content !== originalContent) {
-            fs_extra_1.default.writeFileSync(filePath, content);
+            fs_extra_1.default.writeFileSync(fullPath, content);
             filesProcessed++;
             (0, logger_1.logDetail)('dto', `Post-processed ${file} (added ${imports.length} import(s))`);
         }

package/dist/src/generators/report.generator.js CHANGED Viewed

@@ -7,6 +7,7 @@ exports.generateReport = generateReport;
 const fs_extra_1 = __importDefault(require("fs-extra"));
 const path_1 = __importDefault(require("path"));
 const logger_1 = require("../utils/logger");
+const example_validator_1 = require("../utils/example-validator");
 /** Counts files ending with `.mock.ts` in a directory (returns 0 if directory does not exist). */
 function countMockFiles(dir) {
     try {
@@ -37,6 +38,7 @@ function generateReport(outputDir, analysis, lintResult) {
         })).length;
         return { name: t.name, description: t.description || '', endpoints: endpointCount };
     });
+    const exampleMismatches = (0, example_validator_1.getExampleMismatches)();
     const report = {
         timestamp: new Date().toISOString(),
         tags: analysis.tags.length,
@@ -44,6 +46,10 @@ function generateReport(outputDir, analysis, lintResult) {
         tagDetails,
         outputDirectory: outputDir,
         linting: lintResult,
+        warnings: {
+            exampleMismatches: exampleMismatches.map((m) => ({ ...m })),
+            total: exampleMismatches.length
+        },
         structure: {
             dtos: fs_extra_1.default.readdirSync(path_1.default.join(outputDir, 'data/dtos')).length,
             repositories: fs_extra_1.default.readdirSync(path_1.default.join(outputDir, 'data/repositories')).length,

package/dist/src/utils/example-validator.js ADDED Viewed

@@ -0,0 +1,86 @@
+"use strict";
+/**
+ * Validates that OpenAPI `example` values match their declared `type`.
+ *
+ * YAML parses unquoted values by native type (e.g. `example: 68131` becomes a JS number
+ * even when the schema declares `type: string`).  This module detects such mismatches,
+ * coerces them when possible, and accumulates warnings for the generation report.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateExample = validateExample;
+exports.registerMismatch = registerMismatch;
+exports.getExampleMismatches = getExampleMismatches;
+exports.clearExampleMismatches = clearExampleMismatches;
+// Module-level accumulator — reset between runs via `clearExampleMismatches()`.
+let mismatches = [];
+/**
+ * Validates an `example` value against a declared OpenAPI `type`.
+ *
+ * @returns `{ valid: true }` when types already match, or
+ *          `{ valid: false, coerced: <value> }` when the value was coerced, or
+ *          `{ valid: false }` when coercion is not possible (caller should ignore the example).
+ */
+function validateExample(declaredType, example) {
+    if (declaredType === undefined)
+        return { valid: true };
+    const jsType = typeof example;
+    // ── string declared ──────────────────────────────────────────────────────
+    if (declaredType === 'string') {
+        if (jsType === 'string')
+            return { valid: true };
+        // number or boolean → coerce to string
+        if (jsType === 'number' || jsType === 'boolean') {
+            return { valid: false, coerced: String(example) };
+        }
+        return { valid: false };
+    }
+    // ── integer / number declared ────────────────────────────────────────────
+    if (declaredType === 'integer' || declaredType === 'number') {
+        if (jsType === 'number')
+            return { valid: true };
+        if (jsType === 'string') {
+            const parsed = Number(example);
+            if (!Number.isNaN(parsed))
+                return { valid: false, coerced: parsed };
+            return { valid: false }; // unparseable → ignore
+        }
+        return { valid: false };
+    }
+    // ── boolean declared ─────────────────────────────────────────────────────
+    if (declaredType === 'boolean') {
+        if (jsType === 'boolean')
+            return { valid: true };
+        if (jsType === 'string') {
+            const lower = example.toLowerCase();
+            if (lower === 'true')
+                return { valid: false, coerced: true };
+            if (lower === 'false')
+                return { valid: false, coerced: false };
+        }
+        return { valid: false }; // cannot coerce
+    }
+    // Other types (object, array, etc.) — no validation
+    return { valid: true };
+}
+/**
+ * Records a mismatch so it can be retrieved later for console warnings and the report.
+ */
+function registerMismatch(schemaName, propertyName, declaredType, exampleValue, action, coercedValue) {
+    mismatches.push({
+        schemaName,
+        propertyName,
+        declaredType,
+        exampleValue,
+        exampleJsType: typeof exampleValue,
+        action,
+        coercedValue
+    });
+}
+/** Returns all recorded mismatches. */
+function getExampleMismatches() {
+    return mismatches;
+}
+/** Clears all recorded mismatches (call before each generation run). */
+function clearExampleMismatches() {
+    mismatches = [];
+}

package/dist/src/utils/mock-value-resolver.js CHANGED Viewed

@@ -1,17 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveMockValue = resolveMockValue;
+const example_validator_1 = require("./example-validator");
 /**
  * Resolves a TypeScript literal string to use as a mock value for a single schema property.
  *
  * Priority chain:
  *   $ref mock call → array $ref mock call → enum[0] → example → format fallback → type default
  *
- * @param propName  Property name (used for format heuristics such as "email").
- * @param prop      Raw OpenAPI property definition.
- * @param context   'dto' generates `mockFooDto()`, 'model' generates `mockFooModel()`.
+ * @param propName    Property name (used for format heuristics such as "email").
+ * @param prop        Raw OpenAPI property definition.
+ * @param context     'dto' generates `mockFooDto()`, 'model' generates `mockFooModel()`.
+ * @param schemaName  Parent schema name (used for mismatch reporting).
  */
-function resolveMockValue(propName, prop, context = 'dto') {
+function resolveMockValue(propName, prop, context = 'dto', schemaName = 'unknown') {
     const suffix = context === 'dto' ? 'Dto' : 'Model';
     // 1. Direct $ref → call the referenced mock factory
     if (prop.$ref) {
@@ -31,9 +33,19 @@ function resolveMockValue(propName, prop, context = 'dto') {
         const first = prop.enum[0];
         return typeof first === 'string' ? `'${first}'` : String(first);
     }
-    // 5. Example value from the swagger spec (highest fidelity)
-    if (prop.example !== undefined)
-        return formatLiteral(prop.example);
+    // 5. Example value — validated and coerced if needed
+    if (prop.example !== undefined) {
+        const result = (0, example_validator_1.validateExample)(prop.type, prop.example);
+        if (result.valid) {
+            return formatLiteral(prop.example);
+        }
+        if (result.coerced !== undefined) {
+            (0, example_validator_1.registerMismatch)(schemaName, propName, prop.type, prop.example, 'coerced', result.coerced);
+            return formatLiteral(result.coerced);
+        }
+        // Cannot coerce — register and fall through to defaults
+        (0, example_validator_1.registerMismatch)(schemaName, propName, prop.type, prop.example, 'ignored');
+    }
     // 6. Format-aware fallbacks (when no example is provided)
     if (prop.format === 'date-time')
         return `'2024-01-01T00:00:00.000Z'`;

package/dist/src/utils/name-formatter.js CHANGED Viewed

@@ -1,16 +1,113 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.toPascalCase = toPascalCase;
 exports.toCamelCase = toCamelCase;
+exports.isReservedWord = isReservedWord;
+exports.safePropertyName = safePropertyName;
 /**
- * Converts a PascalCase name to camelCase by lowercasing the first character.
+ * Converts a string to PascalCase, handling spaces, hyphens and underscores.
+ * Used to derive class names from schema/tag names.
+ *
+ * @example
+ * toPascalCase('Product Format')  // 'ProductFormat'
+ * toPascalCase('user-response')   // 'UserResponse'
+ * toPascalCase('UserSchema')      // 'UserSchema'
+ */
+function toPascalCase(name) {
+    if (!name)
+        return name;
+    return name
+        .split(/[\s\-_]+/)
+        .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
+        .join('');
+}
+/**
+ * Converts a string to camelCase, handling spaces, hyphens and underscores.
  * Used to derive class filenames and variable names from schema/tag names.
  *
  * @example
+ * toCamelCase('Product Format')  // 'productFormat'
  * toCamelCase('ProductResponse') // 'productResponse'
  * toCamelCase('UserSchema')      // 'userSchema'
  */
 function toCamelCase(name) {
     if (!name)
         return name;
-    return name.charAt(0).toLowerCase() + name.slice(1);
+    const pascal = toPascalCase(name);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+const JS_RESERVED_WORDS = new Set([
+    'abstract',
+    'arguments',
+    'await',
+    'boolean',
+    'break',
+    'byte',
+    'case',
+    'catch',
+    'char',
+    'class',
+    'const',
+    'continue',
+    'debugger',
+    'default',
+    'delete',
+    'do',
+    'double',
+    'else',
+    'enum',
+    'eval',
+    'export',
+    'extends',
+    'false',
+    'final',
+    'finally',
+    'float',
+    'for',
+    'function',
+    'goto',
+    'if',
+    'implements',
+    'import',
+    'in',
+    'instanceof',
+    'int',
+    'interface',
+    'let',
+    'long',
+    'native',
+    'new',
+    'null',
+    'package',
+    'private',
+    'protected',
+    'public',
+    'return',
+    'short',
+    'static',
+    'super',
+    'switch',
+    'synchronized',
+    'this',
+    'throw',
+    'throws',
+    'transient',
+    'true',
+    'try',
+    'typeof',
+    'undefined',
+    'var',
+    'void',
+    'volatile',
+    'while',
+    'with',
+    'yield'
+]);
+/** Returns true if the given name is a JS/TS reserved word. */
+function isReservedWord(name) {
+    return JS_RESERVED_WORDS.has(name);
+}
+/** Prefixes reserved words with `_` to produce a safe identifier. */
+function safePropertyName(name) {
+    return isReservedWord(name) ? `_${name}` : name;
 }

package/dist/templates/api.repository.contract.mustache CHANGED Viewed

@@ -4,7 +4,7 @@
 import { InjectionToken } from '@angular/core';
 import { Observable } from 'rxjs';
 {{#imports}}
-import { {{classname}} } from '@/entities/models/{{classFilename}}.model';
+import { {{classname}} } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model';
 {{/imports}}
 /**

package/dist/templates/api.repository.impl.mock.mustache CHANGED Viewed

@@ -4,9 +4,9 @@
 import { MockService } from 'ng-mocks';
 import { of } from 'rxjs';
-import { {{classname}}RepositoryImpl } from '@/data/repositories/{{classFilename}}.repository.impl';
+import { {{classname}}RepositoryImpl } from '@/data/repositories/{{classFilename}}/{{classFilename}}.repository.impl';
 {{#returnImports}}
-import { mock{{classname}}Model } from '@/entities/models/{{classFilename}}.model.mock';
+import { mock{{classname}}Model } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model.mock';
 {{/returnImports}}
 export const mock{{classname}}RepositoryImpl = () =>

package/dist/templates/api.repository.impl.mustache CHANGED Viewed

@@ -9,14 +9,14 @@ import { environment } from '@environment';
 import { MRepository } from '@mercadona/core/utils/repository';
-import { {{classname}}Repository } from '@/domain/repositories/{{classFilename}}.repository.contract';
+import { {{classname}}Repository } from '@/domain/repositories/{{classFilename}}/{{classFilename}}.repository.contract';
 {{#returnImports}}
-import { {{classname}}Dto } from '@/dtos/{{classFilename}}.dto';
-import { {{classname}} } from '@/entities/models/{{classFilename}}.model';
-import { {{classVarName}}Mapper } from '@/mappers/{{classFilename}}.mapper';
+import { {{classname}}Dto } from '@/dtos/{{tagFilename}}/{{classFilename}}.dto';
+import { {{classname}} } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model';
+import { {{classVarName}}Mapper } from '@/mappers/{{tagFilename}}/{{classFilename}}.mapper';
 {{/returnImports}}
 {{#paramImports}}
-import { {{classname}} } from '@/entities/models/{{classFilename}}.model';
+import { {{classname}} } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model';
 {{/paramImports}}
 /**

package/dist/templates/api.repository.impl.spec.mustache CHANGED Viewed

@@ -6,8 +6,8 @@ import { TestBed } from '@angular/core/testing';
 import { {{classname}}RepositoryImpl } from './{{classFilename}}.repository.impl';
 {{#returnImports}}
-import { mock{{classname}}Dto } from '@/dtos/{{classFilename}}.dto.mock';
-import { mock{{classname}}Model } from '@/entities/models/{{classFilename}}.model.mock';
+import { mock{{classname}}Dto } from '@/dtos/{{tagFilename}}/{{classFilename}}.dto.mock';
+import { mock{{classname}}Model } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model.mock';
 {{/returnImports}}
 describe('{{classname}}RepositoryImpl', () => {

package/dist/templates/api.use-cases.contract.mustache CHANGED Viewed

@@ -4,7 +4,7 @@
 import { InjectionToken } from '@angular/core';
 import { Observable } from 'rxjs';
 {{#imports}}
-import { {{classname}} } from '@/entities/models/{{classFilename}}.model';
+import { {{classname}} } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model';
 {{/imports}}
 /**

package/dist/templates/api.use-cases.impl.mustache CHANGED Viewed

@@ -6,9 +6,9 @@ import { Observable } from 'rxjs';
 import { {{classname}}UseCases } from './{{classFilename}}.use-cases.contract';
-import { {{constantName}}_REPOSITORY, {{classname}}Repository } from '@/domain/repositories/{{classFilename}}.repository.contract';
+import { {{constantName}}_REPOSITORY, {{classname}}Repository } from '@/domain/repositories/{{classFilename}}/{{classFilename}}.repository.contract';
 {{#imports}}
-import { {{classname}} } from '@/entities/models/{{classFilename}}.model';
+import { {{classname}} } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model';
 {{/imports}}
 /**

package/dist/templates/api.use-cases.impl.spec.mustache CHANGED Viewed

@@ -6,9 +6,9 @@ import { of } from 'rxjs';
 import { {{classname}}UseCasesImpl } from './{{classFilename}}.use-cases.impl';
-import { {{constantName}}_REPOSITORY, {{classname}}Repository } from '@/domain/repositories/{{classFilename}}.repository.contract';
+import { {{constantName}}_REPOSITORY, {{classname}}Repository } from '@/domain/repositories/{{classFilename}}/{{classFilename}}.repository.contract';
 {{#returnImports}}
-import { mock{{classname}}Model } from '@/entities/models/{{classFilename}}.model.mock';
+import { mock{{classname}}Model } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model.mock';
 {{/returnImports}}
 describe('{{classname}}UseCasesImpl', () => {

package/dist/templates/api.use-cases.mock.mustache CHANGED Viewed

@@ -4,9 +4,9 @@
 import { MockService } from 'ng-mocks';
 import { of } from 'rxjs';
-import { {{classname}}UseCasesImpl } from '@/domain/use-cases/{{classFilename}}.use-cases.impl';
+import { {{classname}}UseCasesImpl } from '@/domain/use-cases/{{classFilename}}/{{classFilename}}.use-cases.impl';
 {{#returnImports}}
-import { mock{{classname}}Model } from '@/entities/models/{{classFilename}}.model.mock';
+import { mock{{classname}}Model } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model.mock';
 {{/returnImports}}
 export const mock{{classname}}UseCasesImpl = () =>

package/dist/templates/dto.mock.mustache CHANGED Viewed

@@ -1,7 +1,7 @@
 {{#models}}
 {{#model}}
 {{#mockImports}}
-import { mock{{classname}}Dto } from './{{classFilename}}.dto.mock';
+import { mock{{classname}}Dto } from '{{{importPath}}}';
 {{/mockImports}}
 import { {{classname}}Dto } from './{{classFilename}}.dto';

package/dist/templates/mapper.mustache CHANGED Viewed

@@ -4,8 +4,8 @@
 import { MapFromFn } from '@mercadona/common/public';
 import { Builder } from '@mercadona/common/utils';
-import { {{classname}}Dto } from '@/dtos/{{classFilename}}.dto';
-import { {{classname}} } from '@/entities/models/{{classFilename}}.model';
+import { {{classname}}Dto } from '@/dtos/{{tagFilename}}/{{classFilename}}.dto';
+import { {{classname}} } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model';
 /**
  * {{classname}} Mapper

package/dist/templates/mapper.spec.mustache CHANGED Viewed

@@ -2,8 +2,8 @@
 {{#model}}
 import { {{classVarName}}Mapper } from './{{classFilename}}.mapper';
-import { mock{{classname}}Dto } from '@/dtos/{{classFilename}}.dto.mock';
-import { {{classname}} } from '@/entities/models/{{classFilename}}.model';
+import { mock{{classname}}Dto } from '@/dtos/{{tagFilename}}/{{classFilename}}.dto.mock';
+import { {{classname}} } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model';
 describe('{{classVarName}}Mapper', () => {
 {{#vars}}

package/dist/templates/model-entity.mustache CHANGED Viewed

@@ -1,7 +1,7 @@
 {{#models}}
 {{#model}}
 {{#imports}}
-import { {{classname}} } from './{{classFilename}}.model';
+import { {{classname}} } from '@/entities/models/{{tagFilename}}/{{classFilename}}.model';
 {{/imports}}
 /**

package/dist/templates/model-entity.spec.mustache CHANGED Viewed

@@ -11,6 +11,7 @@ describe('{{classname}}', () => {
   });
 {{#vars}}
+{{#hasMockValue}}
   it('should allow setting {{name}}', () => {
     const model = new {{classname}}();
     const expected = mock{{classname}}Model();
@@ -19,13 +20,16 @@ describe('{{classname}}', () => {
     expect(model.{{name}}).toBe(expected.{{name}});
   });
+{{/hasMockValue}}
 {{/vars}}
   it('should build a valid model from mock', () => {
     const model = mock{{classname}}Model();
     expect(model).toBeInstanceOf({{classname}});
 {{#vars}}
+{{#hasMockValue}}
     expect(model.{{name}}).toBeDefined();
+{{/hasMockValue}}
 {{/vars}}
   });
 });

package/dist/templates/model.mock.mustache CHANGED Viewed

@@ -1,8 +1,8 @@
 {{#models}}
 {{#model}}
 import { {{classname}} } from './{{classFilename}}.model';
-import { {{classVarName}}Mapper } from '@/mappers/{{classFilename}}.mapper';
-import { mock{{classname}}Dto } from '@/dtos/{{classFilename}}.dto.mock';
+import { {{classVarName}}Mapper } from '@/mappers/{{tagFilename}}/{{classFilename}}.mapper';
+import { mock{{classname}}Dto } from '@/dtos/{{tagFilename}}/{{classFilename}}.dto.mock';
 export const mock{{classname}}Model = (overrides: Partial<{{classname}}> = {}): {{classname}} =>
   Object.assign(new {{classname}}(), {

package/dist/templates/repository.provider.mock.mustache CHANGED Viewed

@@ -3,8 +3,8 @@
 {{#operations}}
 import { Provider } from '@angular/core';
-import { {{constantName}}_REPOSITORY } from '@/domain/repositories/{{classFilename}}.repository.contract';
-import { mock{{classname}}RepositoryImpl } from '@/data/repositories/{{classFilename}}.repository.impl.mock';
+import { {{constantName}}_REPOSITORY } from '@/domain/repositories/{{classFilename}}/{{classFilename}}.repository.contract';
+import { mock{{classname}}RepositoryImpl } from '@/data/repositories/{{classFilename}}/{{classFilename}}.repository.impl.mock';
 export function mock{{classname}}Repository(): Provider[] {
   return [

package/dist/templates/repository.provider.mustache CHANGED Viewed

@@ -3,8 +3,8 @@
 {{#operations}}
 import { EnvironmentProviders, makeEnvironmentProviders } from '@angular/core';
-import { {{constantName}}_REPOSITORY } from '@/domain/repositories/{{classFilename}}.repository.contract';
-import { {{classname}}RepositoryImpl } from '@/data/repositories/{{classFilename}}.repository.impl';
+import { {{constantName}}_REPOSITORY } from '@/domain/repositories/{{classFilename}}/{{classFilename}}.repository.contract';
+import { {{classname}}RepositoryImpl } from '@/data/repositories/{{classFilename}}/{{classFilename}}.repository.impl';
 /**
  * {{classname}} Repository Provider

package/dist/templates/use-cases.provider.mock.mustache CHANGED Viewed

@@ -3,8 +3,8 @@
 {{#operations}}
 import { Provider } from '@angular/core';
-import { {{constantName}}_USE_CASES } from '@/domain/use-cases/{{classFilename}}.use-cases.contract';
-import { mock{{classname}}UseCasesImpl } from '@/domain/use-cases/{{classFilename}}.use-cases.mock';
+import { {{constantName}}_USE_CASES } from '@/domain/use-cases/{{classFilename}}/{{classFilename}}.use-cases.contract';
+import { mock{{classname}}UseCasesImpl } from '@/domain/use-cases/{{classFilename}}/{{classFilename}}.use-cases.mock';
 export function mock{{classname}}UseCases(): Provider[] {
   return [

package/dist/templates/use-cases.provider.mustache CHANGED Viewed

@@ -3,8 +3,8 @@
 {{#operations}}
 import { EnvironmentProviders, makeEnvironmentProviders } from '@angular/core';
-import { {{constantName}}_USE_CASES } from '@/domain/use-cases/{{classFilename}}.use-cases.contract';
-import { {{classname}}UseCasesImpl } from '@/domain/use-cases/{{classFilename}}.use-cases.impl';
+import { {{constantName}}_USE_CASES } from '@/domain/use-cases/{{classFilename}}/{{classFilename}}.use-cases.contract';
+import { {{classname}}UseCasesImpl } from '@/domain/use-cases/{{classFilename}}/{{classFilename}}.use-cases.impl';
 /**
  * {{classname}} Use Cases Provider

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@0kmpo/openapi-clean-arch-generator",
-  "version": "1.3.14",
+  "version": "1.3.15",
   "description": "Angular Clean Architecture generator from OpenAPI/Swagger",
   "main": "dist/main.js",
   "bin": {