type-crafter 0.13.0 → 0.13.2

package/dist/index.js

@@ -21188,11 +21188,13 @@ function getReferencedTypeModules(_referencedTypes, _writtenAt) {
             resolveFilePath(outputFile.filePath) !== resolveFilePath(writtenAt)) {
             if (typeof referencedTypeModules[outputFile.modulePath] === 'undefined') {
                 const rawRelativePath = generateRelativePath(writtenAt, outputFile.modulePath);
+                const moduleName = outputFile.modulePath.split('/').pop() ?? '';
                 referencedTypeModules[outputFile.modulePath] = {
                     modulePath: outputFile.modulePath,
                     moduleRelativePath: formatModulePath(rawRelativePath, writtenAt, modulePathConfig),
                     referencedTypes: [referenceType],
-                    moduleName: outputFile.modulePath.split('/').pop() ?? ''
+                    moduleName,
+                    fileBasedModules: moduleName === (modulePathConfig?.moduleFileName ?? '')
                 };
             }
             else {
@@ -21234,6 +21236,20 @@ function toSnakeCaseHelper(input) {
     }
     return toSnakeCase(inputString);
 }
+function toCamelCase(input) {
+    const pascal = toPascalCase(input);
+    return pascal.charAt(0).toLowerCase() + pascal.slice(1);
+}
+function formatCase(input, fontCase) {
+    switch (fontCase) {
+        case 'snake_case':
+            return toSnakeCase(input);
+        case 'PascalCase':
+            return toPascalCase(input);
+        case 'camelCase':
+            return toCamelCase(input);
+    }
+}
 function refineJSONKey(input) {
     if (typeof input === 'string' && input.includes('-')) {
         return `'${input}'`;
@@ -21252,6 +21268,19 @@ function refineIndexKey(input) {
     }
     return input;
 }
+function escapeReservedWord(input) {
+    if (typeof input !== 'string') {
+        return input;
+    }
+    const config = Runtime.getConfig().language.reservedKeywords;
+    if (typeof config === 'undefined') {
+        return input;
+    }
+    if (config.words.includes(input)) {
+        return config.prefix + input;
+    }
+    return input;
+}
 function registerTemplateHelpers() {
     Handlebars.registerHelper('getOptionalKeys', getOptionalKeys);
     Handlebars.registerHelper('getRequiredKeys', getRequiredKeys);
@@ -21267,6 +21296,7 @@ function registerTemplateHelpers() {
     Handlebars.registerHelper('jsonKey', refineJSONKey);
     Handlebars.registerHelper('variableName', refineVariableName);
     Handlebars.registerHelper('indexKey', refineIndexKey);
+    Handlebars.registerHelper('escapeReservedWord', escapeReservedWord);
     Handlebars.registerHelper('stringify', (value) => JSON.stringify(value));
     Handlebars.registerHelper('not', (value) => {
         if (typeof value === 'boolean') {
@@ -21491,18 +21521,19 @@ async function generateAdditionalPropertiesType(typeName, typeInfo, parentTypes)
         type: 'string'
     }).templateInput.type;
     if (typeof typeInfo.additionalProperties === 'boolean') {
+        const unknownType = getPrimitiveType(typeName, {
+            ...placeholderTypeInfo,
+            type: 'unknown'
+        });
         return {
             templateInput: {
                 keyType: stringKeyType,
-                valueType: getPrimitiveType(typeName, {
-                    ...placeholderTypeInfo,
-                    type: 'unknown'
-                }).templateInput.type,
+                valueType: unknownType.templateInput.type,
                 valueTypeReferenced: false,
                 valuePrimitiveType: 'unknown',
                 valueComposerType: null
             },
-            primitives: new Set()
+            primitives: unknownType.primitives
         };
     }
     else if (valueIsKeyedAdditionalProperties(typeInfo.additionalProperties)) {
@@ -21582,8 +21613,7 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
             const referencedType = await generateReferencedType(propertyName, propertyDetails, parentTypes);
             recursivePropertyName = referencedType.templateInput.typeName;
             languageDataType = recursivePropertyName;
-            references.push(...referencedType.references);
-            primitives.push(...referencedType.primitives);
+            references.push(recursivePropertyName);
             isReferenced = true;
         }
         else if (enumValues !== null) {
@@ -21697,6 +21727,18 @@ async function generateArrayType(typeName, typeInfo, parentTypes) {
     }
     else {
         arrayItemsType = await generateType(typeName + 'Item', typeInfo.items, parentTypes);
+        // For referenced types (e.g. enums via $ref), use the type name as the item type
+        // identifier, consistent with how inline enums are handled above.
+        // Also only keep the direct reference — the referenced type handles its own imports.
+        // Create new objects to avoid mutating cached data from generateReferencedType.
+        if (typeInfo.items.$ref !== null) {
+            const refItemTypeName = arrayItemsType.templateInput.typeName;
+            arrayItemsType = {
+                ...arrayItemsType,
+                templateInput: { ...arrayItemsType.templateInput, type: refItemTypeName },
+                references: new Set([refItemTypeName])
+            };
+        }
     }
     if (typeof arrayItemsType.templateInput?.type === 'undefined') {
         throw new InvalidSpecFileError('Invalid array type for: ' + typeName);
@@ -21962,28 +22004,41 @@ async function generator(specFileData) {
         }
     }
     result.groupedTypes = groupedTypes;
+    // remove self references from grouped types
+    for (const groupName in result.groupedTypes) {
+        for (const typeName in result.groupedTypes[groupName]) {
+            result.groupedTypes[groupName][typeName].references.delete(typeName);
+        }
+    }
     return result;
 }
 
+function formatModuleName(name) {
+    const moduleNameCase = Runtime.getConfig().language.modulePathConfig.moduleNameCase;
+    return typeof moduleNameCase !== 'undefined' ? formatCase(name, moduleNameCase) : name;
+}
 function generateTypesOutputFiles(types, groupName = null) {
     const config = Runtime.getConfig();
     const extension = config.output.fileExtension;
     const outputDir = config.output.directory;
     const moduleFileName = config.language.exporterModuleName;
     const writerMode = groupName === null ? config.output.writerMode.types : config.output.writerMode.groupedTypes;
+    const formattedGroupName = groupName !== null ? formatModuleName(groupName) : null;
     const result = new Map();
     for (const typeName in types) {
         const typeProperties = types[typeName];
         if (typeof typeProperties !== 'undefined') {
+            const formattedTypeName = formatModuleName(typeName);
             result.set(typeName, {
                 modulePath: outputDir +
                     '/' +
-                    (writerMode === 'FolderWithFiles' ? (groupName ?? '') + '/' : '') +
-                    moduleFileName,
+                    (formattedGroupName
+                        ? formattedGroupName + (writerMode === 'FolderWithFiles' ? '/' + moduleFileName : '')
+                        : moduleFileName),
                 filePath: outputDir +
                     (writerMode === 'Files' || writerMode === 'FolderWithFiles'
-                        ? '/' + (groupName ?? '') + typeName
-                        : '/' + (groupName ?? 'types')),
+                        ? '/' + (formattedGroupName ?? '') + formattedTypeName
+                        : '/' + (formattedGroupName ?? 'types')),
                 extension
             });
         }
@@ -22041,7 +22096,7 @@ async function writeTypesToFiles(config, types, folderName = '') {
     const typeNames = Object.keys(types);
     for (const typeName in types) {
         const typeData = types[typeName];
-        const file = typeName + config.output.fileExtension;
+        const file = formatModuleName(typeName) + config.output.fileExtension;
         const references = filterReferences
             ? [...types[typeName].references].filter((x) => !typeNames.includes(x))
             : [...types[typeName].references];
@@ -22125,11 +22180,12 @@ async function writeOutput(generationResult) {
     if (config.output.writerMode.groupedTypes === 'FolderWithFiles') {
         for (const groupName in generationResult.groupedTypes) {
             let groupFilesWritten = null;
-            await createFolderWithBasePath(config.output.directory, groupName);
+            const formattedGroupName = formatModuleName(groupName);
+            await createFolderWithBasePath(config.output.directory, formattedGroupName);
             addValuesToMappedSet(writtenFiles, await getCompleteFolderPath(config.output.directory), [
-                groupName
+                formattedGroupName
             ]);
-            groupFilesWritten = await writeTypesToFiles(config, generationResult.groupedTypes[groupName], groupName);
+            groupFilesWritten = await writeTypesToFiles(config, generationResult.groupedTypes[groupName], formattedGroupName);
             if (groupFilesWritten !== null) {
                 addValuesToMappedSet(writtenFiles, await getCompleteFolderPath(groupFilesWritten.folderName), groupFilesWritten.files);
             }
@@ -22138,7 +22194,7 @@ async function writeOutput(generationResult) {
     else if (config.output.writerMode.groupedTypes === 'SingleFile') {
         for (const groupName in generationResult.groupedTypes) {
             let groupFilesWritten = null;
-            groupFilesWritten = await writeTypesToFile(config, generationResult.groupedTypes[groupName], groupName);
+            groupFilesWritten = await writeTypesToFile(config, generationResult.groupedTypes[groupName], formatModuleName(groupName));
             if (groupFilesWritten !== null) {
                 addValuesToMappedSet(writtenFiles, await getCompleteFolderPath(groupFilesWritten.folderName), groupFilesWritten.files);
             }
@@ -22301,7 +22357,64 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
                 parentRef: 'super',
                 selfRef: 'self',
                 moduleFileName: 'mod',
-                fileBasedModules: true
+                fileBasedModules: true,
+                moduleNameCase: 'snake_case'
+            },
+            reservedKeywords: {
+                prefix: 'r#',
+                words: [
+                    'as',
+                    'break',
+                    'const',
+                    'continue',
+                    'crate',
+                    'else',
+                    'enum',
+                    'extern',
+                    'false',
+                    'fn',
+                    'for',
+                    'if',
+                    'impl',
+                    'in',
+                    'let',
+                    'loop',
+                    'match',
+                    'mod',
+                    'move',
+                    'mut',
+                    'pub',
+                    'ref',
+                    'return',
+                    'self',
+                    'Self',
+                    'static',
+                    'struct',
+                    'super',
+                    'trait',
+                    'true',
+                    'type',
+                    'unsafe',
+                    'use',
+                    'where',
+                    'while',
+                    'async',
+                    'await',
+                    'dyn',
+                    'abstract',
+                    'become',
+                    'box',
+                    'do',
+                    'final',
+                    'macro',
+                    'override',
+                    'priv',
+                    'typeof',
+                    'unsized',
+                    'virtual',
+                    'yield',
+                    'try'
+                ]
             }
         }
     };
@@ -22374,7 +22487,7 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.13.0');
+const program = new Command().version('0.13.2');
 program
     .command('generate')
     .description('Generate types for your language from a type spec file')

package/dist/templates/rust/allOf-syntax.hbs

@@ -6,13 +6,13 @@ pub struct {{typeName}} {
 {{#each compositions}}
 {{#if (eq this.source 'referenced')}}
     #[serde(flatten)]
-    pub {{toSnakeCase this.referencedType}}: {{this.referencedType}},
+    pub {{escapeReservedWord (toSnakeCase this.referencedType)}}: {{this.referencedType}},
 {{else if (eq this.source 'inline')}}
 {{#if (eq this.dataType 'object')}}
     #[serde(flatten)]
-    pub {{toSnakeCase this.templateInput.typeName}}: {{this.templateInput.typeName}},
+    pub {{escapeReservedWord (toSnakeCase this.templateInput.typeName)}}: {{this.templateInput.typeName}},
 {{else}}
-    pub {{toSnakeCase this.templateInput.typeName}}: {{{this.templateInput.type}}},
+    pub {{escapeReservedWord (toSnakeCase this.templateInput.typeName)}}: {{{this.templateInput.type}}},
 {{/if}}
 {{/if}}
 {{/each}}

package/dist/templates/rust/object-syntax.hbs

@@ -10,11 +10,13 @@ pub struct {{typeName}} {
 {{#if this.description}}
     /// {{{this.description}}}
 {{/if}}
+{{#unless (eq @key (toSnakeCase @key))}}
     #[serde(rename = "{{@key}}")]
+{{/unless}}
 {{#unless this.required}}
     #[serde(skip_serializing_if = "Option::is_none")]
 {{/unless}}
-    pub {{toSnakeCase @key}}: {{#unless this.required}}Option<{{/unless}}{{{this.type}}}{{#unless this.required}}>{{/unless}},
+    pub {{escapeReservedWord (toSnakeCase @key)}}: {{#unless this.required}}Option<{{/unless}}{{{this.type}}}{{#unless this.required}}>{{/unless}},
 {{/each}}
 {{#if additionalProperties}}
     #[serde(flatten)]

package/dist/templates/rust/types-file-syntax.hbs

@@ -1,7 +1,11 @@
 use serde::{Serialize, Deserialize};
 {{#each (getReferencedTypeModules referencedTypes writtenAt)}}
 {{#each this.referencedTypes}}
-use {{{../moduleRelativePath}}}::{{this}}::{{this}};
+{{#if ../fileBasedModules}}
+use {{{../moduleRelativePath}}}::{{toSnakeCase this}}::{{this}};
+{{else}}
+use {{{../moduleRelativePath}}}::{{this}};
+{{/if}}
 {{/each}}
 {{/each}}
 

package/dist/types/index.d.ts

@@ -25,17 +25,24 @@ export type Template = {
     oneOfSyntax: string;
     allOfSyntax: string;
 };
+export type FontCase = 'snake_case' | 'PascalCase' | 'camelCase';
 export type ModulePathConfig = {
     separator: string;
     parentRef: string;
     selfRef: string;
     moduleFileName: string;
     fileBasedModules: boolean;
+    moduleNameCase?: FontCase;
+};
+export type ReservedKeywordsConfig = {
+    words: string[];
+    prefix: string;
 };
 export type LanguageConfig = {
     exporterModuleName: string;
     typeMapper: LanguageTypeMapper;
     modulePathConfig: ModulePathConfig;
+    reservedKeywords?: ReservedKeywordsConfig;
 };
 /**
  * @description Mappers for all the types supported by OpenAPI 3.0.0
@@ -149,6 +156,7 @@ export type ReferencedModule = {
     moduleRelativePath: string;
     referencedTypes: string[];
     moduleName: string;
+    fileBasedModules: boolean;
 };
 export type EnumTemplateInput = TypeDescriptors & {
     typeName: string;

package/dist/utils/index.d.ts

@@ -1,4 +1,4 @@
-import { type ModulePathConfig, type TypeInfo, type TypeDataType } from '$types';
+import { type ModulePathConfig, type FontCase, type TypeInfo, type TypeDataType } from '$types';
 import { type JSONObject } from 'type-decoder';
 export * from './file-system';
 export * from './logger';
@@ -11,9 +11,12 @@ export declare function toPascalCase(input: string): string;
 export declare function toPascalCaseHelper(input: unknown): string | unknown;
 export declare function toSnakeCase(input: string): string;
 export declare function toSnakeCaseHelper(input: unknown): string | unknown;
+export declare function toCamelCase(input: string): string;
+export declare function formatCase(input: string, fontCase: FontCase): string;
 export declare function refineJSONKey(input: unknown): unknown;
 export declare function refineVariableName(input: unknown): unknown;
 export declare function refineIndexKey(input: unknown): unknown;
+export declare function escapeReservedWord(input: unknown): unknown;
 export declare function registerTemplateHelpers(): void;
 export declare function readNestedValue(json: unknown, keyPath: string[]): JSONObject;
 export declare function generateRelativePath(fromPath: string, toPath: string): string;

package/dist/writer/helpers.d.ts

@@ -1,3 +1,4 @@
 import { type TypeFilePath, type Types } from '$types';
+export declare function formatModuleName(name: string): string;
 export declare function generateTypesOutputFiles(types: Types | null, groupName?: string | null): Map<string, TypeFilePath>;
 export declare function generateExpectedOutputFile(): Map<string, TypeFilePath>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-crafter",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "A tool to generate types from a yaml schema for any language",
   "main": "./dist/index.js",
   "type": "module",
@@ -15,8 +15,8 @@
   ],
   "scripts": {
     "dev": "tsc --watch",
-    "format:all": "npx prettier --write .",
-    "lint:all": "eslint src",
+    "format": "npx prettier --write .",
+    "lint": "eslint src",
     "clean:output": "rm -rf dist",
     "build": "npm run clean:output && rollup --config rollup.config.js"
   },