675 lines
20 KiB
TypeScript
675 lines
20 KiB
TypeScript
import fs from 'fs-extra';
|
|
import path from 'path';
|
|
import mustache from 'mustache';
|
|
import { logStep, logSuccess, logDetail } from '../utils/logger';
|
|
import { mapSwaggerTypeToTs } from '../utils/type-mapper';
|
|
import { toCamelCase, toPascalCase, safePropertyName } from '../utils/name-formatter';
|
|
import { resolveMockValue } from '../utils/mock-value-resolver';
|
|
import type {
|
|
SwaggerAnalysis,
|
|
OpenApiSchema,
|
|
OpenApiOperation,
|
|
TagOperation,
|
|
TagSummary,
|
|
SelectionFilter,
|
|
GeneratedCount
|
|
} from '../types';
|
|
|
|
/**
|
|
* Extracts the unique tags (in order of appearance) from a SwaggerAnalysis.
|
|
* Only endpoints that have at least one tag are considered; the first tag is used.
|
|
*/
|
|
export function extractTagsFromAnalysis(analysis: SwaggerAnalysis): string[] {
|
|
const seen = new Set<string>();
|
|
const tags: string[] = [];
|
|
Object.values(analysis.paths).forEach((pathObj) => {
|
|
Object.values(pathObj as Record<string, unknown>).forEach((opRaw) => {
|
|
const op = opRaw as OpenApiOperation;
|
|
if (op.tags && op.tags.length > 0) {
|
|
const tag = op.tags[0];
|
|
if (!seen.has(tag)) {
|
|
seen.add(tag);
|
|
tags.push(tag);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
return tags;
|
|
}
|
|
|
|
/**
|
|
* Extracts all tags with their operations summary for the interactive selection screen.
|
|
*/
|
|
export function extractTagsWithOperations(analysis: SwaggerAnalysis): TagSummary[] {
|
|
const map = new Map<string, TagSummary>();
|
|
Object.entries(analysis.paths).forEach(([pathKey, pathObj]) => {
|
|
Object.entries(pathObj as Record<string, unknown>).forEach(([method, opRaw]) => {
|
|
const op = opRaw as OpenApiOperation;
|
|
if (!op.tags?.length) return;
|
|
const tag = op.tags[0];
|
|
if (!map.has(tag)) map.set(tag, { tag, operations: [] });
|
|
map.get(tag)!.operations.push({
|
|
nickname: op.operationId || `${method}${pathKey.replace(/\//g, '_')}`,
|
|
method: method.toUpperCase(),
|
|
path: pathKey,
|
|
summary: op.summary || ''
|
|
});
|
|
});
|
|
});
|
|
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.
|
|
*/
|
|
export function buildTagsMapFromAnalysis(
|
|
analysis: SwaggerAnalysis,
|
|
selectionFilter: SelectionFilter = {}
|
|
): Record<string, TagOperation[]> {
|
|
const tagsMap: Record<string, TagOperation[]> = {};
|
|
|
|
Object.keys(analysis.paths).forEach((pathKey) => {
|
|
const pathObj = analysis.paths[pathKey] as Record<string, unknown>;
|
|
Object.keys(pathObj).forEach((method) => {
|
|
const op = pathObj[method] as OpenApiOperation;
|
|
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: mapSwaggerTypeToTs(p.schema?.type || ''),
|
|
description: p.description || '',
|
|
required: p.required,
|
|
testValue: resolveTestParamValue(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 = 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: number) => ({
|
|
...p,
|
|
'-last': i === allParams.length - 1
|
|
})),
|
|
hasQueryParams,
|
|
queryParams: (op.parameters || [])
|
|
.filter((p) => p.in === 'query')
|
|
.map((p, i: number, arr: unknown[]) => ({
|
|
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' ? toCamelCase(returnType) : false,
|
|
returnBaseTypeVarName: returnBaseType !== 'void' ? 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'.
|
|
*/
|
|
export function buildSchemaTagMap(
|
|
schemas: Record<string, unknown>,
|
|
tagsMap: Record<string, TagOperation[]>
|
|
): Record<string, string> {
|
|
const result: Record<string, string> = {};
|
|
Object.keys(schemas).forEach((schemaName) => {
|
|
const baseName = schemaName.replace(/Dto$/, '');
|
|
const tagsUsing: string[] = [];
|
|
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 ? toCamelCase(tagsUsing[0]) : 'shared';
|
|
});
|
|
return result;
|
|
}
|
|
|
|
/** Generates all Clean Architecture artefacts (models, mappers, repos, use cases, providers) using Mustache. */
|
|
export function generateCleanArchitecture(
|
|
analysis: SwaggerAnalysis,
|
|
outputDir: string,
|
|
templatesDir: string,
|
|
tagApiKeyMap: Record<string, string> = {},
|
|
selectionFilter: SelectionFilter = {},
|
|
precomputedSchemaTagMap: Record<string, string> = {}
|
|
): GeneratedCount {
|
|
logStep('Generating Clean Architecture artefacts using Mustache...');
|
|
const generatedCount: GeneratedCount = {
|
|
models: 0,
|
|
repositories: 0,
|
|
mappers: 0,
|
|
useCases: 0,
|
|
providers: 0,
|
|
mocks: 0,
|
|
specs: 0
|
|
};
|
|
|
|
const schemas =
|
|
(analysis.swagger as { components?: { schemas?: Record<string, unknown> } }).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] as OpenApiSchema;
|
|
const rawProperties = schemaObj.properties || {};
|
|
const requiredProps: string[] = schemaObj.required || [];
|
|
|
|
const varsMap = Object.keys(rawProperties).map((k) => {
|
|
let tsType = mapSwaggerTypeToTs(rawProperties[k].type);
|
|
const isInlineObject = rawProperties[k].type === 'object' && !rawProperties[k].$ref;
|
|
if (rawProperties[k].$ref) {
|
|
tsType = rawProperties[k].$ref.split('/').pop() || 'unknown';
|
|
} else if (rawProperties[k].type === 'array' && rawProperties[k].items?.$ref) {
|
|
tsType = `${rawProperties[k].items.$ref.split('/').pop()}[]`;
|
|
}
|
|
return {
|
|
name: safePropertyName(k),
|
|
originalName: k,
|
|
dataType: tsType,
|
|
description: rawProperties[k].description || '',
|
|
required: requiredProps.includes(k),
|
|
hasMockValue: !isInlineObject
|
|
};
|
|
});
|
|
|
|
// Collect imports for types referenced via $ref in properties
|
|
const referencedTypes = new Set<string>();
|
|
Object.values(rawProperties).forEach((prop) => {
|
|
if (prop.$ref) {
|
|
referencedTypes.add(prop.$ref.split('/').pop() || '');
|
|
} else if (prop.type === 'array' && prop.items?.$ref) {
|
|
referencedTypes.add(prop.items.$ref.split('/').pop() || '');
|
|
}
|
|
});
|
|
const modelImports = [...referencedTypes].filter(Boolean).map((name) => ({
|
|
classname: name,
|
|
classFilename: toCamelCase(name),
|
|
tagFilename: schemaTagMap[name] || 'shared'
|
|
}));
|
|
|
|
const modelViewData = {
|
|
tagFilename,
|
|
models: [
|
|
{
|
|
model: {
|
|
classname: baseName,
|
|
classFilename: toCamelCase(baseName),
|
|
classVarName: toCamelCase(baseName),
|
|
description: schemaObj.description || '',
|
|
imports: modelImports,
|
|
vars: varsMap
|
|
}
|
|
}
|
|
],
|
|
allModels: [{ model: { vars: varsMap } }]
|
|
};
|
|
|
|
const mapperViewData = {
|
|
...modelViewData,
|
|
apiInfo: {
|
|
apis: [
|
|
{
|
|
operations: {
|
|
classname: baseName,
|
|
classFilename: toCamelCase(baseName),
|
|
classVarName: toCamelCase(baseName),
|
|
tagFilename
|
|
}
|
|
}
|
|
]
|
|
}
|
|
};
|
|
|
|
// Model (Entities)
|
|
const modelTemplatePath = path.join(templatesDir, 'model-entity.mustache');
|
|
if (fs.existsSync(modelTemplatePath)) {
|
|
const template = fs.readFileSync(modelTemplatePath, 'utf8');
|
|
const output = mustache.render(template, modelViewData);
|
|
const destPath = path.join(
|
|
outputDir,
|
|
'entities/models',
|
|
tagFilename,
|
|
`${toCamelCase(baseName)}.model.ts`
|
|
);
|
|
fs.ensureDirSync(path.dirname(destPath));
|
|
fs.writeFileSync(destPath, output);
|
|
generatedCount.models++;
|
|
logDetail('generate', `model-entity → ${path.relative(process.cwd(), destPath)}`);
|
|
}
|
|
|
|
// Mapper
|
|
const mapperTemplatePath = path.join(templatesDir, 'mapper.mustache');
|
|
if (fs.existsSync(mapperTemplatePath)) {
|
|
const template = fs.readFileSync(mapperTemplatePath, 'utf8');
|
|
const output = mustache.render(template, mapperViewData);
|
|
const destPath = path.join(
|
|
outputDir,
|
|
'data/mappers',
|
|
tagFilename,
|
|
`${toCamelCase(baseName)}.mapper.ts`
|
|
);
|
|
fs.ensureDirSync(path.dirname(destPath));
|
|
fs.writeFileSync(destPath, output);
|
|
generatedCount.mappers++;
|
|
}
|
|
|
|
// DTO mock — values resolved from raw schema (example, format, type)
|
|
const dtoMockVarsMap = Object.keys(rawProperties).map((k) => ({
|
|
name: safePropertyName(k),
|
|
mockValue: resolveMockValue(k, rawProperties[k], 'dto', schemaName)
|
|
}));
|
|
const dtoMockImports = [...referencedTypes].filter(Boolean).map((name) => {
|
|
const targetTag = schemaTagMap[name] || 'shared';
|
|
const targetFile = `${toCamelCase(name)}.dto.mock`;
|
|
const importPath =
|
|
targetTag === tagFilename ? `./${targetFile}` : `../${targetTag}/${targetFile}`;
|
|
return {
|
|
classname: name,
|
|
classFilename: toCamelCase(name),
|
|
tagFilename: targetTag,
|
|
importPath
|
|
};
|
|
});
|
|
|
|
const dtoMockViewData = {
|
|
tagFilename,
|
|
models: [
|
|
{
|
|
model: {
|
|
classname: baseName,
|
|
classFilename: toCamelCase(baseName),
|
|
classVarName: toCamelCase(baseName),
|
|
mockImports: dtoMockImports,
|
|
vars: dtoMockVarsMap
|
|
}
|
|
}
|
|
]
|
|
};
|
|
|
|
renderTemplate(
|
|
templatesDir,
|
|
'dto.mock.mustache',
|
|
dtoMockViewData,
|
|
path.join(outputDir, 'data/dtos', tagFilename, `${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.join(
|
|
outputDir,
|
|
'entities/models',
|
|
tagFilename,
|
|
`${toCamelCase(baseName)}.model.mock.ts`
|
|
),
|
|
generatedCount,
|
|
'mocks'
|
|
);
|
|
|
|
// Model spec
|
|
renderTemplate(
|
|
templatesDir,
|
|
'model-entity.spec.mustache',
|
|
modelViewData,
|
|
path.join(
|
|
outputDir,
|
|
'entities/models',
|
|
tagFilename,
|
|
`${toCamelCase(baseName)}.model.spec.ts`
|
|
),
|
|
generatedCount,
|
|
'specs'
|
|
);
|
|
|
|
// Mapper spec
|
|
renderTemplate(
|
|
templatesDir,
|
|
'mapper.spec.mustache',
|
|
mapperViewData,
|
|
path.join(outputDir, 'data/mappers', tagFilename, `${toCamelCase(baseName)}.mapper.spec.ts`),
|
|
generatedCount,
|
|
'specs'
|
|
);
|
|
});
|
|
|
|
// 2. Generate Use Cases and Repositories from Paths/Tags
|
|
// Generate per tag
|
|
Object.keys(tagsMap).forEach((tag) => {
|
|
const tagFilename = toCamelCase(tag);
|
|
const returnImports: {
|
|
classname: string;
|
|
classFilename: string;
|
|
classVarName: string;
|
|
tagFilename: string;
|
|
}[] = [];
|
|
const paramImports: {
|
|
classname: string;
|
|
classFilename: string;
|
|
classVarName: string;
|
|
tagFilename: string;
|
|
}[] = [];
|
|
|
|
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: toCamelCase(s),
|
|
classVarName: toCamelCase(s),
|
|
tagFilename: schemaTagMap[s] || 'shared'
|
|
};
|
|
|
|
if (usedAsReturn) {
|
|
returnImports.push(entry);
|
|
} else if (usedAsParam) {
|
|
// Param-only types: entity import needed for method signatures, but no Dto or Mapper
|
|
paramImports.push(entry);
|
|
}
|
|
});
|
|
|
|
const apiViewData = {
|
|
apiInfo: {
|
|
apis: [
|
|
{
|
|
operations: {
|
|
classname: toPascalCase(tag),
|
|
classFilename: tagFilename,
|
|
classVarName: tagFilename,
|
|
constantName: tag.toUpperCase().replace(/[^A-Z0-9]/g, '_'),
|
|
operation: tagsMap[tag],
|
|
imports: [...returnImports, ...paramImports],
|
|
returnImports,
|
|
paramImports,
|
|
environmentApiKey: tagApiKeyMap[tag] || 'apiUrl'
|
|
}
|
|
}
|
|
]
|
|
}
|
|
};
|
|
|
|
renderTemplate(
|
|
templatesDir,
|
|
'api.use-cases.contract.mustache',
|
|
apiViewData,
|
|
path.join(outputDir, 'domain/use-cases', tagFilename, `${tagFilename}.use-cases.contract.ts`),
|
|
generatedCount,
|
|
'useCases'
|
|
);
|
|
|
|
renderTemplate(
|
|
templatesDir,
|
|
'api.use-cases.impl.mustache',
|
|
apiViewData,
|
|
path.join(outputDir, 'domain/use-cases', tagFilename, `${tagFilename}.use-cases.impl.ts`),
|
|
generatedCount,
|
|
'useCases'
|
|
);
|
|
|
|
renderTemplate(
|
|
templatesDir,
|
|
'api.repository.contract.mustache',
|
|
apiViewData,
|
|
path.join(
|
|
outputDir,
|
|
'domain/repositories',
|
|
tagFilename,
|
|
`${tagFilename}.repository.contract.ts`
|
|
),
|
|
generatedCount,
|
|
'repositories'
|
|
);
|
|
|
|
renderTemplate(
|
|
templatesDir,
|
|
'api.repository.impl.mustache',
|
|
apiViewData,
|
|
path.join(outputDir, 'data/repositories', tagFilename, `${tagFilename}.repository.impl.ts`),
|
|
generatedCount,
|
|
'repositories'
|
|
);
|
|
|
|
renderTemplate(
|
|
templatesDir,
|
|
'use-cases.provider.mustache',
|
|
apiViewData,
|
|
path.join(outputDir, 'di/use-cases', tagFilename, `${tagFilename}.use-cases.provider.ts`),
|
|
generatedCount,
|
|
'providers'
|
|
);
|
|
|
|
renderTemplate(
|
|
templatesDir,
|
|
'repository.provider.mustache',
|
|
apiViewData,
|
|
path.join(outputDir, 'di/repositories', tagFilename, `${tagFilename}.repository.provider.ts`),
|
|
generatedCount,
|
|
'providers'
|
|
);
|
|
|
|
// Mocks
|
|
renderTemplate(
|
|
templatesDir,
|
|
'api.repository.impl.mock.mustache',
|
|
apiViewData,
|
|
path.join(
|
|
outputDir,
|
|
'data/repositories',
|
|
tagFilename,
|
|
`${tagFilename}.repository.impl.mock.ts`
|
|
),
|
|
generatedCount,
|
|
'mocks'
|
|
);
|
|
|
|
renderTemplate(
|
|
templatesDir,
|
|
'api.use-cases.mock.mustache',
|
|
apiViewData,
|
|
path.join(outputDir, 'domain/use-cases', tagFilename, `${tagFilename}.use-cases.mock.ts`),
|
|
generatedCount,
|
|
'mocks'
|
|
);
|
|
|
|
renderTemplate(
|
|
templatesDir,
|
|
'repository.provider.mock.mustache',
|
|
apiViewData,
|
|
path.join(
|
|
outputDir,
|
|
'di/repositories',
|
|
tagFilename,
|
|
`${tagFilename}.repository.provider.mock.ts`
|
|
),
|
|
generatedCount,
|
|
'mocks'
|
|
);
|
|
|
|
renderTemplate(
|
|
templatesDir,
|
|
'use-cases.provider.mock.mustache',
|
|
apiViewData,
|
|
path.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.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.join(
|
|
outputDir,
|
|
'domain/use-cases',
|
|
tagFilename,
|
|
`${tagFilename}.use-cases.impl.spec.ts`
|
|
),
|
|
generatedCount,
|
|
'specs'
|
|
);
|
|
});
|
|
|
|
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;
|
|
}
|
|
|
|
/** Renders a Mustache template and increments the corresponding counter. */
|
|
function renderTemplate(
|
|
templatesDir: string,
|
|
templateName: string,
|
|
viewData: unknown,
|
|
destPath: string,
|
|
counter: GeneratedCount,
|
|
key: keyof GeneratedCount
|
|
): void {
|
|
const templatePath = path.join(templatesDir, templateName);
|
|
if (fs.existsSync(templatePath)) {
|
|
const template = fs.readFileSync(templatePath, 'utf8');
|
|
const output = mustache.render(template, viewData);
|
|
fs.ensureDirSync(path.dirname(destPath));
|
|
fs.writeFileSync(destPath, output);
|
|
counter[key]++;
|
|
logDetail(
|
|
'generate',
|
|
`${templateName.replace('.mustache', '')} → ${path.relative(process.cwd(), destPath)}`
|
|
);
|
|
}
|
|
}
|
|
|
|
/** Resolves a simple test value literal for a given TypeScript type. */
|
|
function resolveTestParamValue(dataType: string): string {
|
|
switch (dataType) {
|
|
case 'string':
|
|
return "'test'";
|
|
case 'number':
|
|
return '1';
|
|
case 'boolean':
|
|
return 'true';
|
|
default:
|
|
if (dataType.endsWith('[]')) return '[]';
|
|
return '{} as any';
|
|
}
|
|
}
|