type-crafter 0.7.0 → 0.8.1

package/dist/index.js

@@ -3558,6 +3558,7 @@ function decodeTypeInfo(rawInput) {
             description: decodeString(rawInput.description),
             example: decodeString(rawInput.example) ?? decodeNumber(rawInput.example),
             oneOf: decodeArray(rawInput.oneOf, decodeTypeInfo),
+            allOf: decodeArray(rawInput.allOf, decodeTypeInfo),
             additionalProperties,
             enum: _type === 'string'
                 ? decodeArray(rawInput.enum, decodeString)
@@ -11982,6 +11983,7 @@ let exporterModuleSyntaxTemplate = null;
 let typesFileSyntaxTemplate = null;
 let oneOfSyntaxTemplate = null;
 let enumSyntaxTemplate = null;
+let allOfSyntaxTemplate = null;
 const cachedReferencedTypes = new Map();
 let expectedOutputFiles = null;
 function setConfig(newConfig) {
@@ -12009,6 +12011,7 @@ function compileTemplates() {
     typesFileSyntaxTemplate = Handlebars.compile(config.template.typesFileSyntax);
     enumSyntaxTemplate = Handlebars.compile(config.template.enumSyntax);
     oneOfSyntaxTemplate = Handlebars.compile(config.template.oneOfSyntax);
+    allOfSyntaxTemplate = Handlebars.compile(config.template.allOfSyntax);
 }
 function getObjectTemplate() {
     if (objectSyntaxTemplate === null) {
@@ -12064,6 +12067,12 @@ function getInputFilePath(absolutePath = true) {
     }
     return absolutePath ? resolveFilePath(config$2.input) : config$2.input;
 }
+function getAllOfTemplate() {
+    if (allOfSyntaxTemplate === null) {
+        throw new RuntimeError('AllOf template not compiled!');
+    }
+    return allOfSyntaxTemplate;
+}
 var Runtime = {
     getConfig,
     setConfig,
@@ -12080,7 +12089,8 @@ var Runtime = {
     getCachedReferencedTypes,
     getCachedReferenceType,
     cacheReferenceType,
-    getInputFilePath
+    getInputFilePath,
+    getAllOfTemplate
 };
 
 const ALIAS = Symbol.for('yaml.alias');
@@ -19399,7 +19409,16 @@ function resolveFilePath(filePath, useCurrentDirectory = true) {
         : path$1.join(useCurrentDirectory ? process.cwd() : getSourceFileDirectory(), filePath);
     return path$1.resolve(normalizedPath);
 }
+async function checkFileNameCase(filePath) {
+    const directory = path$1.dirname(filePath);
+    const fileName = path$1.basename(filePath);
+    const files = await fs$1.readdir(directory);
+    return files.includes(fileName);
+}
 async function readFile(filePath, useCurrentWorkingDirectory = true) {
+    if (!(await checkFileNameCase(filePath))) {
+        throw new Error(`File not found: ${filePath}`);
+    }
     const data = await fs$1.readFile(resolveFilePath(filePath, useCurrentWorkingDirectory), 'utf-8');
     return data;
 }
@@ -19563,9 +19582,21 @@ 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('notEq', (value1, value2) => value1 !== value2);
+    Handlebars.registerHelper('isEmptyObject', (value) => typeof value === 'object' && value !== null && Object.keys(value).length === 0);
     Handlebars.registerHelper('jsonKey', refineJSONKey);
     Handlebars.registerHelper('variableName', refineVariableName);
     Handlebars.registerHelper('indexKey', refineIndexKey);
+    Handlebars.registerHelper('not', (value) => {
+        if (typeof value === 'boolean') {
+            return !value;
+        }
+    });
+    Handlebars.registerHelper('or', (value1, value2) => {
+        if (typeof value1 === 'boolean' && typeof value2 === 'boolean') {
+            return value1 || value2;
+        }
+    });
 }
 function readNestedValue(json, keyPath) {
     if (!isJSON(json)) {
@@ -19689,6 +19720,7 @@ const placeholderTypeInfo = {
     properties: null,
     $ref: null,
     oneOf: null,
+    allOf: null,
     enum: null,
     additionalProperties: null,
     summary: null,
@@ -19778,7 +19810,7 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
         summary: typeInfo.summary,
         properties: {}
     };
-    let recursiveTypeGenOutput = null;
+    const compositions = [];
     let dynamicGeneratedType = '';
     const primitives = [];
     const references = [];
@@ -19821,8 +19853,9 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
             composerType = arrayDataGenOutput.templateInput.composerType ?? null;
         }
         else if (propertyType === 'object') {
-            recursivePropertyName = toPascalCase(propertyName);
-            recursiveTypeGenOutput = await generateObjectType(recursivePropertyName, typeInfo.properties[propertyName], parentTypes);
+            recursivePropertyName = typeName + toPascalCase(propertyName);
+            const recursiveTypeGenOutput = await generateObjectType(recursivePropertyName, typeInfo.properties[propertyName], parentTypes);
+            compositions.push(recursiveTypeGenOutput);
             languageDataType = recursivePropertyName;
             references.push(...recursiveTypeGenOutput.references);
             primitives.push(...recursiveTypeGenOutput.primitives);
@@ -19858,7 +19891,9 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
     }
     const result = {
         content: Runtime.getObjectTemplate()(templateInput) +
-            (recursiveTypeGenOutput?.content ?? '') +
+            compositions.reduce((acc, curr) => {
+                return acc + curr.content;
+            }, '') +
             dynamicGeneratedType,
         primitives: new Set(primitives),
         references: new Set(references),
@@ -19982,13 +20017,13 @@ async function generateOneOfTypes(typeName, typeInfo, parentTypes) {
     for (let index = 0; index < typeInfo.oneOf.length; index++) {
         const oneOfItem = typeInfo.oneOf[index];
         if (oneOfItem.$ref !== null) {
-            const referenceData = await resolveTypeReference(oneOfItem.$ref);
+            const referenceData = await generateReferencedType(typeName + (index + 1), oneOfItem, parentTypes);
             const composition = {
                 source: 'referenced',
-                referencedType: referenceData.name
+                referencedType: referenceData.templateInput.typeName
             };
             templateInput.compositions.push(composition);
-            result.references.add(referenceData.name);
+            result.references.add(referenceData.templateInput.typeName);
         }
         else {
             const generatedType = await generateType(typeName + (index + 1), oneOfItem, parentTypes);
@@ -20013,6 +20048,58 @@ async function generateOneOfTypes(typeName, typeInfo, parentTypes) {
     result.content = Runtime.getOneOfTemplate()(templateInput);
     return result;
 }
+async function generateAllOfTypes(typeName, typeInfo, parentTypes) {
+    if (typeInfo.allOf === null || typeInfo.allOf.length === 0) {
+        throw new InvalidSpecFileError('Invalid allOf type for: ' + typeName);
+    }
+    const templateInput = {
+        typeName,
+        type: typeName,
+        compositions: [],
+        description: typeInfo.description,
+        example: typeInfo.example,
+        summary: typeInfo.summary
+    };
+    const result = {
+        content: '',
+        references: new Set(),
+        primitives: new Set(),
+        templateInput
+    };
+    for (let index = 0; index < typeInfo.allOf.length; index++) {
+        const allOfItem = typeInfo.allOf[index];
+        if (allOfItem.$ref !== null) {
+            const referenceData = await generateReferencedType(typeName + 'AllOf' + index, allOfItem, parentTypes);
+            const composition = {
+                source: 'referenced',
+                referencedType: referenceData.templateInput.typeName
+            };
+            templateInput.compositions.push(composition);
+            result.references.add(referenceData.templateInput.typeName);
+        }
+        else {
+            const generatedType = await generateType(typeName + (index + 1), allOfItem, parentTypes);
+            if (generatedType === null) {
+                throw new InvalidSpecFileError('Invalid allOf type for: ' + typeName);
+            }
+            const composition = {
+                dataType: allOfItem.type,
+                templateInput: generatedType.templateInput,
+                source: 'inline',
+                content: generatedType.content
+            };
+            templateInput.compositions.push(composition);
+            for (const reference of generatedType.references.values()) {
+                result.references.add(reference);
+            }
+            for (const primitive of generatedType.primitives.values()) {
+                result.primitives.add(primitive);
+            }
+        }
+    }
+    result.content = Runtime.getAllOfTemplate()(templateInput);
+    return result;
+}
 function returnCyclicReference(typeName) {
     const templateInput = {
         typeName,
@@ -20043,6 +20130,9 @@ async function generateType(typeName, typeInfo, parentTypes) {
     if (typeInfo.oneOf !== null) {
         return await generateOneOfTypes(typeName, typeInfo, parentTypes);
     }
+    if (typeInfo.allOf !== null) {
+        return await generateAllOfTypes(typeName, typeInfo, parentTypes);
+    }
     if (typeInfo.type === 'array') {
         return await generateArrayType(typeName, typeInfo, parentTypes);
     }
@@ -20292,6 +20382,7 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
     const typesFileSyntax = await readFile(directoryPrefix + 'templates/typescript/types-file-syntax.hbs', devMode);
     const enumSyntax = await readFile(directoryPrefix + 'templates/typescript/enum-syntax.hbs', devMode);
     const oneOfSyntax = await readFile(directoryPrefix + 'templates/typescript/oneOf-syntax.hbs', devMode);
+    const allOfSyntax = await readFile(directoryPrefix + 'templates/typescript/allOf-syntax.hbs', devMode);
     const config = {
         input: inputFilePath,
         output: {
@@ -20308,7 +20399,8 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
             exporterModuleSyntax,
             typesFileSyntax,
             enumSyntax,
-            oneOfSyntax
+            oneOfSyntax,
+            allOfSyntax
         },
         language: {
             exporterModuleName: 'index',
@@ -20334,6 +20426,7 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
     const typesFileSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/types-file-syntax.hbs', devMode);
     const enumSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/enum-syntax.hbs', devMode);
     const oneOfSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/oneOf-syntax.hbs', devMode);
+    const allOfSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/allOf-syntax.hbs', devMode);
     const config = {
         input: inputFilePath,
         output: {
@@ -20350,7 +20443,8 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
             exporterModuleSyntax,
             typesFileSyntax,
             enumSyntax,
-            oneOfSyntax
+            oneOfSyntax,
+            allOfSyntax
         },
         language: {
             exporterModuleName: 'index',
@@ -20414,7 +20508,7 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.7.0');
+const program = new Command().version('0.8.1');
 program
     .command('generate')
     .description('Generate types for your language from a type spec file')

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { Configuration, EnumTemplateInput, ExporterModuleTemplateInput, GeneratedReferencedType, ObjectTemplateInput, OneOfTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
+import type { AllOfTemplateInput, Configuration, EnumTemplateInput, ExporterModuleTemplateInput, GeneratedReferencedType, ObjectTemplateInput, OneOfTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
 declare function setConfig(newConfig: Configuration): void;
 declare function getConfig(): Configuration;
 declare function setSpecFileData(newSpecFileData: SpecFileData): void;
@@ -15,6 +15,7 @@ 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 function getAllOfTemplate(): HandlebarsTemplateDelegate<AllOfTemplateInput>;
 declare const _default: {
     getConfig: typeof getConfig;
     setConfig: typeof setConfig;
@@ -32,5 +33,6 @@ declare const _default: {
     getCachedReferenceType: typeof getCachedReferenceType;
     cacheReferenceType: typeof cacheReferenceType;
     getInputFilePath: typeof getInputFilePath;
+    getAllOfTemplate: typeof getAllOfTemplate;
 };
 export default _default;

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

@@ -0,0 +1,19 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  {{#if (eq this.source 'referenced')}}{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{this.templateInput.typeName}}
+    {{else if (eq this.dataType 'object')}}
+      {{this.templateInput.typeName}}
+    {{else}}
+      {{this.templateInput.type}}
+    {{/if}}
+  {{/if}} {{#unless @last}} & {{/unless}}
+{{/each}};
+
+{{#each compositions}}
+{{#if (eq this.dataType 'object')}}
+{{{this.content}}}
+{{/if}}
+{{/each}}

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

@@ -4,7 +4,7 @@ export type {{typeName}} =
   {{else if (eq this.source 'inline')}}
     {{#if this.templateInput.values}}
       {{#each this.templateInput.values}}
-        {{#unless @first}}|{{/unless}} {{#if (eq ../this.templateInput.enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../this.templateInput/enumType 'string')}}'{{/if}}
+        {{#unless @first}}|{{/unless}} {{#if (eq ../this.templateInput.type 'string') }}'{{/if}}{{{this}}}{{#if (eq ../this.templateInput/type 'string')}}'{{/if}}
       {{/each}}
     {{else if (eq this.dataType 'object')}}
       {

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

@@ -0,0 +1,42 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  {{#if (eq this.source 'referenced')}}{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{this.templateInput.typeName}}
+    {{else if (eq this.dataType 'object')}}
+      {{this.templateInput.typeName}}
+    {{else}}
+      {{this.templateInput.type}}
+    {{/if}}
+  {{/if}} {{#unless @last}} & {{/unless}}
+{{/each}};
+
+{{#each compositions}}
+{{#if (eq this.dataType 'object')}}
+{{{this.content}}}
+{{/if}}
+{{/each}}
+
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
+  {{#each compositions}}
+  {{#if (eq this.source 'referenced')}}
+  const decoded{{referencedType}} = decode{{referencedType}}(rawInput);
+  {{else if (eq this.source 'inline')}}
+  const decoded{{toPascalCase this.templateInput.typeName}} = decode{{this.templateInput.typeName}}(rawInput);
+  {{/if}}
+  {{/each}}
+
+  if (
+    {{#each compositions}}decoded{{#if (eq this.source 'referenced')}}{{referencedType}}{{else}}{{toPascalCase this.templateInput.typeName}}{{/if}} !== null {{#unless @last}} && {{/unless}} {{/each}}
+    ) {
+      return {
+        {{#each compositions}}
+        {{#if (eq this.source 'referenced')}}...decoded{{referencedType}},
+        {{else}}...decoded{{toPascalCase this.templateInput.typeName}},
+        {{/if}}
+        {{/each}}
+      };
+    }
+  return null;
+}

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

@@ -7,7 +7,7 @@
  * @example {{{example}}}
  {{/if}}
  */
-export type {{typeName}} = {
+export type {{typeName}} = {{#if (not (isEmptyObject properties))}}  {
   {{#each properties}}
   /**
   {{#if this.description}}
@@ -25,6 +25,9 @@ export type {{typeName}} = {
   [keys: {{jsonKey additionalProperties.keyType}}]: {{additionalProperties.valueType}};
   {{/if}}
 };
+{{else if (or (notEq length additionalProperties 0) (not (isEmptyObject additionalProperties)))}}
+Record<{{jsonKey additionalProperties.keyType}}, {{additionalProperties.valueType}}>;
+{{/if}}
 
 export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   if (isJSON(rawInput)) {

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

@@ -1,11 +1,11 @@
 export type {{typeName}} =
   {{#each compositions}}
-  | {{#if (eq this.source 'referenced')}}C{{referencedType}}
+  | {{#if (eq this.source 'referenced')}}C{{../typeName}}{{referencedType}}
   {{else if (eq this.source 'inline')}}
     {{#if this.templateInput.values}}
       {{this.templateInput.typeName}}
     {{else if (eq this.dataType 'object')}}
-      C{{this.templateInput.typeName}}
+      C{{typeName}}{{this.templateInput.typeName}}
     {{else}}
       {{this.templateInput.type}}
     {{/if}}
@@ -16,7 +16,7 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   const result: {{typeName}} | null =
   {{#each compositions}}
   {{#if (eq this.source 'referenced')}}
-    decodeC{{referencedType}}(rawInput)
+    decodeC{{../typeName}}{{referencedType}}(rawInput)
   {{else if (eq this.dataType 'object')}}
     decodeC{{this.templateInput.typeName}}(rawInput)
   {{else if (eq this.dataType 'array')}}
@@ -36,26 +36,26 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
 {{#if this.templateInput.values}}
 {{{this.content}}}
 {{else if (eq this.source 'referenced')}}
-export class C{{referencedType}} {
+export class C{{../typeName}}{{referencedType}} {
   data: {{referencedType}};
   constructor(data: {{referencedType}}) {
     this.data = data;
   }
 }
 
-export function decodeC{{referencedType}}(rawInput: unknown): C{{referencedType}} | null {
+export function decodeC{{../typeName}}{{referencedType}}(rawInput: unknown): C{{../typeName}}{{referencedType}} | null {
   const result = decode{{referencedType}}(rawInput);
   if (result === null) {
     return null;
   }
-  return new C{{referencedType}}(result);
+  return new C{{../typeName}}{{referencedType}}(result);
 }
 
 {{else if (eq this.dataType 'object')}}
 
 {{{this.content}}}
 
-export class C{{this.templateInput.typeName}} {
+export class C{{../typeName}}{{this.templateInput.typeName}} {
   data: {{this.templateInput.typeName}};
   constructor(data: {{this.templateInput.typeName}}) {
     this.data = data;
@@ -67,7 +67,7 @@ export function decodeC{{this.templateInput.typeName}}(rawInput: unknown) {
   if (result === null) {
     return null;
   }
-  return new C{{this.templateInput.typeName}}(result);
+  return new C{{../typeName}}{{this.templateInput.typeName}}(result);
 }
 
 {{/if}}

package/dist/types/index.d.ts

@@ -22,6 +22,7 @@ export type Template = {
     typesFileSyntax: string;
     enumSyntax: string;
     oneOfSyntax: string;
+    allOfSyntax: string;
 };
 export type LanguageConfig = {
     exporterModuleName: string;
@@ -78,6 +79,7 @@ export type TypeInfo = TypeDescriptors & {
     properties: TypeProperties | null;
     $ref: string | null;
     oneOf: TypeInfo[] | null;
+    allOf: TypeInfo[] | null;
     enum: string[] | number[] | null;
     additionalProperties: AdditionalProperties | null;
 };
@@ -144,12 +146,24 @@ export type OneOfTemplateInputComposition = {
     referencedType?: string;
     content?: string;
 };
+export type AllOfTemplateInput = TypeDescriptors & {
+    typeName: string;
+    type: string;
+    compositions: AllOfTemplateInputComposition[];
+};
+export type AllOfTemplateInputComposition = {
+    dataType?: TypeDataType | null;
+    templateInput?: TemplateInput;
+    source: 'inline' | 'referenced';
+    referencedType?: string;
+    content?: string;
+};
 export type VariableTemplateInput = TypeDescriptors & {
     typeName: string;
     type: string;
     composerType?: string;
 };
-export type TemplateInput = ObjectTemplateInput | EnumTemplateInput | OneOfTemplateInput | VariableTemplateInput;
+export type TemplateInput = ObjectTemplateInput | EnumTemplateInput | OneOfTemplateInput | AllOfTemplateInput | VariableTemplateInput;
 export type GenerationResult = {
     groupedTypes: GroupedTypesOutput;
     types: GeneratedTypes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-crafter",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "A tool to generate types from a yaml schema for any language",
   "main": "./dist/index.js",
   "type": "module",