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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "@0kmpo/openapi-clean-arch-generator",
-  "version": "1.3.13",
+  "version": "1.3.15",
   "description": "Angular Clean Architecture generator from OpenAPI/Swagger",
   "main": "dist/main.js",
   "bin": {
@@ -41,6 +41,7 @@
   "license": "MIT",
   "files": [
     "dist/main.js",
+    "dist/package.json",
     "dist/src/",
     "dist/templates/",
     "README.md",