type-crafter 0.5.0 → 0.6.0

package/dist/generators/helpers.d.ts

@@ -1,5 +1,6 @@
-import { type ResolveReferenceData } from '$types';
-export declare function resolveReference(reference: string): Promise<ResolveReferenceData>;
+import { type ResolvedTypeReferenceData, type ResolvedGroupReferenceData } from '$types';
+export declare function resolveTypeReference(reference: string): Promise<ResolvedTypeReferenceData>;
+export declare function resolveGroupReference(reference: string): Promise<ResolvedGroupReferenceData>;
 export declare function fillPatterns(input: string, patterns: Array<{
     regex: RegExp;
     value: string;

package/dist/index.js

@@ -3488,7 +3488,9 @@ function decodeGroupedTypes(rawInput) {
         const result = {};
         for (const key in rawInput) {
             const value = rawInput[key];
-            const decodedValue = decodeTypes(value);
+            const decodedRefValue = decodeGroupRef(value);
+            const decodedTypes = decodeTypes(value);
+            const decodedValue = decodedRefValue ?? decodedTypes;
             if (decodedValue !== null) {
                 result[key] = decodedValue;
             }
@@ -3500,6 +3502,20 @@ function decodeGroupedTypes(rawInput) {
     }
     return null;
 }
+function valueIsGroupRef(value) {
+    return isJSON(value) && typeof value.$ref === 'string';
+}
+function decodeGroupRef(rawInput) {
+    if (isJSON(rawInput)) {
+        const ref = decodeString(rawInput.$ref);
+        if (ref !== null) {
+            return {
+                $ref: ref
+            };
+        }
+    }
+    return null;
+}
 function decodeTypes(rawInput) {
     if (isJSON(rawInput)) {
         const result = {};
@@ -12008,6 +12024,12 @@ function getCachedReferenceType(referencePath) {
 function cacheReferenceType(referencePath, generatedData) {
     cachedReferencedTypes.set(referencePath, generatedData);
 }
+function getInputFilePath(absolutePath = true) {
+    if (config$2 === null) {
+        throw new RuntimeError('Spec file path not set!');
+    }
+    return absolutePath ? resolveFilePath(config$2.input) : config$2.input;
+}
 var Runtime = {
     getConfig,
     setConfig,
@@ -12023,7 +12045,8 @@ var Runtime = {
     getOneOfTemplate,
     getCachedReferencedTypes,
     getCachedReferenceType,
-    cacheReferenceType
+    cacheReferenceType,
+    getInputFilePath
 };
 
 const ALIAS = Symbol.for('yaml.alias');
@@ -19479,6 +19502,24 @@ function toPascalCaseHelper(input) {
     }
     return toPascalCase(inputString);
 }
+function refineJSONKey(input) {
+    if (typeof input === 'string' && input.includes('-')) {
+        return `'${input}'`;
+    }
+    return input;
+}
+function refineVariableName(input) {
+    if (typeof input === 'string') {
+        return toPascalCase(input);
+    }
+    return input;
+}
+function refineIndexKey(input) {
+    if (typeof input === 'string') {
+        return `'${input}'`;
+    }
+    return input;
+}
 function registerTemplateHelpers() {
     Handlebars.registerHelper('getOptionalKeys', getOptionalKeys);
     Handlebars.registerHelper('getRequiredKeys', getRequiredKeys);
@@ -19488,6 +19529,9 @@ function registerTemplateHelpers() {
     Handlebars.registerHelper('toPascalCase', toPascalCaseHelper);
     Handlebars.registerHelper('isNonEmptyArray', (value) => Array.isArray(value) && value.length === 0);
     Handlebars.registerHelper('eq', (value1, value2) => value1 === value2);
+    Handlebars.registerHelper('jsonKey', refineJSONKey);
+    Handlebars.registerHelper('variableName', refineVariableName);
+    Handlebars.registerHelper('indexKey', refineIndexKey);
 }
 function readNestedValue(json, keyPath) {
     if (!isJSON(json)) {
@@ -19526,10 +19570,10 @@ function stripPrefix(value, prefix) {
 }
 // #endregion
 
-async function resolveReference(reference) {
-    let referenceType = 'unknown';
-    const referenceParts = reference.split('/');
-    const referenceName = referenceParts[referenceParts.length - 1];
+function getReferenceMeta(reference) {
+    const slashedParts = reference.split('/');
+    const hashSlashParts = reference.split('#');
+    let referenceType;
     if (reference.startsWith('#')) {
         referenceType = 'local';
     }
@@ -19539,32 +19583,61 @@ async function resolveReference(reference) {
     else {
         referenceType = 'remote';
     }
-    let result = null;
-    let referenceFileName;
-    if (referenceType === 'local') {
-        const specFileData = Runtime.getSpecFileData();
-        const referenceKeyPath = referenceParts.slice(1);
-        result = decodeTypeInfo(readNestedValue(specFileData, referenceKeyPath));
+    let completeSource = hashSlashParts.at(0);
+    const sourceFile = hashSlashParts.at(0)?.split('/').at(-1);
+    const path = hashSlashParts.at(1)?.slice(1);
+    const name = slashedParts[slashedParts.length - 1];
+    if (typeof completeSource === 'undefined' ||
+        typeof path === 'undefined' ||
+        typeof sourceFile === 'undefined') {
+        throw new InvalidSpecFileError('Invalid reference at: ' + reference);
     }
-    else if (referenceType === 'url') {
-        throw new UnsupportedFeatureError('URL references are not supported yet');
+    if (referenceType === 'remote' &&
+        resolveFilePath(completeSource) === Runtime.getInputFilePath()) {
+        completeSource = resolveFilePath(completeSource);
+        referenceType = 'local';
     }
-    else if (referenceType === 'remote') {
-        const indexOfExtension = reference.indexOf('.yaml');
-        const referenceFilePath = reference.slice(0, indexOfExtension + 5);
-        const typeDataPath = reference.slice(indexOfExtension + 6);
-        referenceFileName = referenceParts.find((part) => part.endsWith('.yaml'));
-        const referencedFileData = await readYaml(referenceFilePath);
-        const jsonValue = readNestedValue(referencedFileData, typeDataPath.split('/'));
-        result = decodeTypeInfo(jsonValue);
+    return {
+        completeSource,
+        sourceFile,
+        path,
+        type: referenceType,
+        name
+    };
+}
+async function getReferencedData(refMeta) {
+    let refFileData;
+    if (refMeta.type === 'local') {
+        refFileData = Runtime.getSpecFileData();
+    }
+    else if (refMeta.type === 'remote') {
+        refFileData = await readYaml(refMeta.completeSource);
     }
     else {
+        throw new UnsupportedFeatureError('URL references are not supported yet');
+    }
+    if (typeof refFileData === 'undefined') {
+        throw new InvalidSpecFileError('Invalid reference at: ' + refMeta.completeSource);
+    }
+    return readNestedValue(refFileData, refMeta.path.split('/'));
+}
+async function resolveTypeReference(reference) {
+    const refMeta = getReferenceMeta(reference);
+    const refData = await getReferencedData(refMeta);
+    const result = decodeTypeInfo(refData);
+    if (result === null) {
         throw new InvalidSpecFileError('Invalid reference at: ' + reference);
     }
+    return { typeInfo: result, ...refMeta };
+}
+async function resolveGroupReference(reference) {
+    const refMeta = getReferenceMeta(reference);
+    const refData = await getReferencedData(refMeta);
+    const result = decodeTypes(refData);
     if (result === null) {
         throw new InvalidSpecFileError('Invalid reference at: ' + reference);
     }
-    return { typeInfo: result, referenceName, sourceFile: referenceFileName };
+    return { groupedTypes: result, ...refMeta };
 }
 function fillPatterns(input, patterns) {
     let result = input;
@@ -19574,6 +19647,12 @@ function fillPatterns(input, patterns) {
     return result;
 }
 
+/**
+ * @description Generates the primitive type for the unit attribute in the spec.
+ * @param typeName { string }
+ * @param typeInfo { TypeInfo }
+ * @returns {GeneratedType<VariableTemplateInput>}
+ */
 function getPrimitiveType(typeName, typeInfo) {
     if (typeInfo.type === null) {
         throw new InvalidSpecFileError('Invalid type for: ' + typeName);
@@ -19609,7 +19688,7 @@ function getPrimitiveType(typeName, typeInfo) {
     result.primitives.add(languageDataType);
     return result;
 }
-async function generateObjectType(typeName, typeInfo) {
+async function generateObjectType(typeName, typeInfo, parentTypes) {
     const templateInput = {
         typeName,
         type: typeName,
@@ -19622,13 +19701,14 @@ async function generateObjectType(typeName, typeInfo) {
     let dynamicGeneratedType = '';
     const primitives = [];
     const references = [];
+    // Generating types for properties
     for (const propertyName in typeInfo.properties) {
         const propertyDetails = typeInfo.properties[propertyName];
         const propertyType = propertyDetails.type;
         const reference = propertyDetails.$ref ?? null;
         const enumValues = propertyDetails.enum ?? null;
         // Throwing error in case neither property type nor reference to a different type is present
-        if (propertyType === null && reference === null) {
+        if (propertyType === null && reference === null && propertyDetails.oneOf === null) {
             throw new InvalidSpecFileError('Invalid property type for: ' + typeName + '.' + propertyName);
         }
         const primitiveType = propertyType ?? 'object';
@@ -19637,7 +19717,7 @@ async function generateObjectType(typeName, typeInfo) {
         let languageDataType = null;
         let isReferenced = false;
         if (reference !== null) {
-            const referencedType = await generateReferencedType(propertyName, propertyDetails);
+            const referencedType = await generateReferencedType(propertyName, propertyDetails, parentTypes);
             recursivePropertyName = referencedType.templateInput.typeName;
             languageDataType = recursivePropertyName;
             references.push(...referencedType.references);
@@ -19650,7 +19730,7 @@ async function generateObjectType(typeName, typeInfo) {
             languageDataType = enumName;
         }
         else if (propertyType === 'array') {
-            const arrayDataGenOutput = await generateArrayType(propertyName, propertyDetails);
+            const arrayDataGenOutput = await generateArrayType(propertyName, propertyDetails, parentTypes);
             primitives.push(...arrayDataGenOutput.primitives);
             references.push(...arrayDataGenOutput.references);
             languageDataType = arrayDataGenOutput.templateInput.type;
@@ -19658,16 +19738,17 @@ async function generateObjectType(typeName, typeInfo) {
         }
         else if (propertyType === 'object') {
             recursivePropertyName = toPascalCase(propertyName);
-            recursiveTypeGenOutput = await generateObjectType(recursivePropertyName, typeInfo.properties[propertyName]);
+            recursiveTypeGenOutput = await generateObjectType(recursivePropertyName, typeInfo.properties[propertyName], parentTypes);
             languageDataType = recursivePropertyName;
             references.push(...recursiveTypeGenOutput.references);
             primitives.push(...recursiveTypeGenOutput.primitives);
         }
         else {
-            const primitiveTypeGenOutput = getPrimitiveType(propertyName, propertyDetails);
+            const primitiveTypeGenOutput = await generateType(typeName + toPascalCase(propertyName), propertyDetails, parentTypes);
             languageDataType = primitiveTypeGenOutput.templateInput.type;
             primitives.push(...primitiveTypeGenOutput.primitives);
             references.push(...primitiveTypeGenOutput.references);
+            dynamicGeneratedType = primitiveTypeGenOutput.content;
         }
         if (languageDataType === null) {
             throw new InvalidSpecFileError(`Invalid language data type for: ${typeName}.${propertyName}`);
@@ -19696,6 +19777,12 @@ async function generateObjectType(typeName, typeInfo) {
     };
     return result;
 }
+/**
+ * @description Generated ENUM type for the unit attribute in the spec.
+ * @param typeName
+ * @param typeInfo
+ * @returns {GeneratedType<EnumTemplateInput>}
+ */
 function generateEnumType(typeName, typeInfo) {
     if (typeInfo.enum === null || typeInfo.enum.length === 0 || typeInfo.type === null) {
         throw new InvalidSpecFileError('Invalid enum type for: ' + typeName);
@@ -19717,11 +19804,11 @@ function generateEnumType(typeName, typeInfo) {
     result.content = Runtime.getEnumTemplate()(templateInput);
     return result;
 }
-async function generateArrayType(typeName, typeInfo) {
+async function generateArrayType(typeName, typeInfo, parentTypes) {
     if (typeInfo.items === null) {
         throw new InvalidSpecFileError('Invalid array type for: ' + typeName);
     }
-    const arrayItemsType = await generateType(typeName, typeInfo.items);
+    const arrayItemsType = await generateType(typeName + 'Item', typeInfo.items, parentTypes);
     if (typeof arrayItemsType.templateInput?.type === 'undefined') {
         throw new InvalidSpecFileError('Invalid array type for: ' + typeName);
     }
@@ -19766,7 +19853,7 @@ function generateVariableType(typeName, typeInfo) {
         templateInput
     };
 }
-async function generateReferencedType(typeName, typeInfo) {
+async function generateReferencedType(typeName, typeInfo, parentTypes) {
     if (typeInfo.$ref === null) {
         throw new InvalidSpecFileError('Invalid referenced type for: ' + typeName);
     }
@@ -19774,18 +19861,18 @@ async function generateReferencedType(typeName, typeInfo) {
     if (cachedReferencedType !== null) {
         return cachedReferencedType.templateData;
     }
-    const referencedTypeInfo = await resolveReference(typeInfo.$ref);
-    const referencedGeneratedType = await generateType(referencedTypeInfo.referenceName, referencedTypeInfo.typeInfo);
+    const referencedTypeInfo = await resolveTypeReference(typeInfo.$ref);
+    const referencedGeneratedType = await generateType(referencedTypeInfo.name, referencedTypeInfo.typeInfo, parentTypes);
     const result = {
         content: referencedGeneratedType.content,
-        references: new Set([...referencedGeneratedType.references, referencedTypeInfo.referenceName]),
+        references: new Set([...referencedGeneratedType.references, referencedTypeInfo.name]),
         primitives: referencedGeneratedType.primitives,
         templateInput: referencedGeneratedType.templateInput
     };
     Runtime.cacheReferenceType(typeInfo.$ref, { ...referencedTypeInfo, templateData: result });
     return result;
 }
-async function generateOneOfTypes(typeName, typeInfo) {
+async function generateOneOfTypes(typeName, typeInfo, parentTypes) {
     if (typeInfo.oneOf === null || typeInfo.oneOf.length === 0) {
         throw new InvalidSpecFileError('Invalid oneOf type for: ' + typeName);
     }
@@ -19806,16 +19893,16 @@ async function generateOneOfTypes(typeName, typeInfo) {
     for (let index = 0; index < typeInfo.oneOf.length; index++) {
         const oneOfItem = typeInfo.oneOf[index];
         if (oneOfItem.$ref !== null) {
-            const referenceData = await resolveReference(oneOfItem.$ref);
+            const referenceData = await resolveTypeReference(oneOfItem.$ref);
             const composition = {
                 source: 'referenced',
-                referencedType: referenceData.referenceName
+                referencedType: referenceData.name
             };
             templateInput.compositions.push(composition);
-            result.references.add(referenceData.referenceName);
+            result.references.add(referenceData.name);
         }
         else {
-            const generatedType = await generateType(typeName + (index + 1), oneOfItem);
+            const generatedType = await generateType(typeName + (index + 1), oneOfItem, parentTypes);
             if (generatedType === null) {
                 throw new InvalidSpecFileError('Invalid oneOf type for: ' + typeName);
             }
@@ -19837,21 +19924,41 @@ async function generateOneOfTypes(typeName, typeInfo) {
     result.content = Runtime.getOneOfTemplate()(templateInput);
     return result;
 }
-async function generateType(typeName, typeInfo) {
+function returnCyclicReference(typeName) {
+    const templateInput = {
+        typeName,
+        type: typeName,
+        composerType: typeName,
+        description: '',
+        example: '',
+        summary: ''
+    };
+    return {
+        content: '',
+        references: new Set(),
+        primitives: new Set(),
+        templateInput
+    };
+}
+async function generateType(typeName, typeInfo, parentTypes) {
+    if (parentTypes.includes(typeName)) {
+        return returnCyclicReference(typeName);
+    }
+    parentTypes = [...parentTypes, typeName];
     if (typeInfo.type === 'object') {
-        return await generateObjectType(typeName, typeInfo);
+        return await generateObjectType(typeName, typeInfo, parentTypes);
     }
     if (typeInfo.enum !== null) {
         return generateEnumType(typeName, typeInfo);
     }
     if (typeInfo.oneOf !== null) {
-        return await generateOneOfTypes(typeName, typeInfo);
+        return await generateOneOfTypes(typeName, typeInfo, parentTypes);
     }
     if (typeInfo.type === 'array') {
-        return await generateArrayType(typeName, typeInfo);
+        return await generateArrayType(typeName, typeInfo, parentTypes);
     }
     if (typeInfo.$ref !== null) {
-        return await generateReferencedType(typeName, typeInfo);
+        return await generateReferencedType(typeName, typeInfo, parentTypes);
     }
     return generateVariableType(typeName, typeInfo);
 }
@@ -19859,7 +19966,11 @@ async function generateTypes(types) {
     const result = {};
     for (const type in types) {
         const typeInfo = types[type];
-        result[type] = await generateType(type, typeInfo);
+        const generatedData = await generateType(type, typeInfo, []);
+        // Not storing top level referenced types as they are already generated somewhere else
+        if (typeInfo.$ref === null) {
+            result[type] = generatedData;
+        }
     }
     return result;
 }
@@ -19872,18 +19983,34 @@ async function generator(specFileData) {
     if (specFileData.types !== null) {
         result.types = await generateTypes(specFileData.types);
     }
+    // remove self references
+    for (const typeName in result.types) {
+        const typeData = result.types[typeName];
+        typeData.references.delete(typeName);
+    }
     // generating grouped types
     const groupedTypes = {};
+    const referencedGroups = [];
     for (const groupName in specFileData.groupedTypes) {
-        groupedTypes[groupName] = await generateTypes(specFileData.groupedTypes[groupName]);
+        const groupData = specFileData.groupedTypes[groupName];
+        if (!valueIsGroupRef(groupData)) {
+            groupedTypes[groupName] = await generateTypes(groupData);
+        }
+        else {
+            const groupRefData = await resolveGroupReference(groupData.$ref);
+            referencedGroups.push(groupRefData);
+        }
+    }
+    for (const refGroup of referencedGroups) {
+        groupedTypes[refGroup.name] = await generateTypes(refGroup.groupedTypes);
     }
     // storing remote referenced to output
     for (const generatedRefData of Runtime.getCachedReferencedTypes().values()) {
-        if (typeof generatedRefData.sourceFile === 'string') {
+        if (typeof generatedRefData.sourceFile === 'string' && generatedRefData.type !== 'local') {
             const refGroupName = toPascalCase(generatedRefData.sourceFile.replace('.yaml', ''));
             groupedTypes[refGroupName] = {
                 ...groupedTypes[refGroupName],
-                [generatedRefData.referenceName]: generatedRefData.templateData
+                [generatedRefData.name]: generatedRefData.templateData
             };
         }
     }
@@ -19922,25 +20049,33 @@ function generateExpectedOutputFile() {
     result = new Map([...generateTypesOutputFiles(specData.types)]);
     for (const groupName in specData.groupedTypes) {
         const group = specData.groupedTypes[groupName];
-        result = new Map([...result, ...generateTypesOutputFiles(group, groupName)]);
+        // No File/Folder will be created for referenced groups
+        if (!valueIsGroupRef(group)) {
+            result = new Map([...result, ...generateTypesOutputFiles(group, groupName)]);
+        }
     }
     // Generating expect writing types for referenced types
     let referredGroups = {};
     for (const generatedRefData of Runtime.getCachedReferencedTypes().values()) {
-        if (typeof generatedRefData.sourceFile !== 'undefined') {
+        if (typeof generatedRefData.sourceFile !== 'undefined' &&
+            generatedRefData.completeSource !== Runtime.getInputFilePath() // Preventing new file creation for remote references from base file
+        ) {
             const groupName = toPascalCase(generatedRefData.sourceFile.replace('.yaml', ''));
             referredGroups = {
                 ...referredGroups,
                 [groupName]: {
                     ...referredGroups[groupName],
-                    [generatedRefData.referenceName]: generatedRefData.typeInfo
+                    [generatedRefData.name]: generatedRefData.typeInfo
                 }
             };
         }
     }
     for (const groupName in referredGroups) {
         const group = referredGroups[groupName];
-        result = new Map([...result, ...generateTypesOutputFiles(group, groupName)]);
+        // No File/Folder will be created for referenced groups
+        if (!valueIsGroupRef(group)) {
+            result = new Map([...result, ...generateTypesOutputFiles(group, groupName)]);
+        }
     }
     return result;
 }
@@ -19951,11 +20086,19 @@ async function writeTypesToFiles(config, types, folderName = '') {
         folderName: config.output.directory + '/' + folderName,
         files: []
     };
+    // Filtering references for writing types to files; Done for types.writerMode: Files
+    // Maybe a hack. But it works for now
+    // Fix this later
+    const filterReferences = folderName !== '';
+    const typeNames = Object.keys(types);
     for (const typeName in types) {
         const typeData = types[typeName];
         const file = typeName + config.output.fileExtension;
+        const references = filterReferences
+            ? [...types[typeName].references].filter((x) => !typeNames.includes(x))
+            : [...types[typeName].references];
         const templateInput = {
-            referencedTypes: [...typeData.references],
+            referencedTypes: references,
             primitives: [...typeData.primitives],
             typesContent: typeData.content,
             writtenAt: await getExpectedWrittenPath(result.folderName, file)
@@ -19976,9 +20119,12 @@ async function writeTypesToFile(config, types, fileName = 'types') {
         typesContent: '',
         writtenAt: ''
     };
+    const typeNames = Object.keys(types);
     for (const typeName in types) {
         templateInput.primitives.push(...types[typeName].primitives);
-        templateInput.referencedTypes.push(...types[typeName].references);
+        // Removing references that are already written to file
+        const _references = [...types[typeName].references].filter((x) => !typeNames.includes(x));
+        templateInput.referencedTypes.push(..._references);
         templateInput.typesContent += types[typeName].content + '\n';
     }
     // remove duplicates
@@ -20080,7 +20226,7 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
             typeMapper: {
                 string: { default: 'string', date: 'Date' },
                 number: { default: 'number' },
-                integer: { default: 'integer' },
+                integer: { default: 'number' },
                 boolean: 'boolean',
                 array: '~ItemType~[]',
                 object: 'type',
@@ -20122,7 +20268,7 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
             typeMapper: {
                 string: { default: 'string', date: 'Date' },
                 number: { default: 'number' },
-                integer: { default: 'integer' },
+                integer: { default: 'number' },
                 boolean: 'boolean',
                 array: '~ItemType~[]',
                 object: 'type',
@@ -20179,15 +20325,15 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.5.0');
+const program = new Command().version('0.6.0');
 program
     .command('generate')
     .description('Generate types for your language from a type spec file')
     .argument('<outputLanguage>', 'Language to generate types for')
     .argument('<inputFilePath>', 'Path to the input spec file')
     .argument('<outputDirectory>', 'Path to the output file')
-    .argument('[typesWriterMode]', 'Writer mode for types', 'SingleFile')
-    .argument('[groupedTypesWriterMode]', 'Writer mode for grouped types', 'SingleFile')
+    .argument('[typesWriterMode]', 'Writer mode for types', 'Files')
+    .argument('[groupedTypesWriterMode]', 'Writer mode for grouped types', 'FolderWithFiles')
     .action(runner);
 program.parse();
 

package/dist/runtime.d.ts

@@ -14,6 +14,7 @@ declare function getExpectedOutputFiles(): Map<string, TypeFilePath>;
 declare function getCachedReferencedTypes(): Map<string, GeneratedReferencedType>;
 declare function getCachedReferenceType(referencePath: string): GeneratedReferencedType | null;
 declare function cacheReferenceType(referencePath: string, generatedData: GeneratedReferencedType): void;
+declare function getInputFilePath(absolutePath?: boolean): string;
 declare const _default: {
     getConfig: typeof getConfig;
     setConfig: typeof setConfig;
@@ -30,5 +31,6 @@ declare const _default: {
     getCachedReferencedTypes: typeof getCachedReferencedTypes;
     getCachedReferenceType: typeof getCachedReferenceType;
     cacheReferenceType: typeof cacheReferenceType;
+    getInputFilePath: typeof getInputFilePath;
 };
 export default _default;

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

@@ -19,6 +19,6 @@ export type {{typeName}} = {
    * @example {{{this.example}}}
   {{/if}}
    */
-  {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
+  {{{jsonKey @key}}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
   {{/each}}
 };

package/dist/templates/typescript/oneOf-syntax.hbs

@@ -13,7 +13,7 @@ export type {{typeName}} =
         {{/each}}
       }
     {{else}}
-      {{this.templateInput.dataType}}
+      {{this.templateInput.type}}
     {{/if}}
   {{/if}}
 {{/each}};

package/dist/templates/typescript-with-decoders/object-syntax.hbs

@@ -19,20 +19,20 @@ export type {{typeName}} = {
    * @example {{{this.example}}}
   {{/if}}
    */
-  {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
+  {{{jsonKey @key}}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
   {{/each}}
 };
 
 export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   if (isJSON(rawInput)) {
     {{#each properties}}
-    const {{@key}} = {{#if (eq this.primitiveType 'array') }} decodeArray(rawInput.{{@key}}, decode{{{toPascalCase this.composerType}}}){{else}} decode{{{toPascalCase this.type}}}(rawInput.{{@key}}){{/if}};
+    const decoded{{variableName @key}} = {{#if (eq this.primitiveType 'array') }} decodeArray(rawInput[{{{indexKey @key}}}], decode{{{toPascalCase this.composerType}}}){{else}} decode{{{toPascalCase this.type}}}(rawInput[{{{indexKey @key}}}]){{/if}};
     {{/each}}
 
     {{#if (areRequiredKeysPresent properties)}}
     if (
       {{#each (getRequiredKeys properties)}}
-      {{this}} === null{{#unless @last}} ||{{/unless}}
+      decoded{{toPascalCase this}} === null{{#unless @last}} ||{{/unless}}
       {{/each}}
     ) {
       return null;
@@ -41,7 +41,7 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
 
     return {
       {{#each properties}}
-      {{@key}},
+      {{{jsonKey @key}}}: decoded{{{variableName @key}}},
       {{/each}}
     };
   }

package/dist/templates/typescript-with-decoders/oneOf-syntax.hbs

@@ -7,7 +7,7 @@ export type {{typeName}} =
     {{else if (eq this.dataType 'object')}}
       C{{this.templateInput.typeName}}
     {{else}}
-      {{this.templateInput.dataType}}
+      {{this.templateInput.type}}
     {{/if}}
   {{/if}}
 {{/each}};
@@ -19,12 +19,12 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
     decodeC{{referencedType}}(rawInput)
   {{else if (eq this.dataType 'object')}}
     decodeC{{this.templateInput.typeName}}(rawInput)
-  {{else if (eq this.templateInput.primitiveType 'array')}}
-    decodeArray(rawInput, decode{{{toPascalCase this.templateInput.itemType}}})
+  {{else if (eq this.dataType 'array')}}
+    decodeArray(rawInput, decode{{{toPascalCase this.templateInput.composerType}}})
   {{else if this.templateInput.values}}
     decode{{this.templateInput.typeName}}(rawInput)
   {{else}}
-    decode{{{toPascalCase this.templateInput.dataType}}}(rawInput)
+    decode{{{toPascalCase this.templateInput.type}}}(rawInput)
   {{/if}}{{#unless @last}}??{{/unless}}
   {{/each}};
   return result;

package/dist/types/decoders.d.ts

@@ -1,7 +1,9 @@
-import type { EnumTemplateInput, GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypeInfo, TypesWriterMode } from '.';
+import type { GroupRef, EnumTemplateInput, GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypeInfo, Types, TypesWriterMode, GroupTypesData } from '.';
 export declare function decodeGroupedTypesWriterMode(rawInput: unknown): GroupedTypesWriterMode | null;
 export declare function decodeTypesWriterMode(rawInput: unknown): TypesWriterMode | null;
 export declare function decodeSpecFileData(rawInput: unknown): SpecFileData | null;
+export declare function valueIsGroupRef(value: GroupTypesData): value is GroupRef;
+export declare function decodeTypes(rawInput: unknown): Types | null;
 export declare function decodeTypeInfo(rawInput: unknown): TypeInfo | null;
 export declare function decodeObjectTemplateInputProperties(rawInput: unknown): ObjectTemplateInputProperties | null;
 export declare function decodeEnumTemplateInput(rawInput: unknown): EnumTemplateInput | null;

package/dist/types/index.d.ts

@@ -36,12 +36,21 @@ export type FormatType = {
     default: string;
     [format: string]: string | undefined;
 };
-export type ResolveReferenceData = {
+export type ReferenceType = 'local' | 'remote' | 'url';
+export type ReferenceMeta = {
+    completeSource: string;
+    sourceFile: string;
+    path: string;
+    type: ReferenceType;
+    name: string;
+};
+export type ResolvedTypeReferenceData = ReferenceMeta & {
     typeInfo: TypeInfo;
-    referenceName: string;
-    sourceFile?: string;
 };
-export type GeneratedReferencedType = ResolveReferenceData & {
+export type ResolvedGroupReferenceData = ReferenceMeta & {
+    groupedTypes: Types;
+};
+export type GeneratedReferencedType = ResolvedTypeReferenceData & {
     templateData: GeneratedType<TemplateInput>;
 };
 export type SpecFileData = {
@@ -54,7 +63,11 @@ export type SpecInfo = {
     title: string;
 };
 type GroupName = string;
-export type GroupedTypes = Record<GroupName, Types>;
+export type GroupedTypes = Record<GroupName, GroupTypesData>;
+export type GroupTypesData = Types | GroupRef;
+export type GroupRef = {
+    $ref: string;
+};
 type TypeName = string;
 export type Types = Record<TypeName, TypeInfo>;
 export type TypeInfo = TypeDescriptors & {

package/dist/utils/index.d.ts

@@ -8,6 +8,9 @@ export declare function getReferencedTypes(object: unknown): string[];
 export declare function getReferencedTypeModules(_referencedTypes: unknown, _writtenAt: string): unknown[];
 export declare function toPascalCase(input: string): string;
 export declare function toPascalCaseHelper(input: unknown): string | unknown;
+export declare function refineJSONKey(input: unknown): unknown;
+export declare function refineVariableName(input: unknown): unknown;
+export declare function refineIndexKey(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,3 @@
-import type { TypeFilePath, Types } from '$types';
+import { type TypeFilePath, type Types } from '$types';
 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.5.0",
+  "version": "0.6.0",
   "description": "A tool to generate types from a yaml schema for any language",
   "main": "./dist/index.js",
   "type": "module",