type-crafter 0.2.1 → 0.4.0

package/dist/index.js

@@ -10665,6 +10665,17 @@ function __decodeString(value) {
     }
     return errorDelimiter;
 }
+/**
+ * @description A function which attempts to safely cast any value to a valid number
+ * @param value Value with unknown type
+ * @returns Attempts to convert the passed value to a valid number, returns null in case cast fails
+ */
+function decodeNumber(value) {
+    if (typeof value === 'number') {
+        return value;
+    }
+    return null;
+}
 /**
  * @description A function which attempts to safely cast any value to a valid boolean
  * @param value Value with unknown type
@@ -10809,13 +10820,22 @@ function decodeTypes(rawInput) {
 }
 function decodeTypeInfo(rawInput) {
     if (isJSON(rawInput)) {
+        const _type = decodeTypeDataType(rawInput.type);
         const result = {
-            type: decodeTypeDataType(rawInput.type),
+            type: _type,
             required: decodeArray(rawInput.required, decodeString),
             properties: decodeTypeProperties(rawInput.properties),
             items: decodeTypeInfo(rawInput.items),
             format: decodeString(rawInput.format),
-            $ref: decodeString(rawInput.$ref)
+            $ref: decodeString(rawInput.$ref),
+            description: decodeString(rawInput.description),
+            example: decodeString(rawInput.example) ?? decodeNumber(rawInput.example),
+            oneOf: decodeArray(rawInput.oneOf, decodeTypeInfo),
+            enum: _type === 'string'
+                ? decodeArray(rawInput.enum, decodeString)
+                : _type === 'number'
+                    ? decodeArray(rawInput.enum, decodeNumber)
+                    : null
         };
         return result;
     }
@@ -10860,13 +10880,17 @@ function decodeObjectTemplateInputProperty(rawInput) {
         const referenced = decodeBoolean(rawInput.referenced);
         const primitiveType = decodeString(rawInput.primitiveType);
         const composerType = decodeString(rawInput.composerType);
+        const example = decodeString(rawInput.example) ?? decodeNumber(rawInput.example);
+        const description = decodeString(rawInput.description);
         if (required !== null && _type !== null && referenced !== null && primitiveType !== null) {
             return {
                 type: _type,
                 required,
                 referenced,
                 primitiveType,
-                composerType
+                composerType,
+                example,
+                description
             };
         }
     }
@@ -19204,6 +19228,8 @@ let specFileData = null;
 let objectSyntaxTemplate = null;
 let exporterModuleSyntaxTemplate = null;
 let typesFileSyntaxTemplate = null;
+let oneOfSyntaxTemplate = null;
+let enumSyntaxTemplate = null;
 let expectedOutputFiles = null;
 function setConfig(newConfig) {
     config$2 = newConfig;
@@ -19228,6 +19254,8 @@ function compileTemplates() {
     objectSyntaxTemplate = Handlebars.compile(config.template.objectSyntax);
     exporterModuleSyntaxTemplate = Handlebars.compile(config.template.exporterModuleSyntax);
     typesFileSyntaxTemplate = Handlebars.compile(config.template.typesFileSyntax);
+    enumSyntaxTemplate = Handlebars.compile(config.template.enumSyntax);
+    oneOfSyntaxTemplate = Handlebars.compile(config.template.oneOfSyntax);
 }
 function getObjectTemplate() {
     if (objectSyntaxTemplate === null) {
@@ -19247,6 +19275,18 @@ function getTypesFileTemplate() {
     }
     return typesFileSyntaxTemplate;
 }
+function getEnumTemplate() {
+    if (enumSyntaxTemplate === null) {
+        throw new RuntimeError('Enum template not compiled!');
+    }
+    return enumSyntaxTemplate;
+}
+function getOneOfTemplate() {
+    if (oneOfSyntaxTemplate === null) {
+        throw new RuntimeError('OneOf template not compiled!');
+    }
+    return oneOfSyntaxTemplate;
+}
 function setExpectedOutputFiles(newExpectedOutputFiles) {
     expectedOutputFiles = newExpectedOutputFiles;
 }
@@ -19265,8 +19305,10 @@ var Runtime = {
     getObjectTemplate,
     getExporterModuleTemplate,
     getTypesFileTemplate,
+    getEnumTemplate,
     getExpectedOutputFiles,
-    compileTemplates
+    compileTemplates,
+    getOneOfTemplate
 };
 
 function getSourceFileDirectory() {
@@ -19406,13 +19448,20 @@ function toPascalCase(input) {
         .map((word) => word.charAt(0).toUpperCase() + word.slice(1))
         .join('');
 }
+function toPascalCaseHelper(input) {
+    const inputString = decodeString(input);
+    if (inputString === null) {
+        return input;
+    }
+    return toPascalCase(inputString);
+}
 function registerTemplateHelpers() {
     Handlebars.registerHelper('getOptionalKeys', getOptionalKeys);
     Handlebars.registerHelper('getRequiredKeys', getRequiredKeys);
     Handlebars.registerHelper('areRequiredKeysPresent', (object) => getRequiredKeys(object).length > 0);
     Handlebars.registerHelper('getReferencedTypes', getReferencedTypes);
     Handlebars.registerHelper('getReferencedTypeModules', getReferencedTypeModules);
-    Handlebars.registerHelper('toPascalCase', toPascalCase);
+    Handlebars.registerHelper('toPascalCase', toPascalCaseHelper);
     Handlebars.registerHelper('isNonEmptyArray', (value) => Array.isArray(value) && value.length === 0);
     Handlebars.registerHelper('eq', (value1, value2) => value1 === value2);
 }
@@ -19494,49 +19543,94 @@ function resolveAndGetReferenceName(reference) {
     return getReferenceName(reference);
 }
 function getLanguageDataType(dataType, format, items) {
+    const result = {
+        dataType,
+        references: new Set(),
+        primitives: new Set()
+    };
     const typeMapper = Runtime.getConfig().language.typeMapper ?? null;
     const mappedType = typeMapper !== null ? typeMapper[dataType] : null;
+    const itemReference = 
+    // eslint-disable-next-line @typescript-eslint/prefer-optional-chain
+    items !== null && items.$ref !== null ? resolveAndGetReferenceName(items.$ref) : null;
     const itemsType = 
     // eslint-disable-next-line
     items !== null
         ? items.type !== null
             ? getLanguageDataType(items.type, items.format, items.items)
-            : items.$ref !== null
-                ? resolveAndGetReferenceName(items.$ref)
+            : itemReference !== null
+                ? {
+                    dataType: itemReference,
+                    references: new Set([itemReference]),
+                    primitives: new Set()
+                }
                 : null
         : null;
     const fillerPatterns = [];
     if (itemsType !== null) {
-        fillerPatterns.push({ regex: /~ItemType~/g, value: itemsType });
+        fillerPatterns.push({ regex: /~ItemType~/g, value: itemsType.dataType });
     }
+    let mappedTypeWithFormat = null;
+    let defaultType = null;
     if (typeof mappedType === 'string') {
-        return fillPatterns(mappedType, fillerPatterns);
+        result.dataType = fillPatterns(mappedType, fillerPatterns);
     }
     else if (isJSON(mappedType)) {
-        const defaultType = mappedType.default;
-        const mappedTypeWithFormat = mappedType[format ?? ''] ?? defaultType;
+        defaultType = mappedType.default;
+        mappedTypeWithFormat = mappedType[format ?? ''] ?? defaultType;
         if (typeof mappedTypeWithFormat === 'string') {
-            return fillPatterns(mappedTypeWithFormat, fillerPatterns);
+            result.dataType = fillPatterns(mappedTypeWithFormat, fillerPatterns);
         }
     }
-    return dataType;
+    /**
+     * @todo: Segregate array & variable type generation
+     */
+    const primitiveElementType = items?.$ref !== null
+        ? null
+        : mappedTypeWithFormat === null
+            ? itemsType !== null
+                ? itemsType.dataType
+                : result.dataType
+            : typeof mappedType === 'string' && items?.$ref !== null
+                ? mappedType
+                : null;
+    if (itemsType !== null && primitiveElementType !== null) {
+        result.itemType = primitiveElementType;
+    }
+    else if (itemsType !== null && itemReference !== null) {
+        result.itemType = itemReference;
+    }
+    if (itemsType !== null) {
+        result.references = new Set([...result.references, ...itemsType.references]);
+        result.primitives =
+            primitiveElementType !== null
+                ? new Set([...result.primitives, primitiveElementType])
+                : result.primitives;
+    }
+    return result;
 }
-function generateType(typeName, typeInfo, groupedTypes = false) {
-    const result = {
-        content: '',
-        references: new Set(),
-        primitives: new Set()
-    };
+function generateObjectType(typeName, typeInfo) {
     const templateInput = {
         typeName,
+        description: typeInfo.description,
+        example: typeInfo.example,
         properties: {}
     };
+    const result = {
+        content: '',
+        references: new Set(),
+        primitives: new Set(),
+        templateInput
+    };
     let recursiveTypeGenOutput = null;
+    let dynamicGeneratedType = '';
     for (const propertyName in typeInfo.properties) {
-        const propertyType = typeInfo.properties[propertyName].type;
-        const propertyFormat = typeInfo.properties[propertyName].format;
-        const propertyItems = typeInfo.properties[propertyName].items ?? null;
-        const reference = typeInfo.properties[propertyName].$ref ?? null;
+        const propertyDetails = typeInfo.properties[propertyName];
+        const propertyType = propertyDetails.type;
+        const propertyFormat = propertyDetails.format;
+        const propertyItems = propertyDetails.items ?? null;
+        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) {
             throw new InvalidSpecFileError('Invalid property type for: ' + typeName + '.' + propertyName);
@@ -19553,9 +19647,14 @@ function generateType(typeName, typeInfo, groupedTypes = false) {
             isReferenced = true;
             result.references.add(recursivePropertyName);
         }
+        else if (enumValues !== null) {
+            const enumName = toPascalCase(propertyName) + 'Enum';
+            dynamicGeneratedType = generateEnumType(enumName, propertyDetails).content;
+            languageDataType = enumName;
+        }
         else if (propertyType === 'object') {
             recursivePropertyName = toPascalCase(propertyName);
-            recursiveTypeGenOutput = generateType(recursivePropertyName, typeInfo.properties[propertyName], groupedTypes);
+            recursiveTypeGenOutput = generateObjectType(recursivePropertyName, typeInfo.properties[propertyName]);
             languageDataType = recursivePropertyName;
             for (const reference of recursiveTypeGenOutput.references.values()) {
                 result.references.add(reference);
@@ -19565,7 +19664,7 @@ function generateType(typeName, typeInfo, groupedTypes = false) {
             }
         }
         else if (propertyType !== null) {
-            languageDataType = getLanguageDataType(propertyType, propertyFormat, propertyItems);
+            languageDataType = getLanguageDataType(propertyType, propertyFormat, propertyItems).dataType;
             result.primitives.add(propertyItems !== null ? 'Array' : languageDataType);
             if (propertyItems !== null) {
                 const itemsType = propertyItems.type ?? getReferenceName(propertyItems.$ref ?? '');
@@ -19583,20 +19682,129 @@ function generateType(typeName, typeInfo, groupedTypes = false) {
                 required: typeInfo.required?.includes(propertyName) ?? false,
                 referenced: isReferenced,
                 primitiveType,
-                composerType
+                composerType,
+                example: propertyDetails.example,
+                description: propertyDetails.description
             }
         };
     }
     result.content =
-        Runtime.getObjectTemplate()(templateInput) + (recursiveTypeGenOutput?.content ?? '');
+        Runtime.getObjectTemplate()(templateInput) +
+            (recursiveTypeGenOutput?.content ?? '') +
+            dynamicGeneratedType;
     return result;
 }
-function generateTypes(types, groupedTypes = false) {
+function generateEnumType(typeName, typeInfo) {
+    if (typeInfo.enum === null || typeInfo.enum.length === 0 || typeInfo.type === null) {
+        throw new InvalidSpecFileError('Invalid enum type for: ' + typeName);
+    }
+    const templateInput = {
+        typeName,
+        enumType: typeInfo.type,
+        values: typeInfo.enum,
+        example: typeInfo.example,
+        description: typeInfo.description
+    };
+    const result = {
+        content: '',
+        references: new Set(),
+        primitives: new Set(),
+        templateInput
+    };
+    result.content = Runtime.getEnumTemplate()(templateInput);
+    return result;
+}
+function generateOneOfTypes(typeName, typeInfo) {
+    const result = {
+        content: '',
+        references: new Set(),
+        primitives: new Set()
+    };
+    if (typeInfo.oneOf === null || typeInfo.oneOf.length === 0) {
+        throw new InvalidSpecFileError('Invalid oneOf type for: ' + typeName);
+    }
+    const templateInput = {
+        typeName,
+        compositions: []
+    };
+    for (let index = 0; index < typeInfo.oneOf.length; index++) {
+        const oneOfItem = typeInfo.oneOf[index];
+        if (oneOfItem.$ref !== null) {
+            const referenceName = resolveAndGetReferenceName(oneOfItem.$ref);
+            const composition = {
+                source: 'referenced',
+                referencedType: referenceName
+            };
+            templateInput.compositions.push(composition);
+            result.references.add(referenceName);
+        }
+        else {
+            const generatedType = generateType(typeName + (index + 1), oneOfItem);
+            if (generatedType === null) {
+                throw new InvalidSpecFileError('Invalid oneOf type for: ' + typeName);
+            }
+            const composition = {
+                dataType: oneOfItem.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.getOneOfTemplate()(templateInput);
+    return result;
+}
+function generateVariableType(typeName, typeInfo) {
+    if (typeInfo.type === null) {
+        return null;
+    }
+    const dataType = getLanguageDataType(typeInfo.type, typeInfo.format, typeInfo.items);
+    const _primitives = [...dataType.primitives];
+    if (typeInfo.type === 'array' && dataType.references.size !== 0) {
+        _primitives.push('Array');
+    }
+    else if (typeInfo.type !== 'array' && typeInfo.$ref === null) {
+        _primitives.push(dataType.dataType);
+    }
+    return {
+        content: '',
+        references: dataType.references,
+        primitives: new Set(_primitives),
+        templateInput: {
+            typeName,
+            dataType: dataType.dataType,
+            itemType: dataType.itemType,
+            primitiveType: typeInfo.type
+        }
+    };
+}
+function generateType(typeName, typeInfo) {
+    if (typeInfo.type === 'object') {
+        return generateObjectType(typeName, typeInfo);
+    }
+    if (typeInfo.enum !== null) {
+        return generateEnumType(typeName, typeInfo);
+    }
+    if (typeInfo.oneOf !== null) {
+        return generateOneOfTypes(typeName, typeInfo);
+    }
+    return generateVariableType(typeName, typeInfo);
+}
+function generateTypes(types) {
     const result = {};
     for (const type in types) {
         const typeInfo = types[type];
         const genType = generateType(type, typeInfo);
-        result[type] = genType;
+        if (genType !== null) {
+            result[type] = genType;
+        }
     }
     return result;
 }
@@ -19612,7 +19820,7 @@ function generator(specFileData) {
     // generating grouped types
     const groupedTypes = {};
     for (const groupName in specFileData.groupedTypes) {
-        groupedTypes[groupName] = generateTypes(specFileData.groupedTypes[groupName], true);
+        groupedTypes[groupName] = generateTypes(specFileData.groupedTypes[groupName]);
     }
     result.groupedTypes = groupedTypes;
     return result;
@@ -19762,6 +19970,8 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
     const objectSyntax = await readFile(directoryPrefix + 'templates/typescript/object-syntax.hbs', devMode);
     const exporterModuleSyntax = await readFile(directoryPrefix + 'templates/typescript/exporter-module-syntax.hbs', devMode);
     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 config = {
         input: inputFilePath,
         output: {
@@ -19776,7 +19986,9 @@ async function config$1(inputFilePath, outputDirectory, typesWriterMode, grouped
         template: {
             objectSyntax,
             exporterModuleSyntax,
-            typesFileSyntax
+            typesFileSyntax,
+            enumSyntax,
+            oneOfSyntax
         },
         language: {
             exporterModuleName: 'index',
@@ -19800,6 +20012,8 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
     const objectSyntax = await readFile(directoryPrefix + 'templates/typescript-with-decoders/object-syntax.hbs', devMode);
     const exporterModuleSyntax = await readFile(directoryPrefix + 'templates/typescript/exporter-module-syntax.hbs', devMode);
     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 config = {
         input: inputFilePath,
         output: {
@@ -19814,7 +20028,9 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
         template: {
             objectSyntax,
             exporterModuleSyntax,
-            typesFileSyntax
+            typesFileSyntax,
+            enumSyntax,
+            oneOfSyntax
         },
         language: {
             exporterModuleName: 'index',
@@ -19879,7 +20095,7 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.2.1');
+const program = new Command().version('0.4.0');
 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, ExporterModuleTemplateInput, ObjectTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
+import type { Configuration, EnumTemplateInput, ExporterModuleTemplateInput, ObjectTemplateInput, OneOfTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
 declare function setConfig(newConfig: Configuration): void;
 declare function getConfig(): Configuration;
 declare function setSpecFileData(newSpecFileData: SpecFileData): void;
@@ -7,6 +7,8 @@ declare function compileTemplates(): void;
 declare function getObjectTemplate(): HandlebarsTemplateDelegate<ObjectTemplateInput>;
 declare function getExporterModuleTemplate(): HandlebarsTemplateDelegate<ExporterModuleTemplateInput>;
 declare function getTypesFileTemplate(): HandlebarsTemplateDelegate<TypesFileTemplateInput>;
+declare function getEnumTemplate(): HandlebarsTemplateDelegate<EnumTemplateInput>;
+declare function getOneOfTemplate(): HandlebarsTemplateDelegate<OneOfTemplateInput>;
 declare function setExpectedOutputFiles(newExpectedOutputFiles: Map<string, TypeFilePath>): void;
 declare function getExpectedOutputFiles(): Map<string, TypeFilePath>;
 declare const _default: {
@@ -18,7 +20,9 @@ declare const _default: {
     getObjectTemplate: typeof getObjectTemplate;
     getExporterModuleTemplate: typeof getExporterModuleTemplate;
     getTypesFileTemplate: typeof getTypesFileTemplate;
+    getEnumTemplate: typeof getEnumTemplate;
     getExpectedOutputFiles: typeof getExpectedOutputFiles;
     compileTemplates: typeof compileTemplates;
+    getOneOfTemplate: typeof getOneOfTemplate;
 };
 export default _default;

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

@@ -0,0 +1,13 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
+export type {{typeName}} =
+{{#each values}}
+  | {{#if (eq ../enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../enumType 'string')}}'{{/if}}
+{{/each}};

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

@@ -1,5 +1,24 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
 export type {{typeName}} = {
   {{#each properties}}
+  /**
+  {{#if this.description}}
+   * @description {{{this.description}}}
+  {{/if}}
+   * @type { {{this.type}} }
+   * @memberof {{../typeName}}
+  {{#if this.example}}
+   * @example {{{this.example}}}
+  {{/if}}
+   */
   {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
   {{/each}}
 };

package/dist/templates/typescript/oneOf-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}}
+      {{#each this.templateInput.values}}
+        {{#unless @first}}|{{/unless}} {{#if (eq ../this.templateInput.enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../this.templateInput/enumType 'string')}}'{{/if}}
+      {{/each}}
+    {{else if (eq this.dataType 'object')}}
+      {
+        {{#each this.templateInput.properties}}
+        {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
+        {{/each}}
+      }
+    {{else}}
+      {{this.templateInput.dataType}}
+    {{/if}}
+  {{/if}}
+{{/each}};

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

@@ -0,0 +1,23 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
+export type {{typeName}} =
+{{#each values}}
+  | {{#if (eq ../enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../enumType 'string')}}'{{/if}}
+{{/each}};
+
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
+  switch (rawInput) {
+    {{#each values}}
+    case {{#if (eq ../enumType 'string') }}'{{/if}}{{this}}{{#if (eq ../enumType 'string')}}'{{/if}}:
+    {{/each}}
+     return rawInput;
+  }
+  return null;
+}

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

@@ -1,5 +1,24 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
 export type {{typeName}} = {
   {{#each properties}}
+  /**
+  {{#if this.description}}
+   * @description {{{this.description}}}
+  {{/if}}
+   * @type { {{this.type}} }
+   * @memberof {{../typeName}}
+  {{#if this.example}}
+   * @example {{{this.example}}}
+  {{/if}}
+   */
   {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
   {{/each}}
 };

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

@@ -0,0 +1,74 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  | {{#if (eq this.source 'referenced')}}C{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{this.templateInput.typeName}}
+    {{else if (eq this.dataType 'object')}}
+      C{{this.templateInput.typeName}}
+    {{else}}
+      {{this.templateInput.dataType}}
+    {{/if}}
+  {{/if}}
+{{/each}};
+
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
+  const result: {{typeName}} | null =
+  {{#each compositions}}
+  {{#if (eq this.source 'referenced')}}
+    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 this.templateInput.values}}
+    decode{{this.templateInput.typeName}}(rawInput)
+  {{else}}
+    decode{{{toPascalCase this.templateInput.dataType}}}(rawInput)
+  {{/if}}{{#unless @last}}??{{/unless}}
+  {{/each}};
+  return result;
+}
+
+
+{{#each compositions}}
+
+{{#if this.templateInput.values}}
+{{{this.content}}}
+{{else if (eq this.source 'referenced')}}
+export class C{{referencedType}} {
+  data: {{referencedType}};
+  constructor(data: {{referencedType}}) {
+    this.data = data;
+  }
+}
+
+export function decodeC{{referencedType}}(rawInput: unknown): C{{referencedType}} | null {
+  const result = decode{{referencedType}}(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new C{{referencedType}}(result);
+}
+
+{{else if (eq this.dataType 'object')}}
+
+{{{this.content}}}
+
+export class C{{this.templateInput.typeName}} {
+  data: {{this.templateInput.typeName}};
+  constructor(data: {{this.templateInput.typeName}}) {
+    this.data = data;
+  }
+}
+
+export function decodeC{{this.templateInput.typeName}}(rawInput: unknown) {
+  const result = decode{{this.templateInput.typeName}}(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new C{{this.templateInput.typeName}}(result);
+}
+
+{{/if}}
+{{/each}}

package/dist/types/decoders.d.ts

@@ -1,5 +1,6 @@
-import type { GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypesWriterMode } from '.';
+import type { EnumTemplateInput, GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypesWriterMode } 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 decodeObjectTemplateInputProperties(rawInput: unknown): ObjectTemplateInputProperties | null;
+export declare function decodeEnumTemplateInput(rawInput: unknown): EnumTemplateInput | null;

package/dist/types/index.d.ts

@@ -20,6 +20,8 @@ export type Template = {
     objectSyntax: string;
     exporterModuleSyntax: string;
     typesFileSyntax: string;
+    enumSyntax: string;
+    oneOfSyntax: string;
 };
 export type LanguageConfig = {
     exporterModuleName: string;
@@ -54,12 +56,18 @@ export type TypeInfo = {
     items: TypeInfo | null;
     properties: TypeProperties | null;
     $ref: string | null;
+    oneOf: TypeInfo[] | null;
+    enum: string[] | number[] | null;
+    description: string | null;
+    example: string | number | null;
 };
 type PropertyName = string;
 export type TypeProperties = Record<PropertyName, TypeInfo>;
 export type TypeDataType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'unknown';
 export type ObjectTemplateInput = {
     typeName: string;
+    example: string | number | null;
+    description: string | null;
     properties: ObjectTemplateInputProperties;
 };
 export type ObjectTemplateInputProperties = Record<PropertyName, ObjectTemplateInputProperty>;
@@ -69,6 +77,8 @@ export type ObjectTemplateInputProperty = {
     referenced: boolean;
     primitiveType: string;
     composerType: string | null;
+    example: string | number | null;
+    description: string | null;
 };
 export type ExporterModuleTemplateInput = {
     modules: string[];
@@ -84,6 +94,31 @@ export type ReferencedModule = {
     moduleRelativePath: string;
     referencedTypes: string[];
 };
+export type EnumTemplateInput = {
+    typeName: string;
+    enumType: string;
+    values: string[] | number[];
+    example: string | number | null;
+    description: string | null;
+};
+export type OneOfTemplateInput = {
+    typeName: string;
+    compositions: OneOfTemplateInputComposition[];
+};
+export type OneOfTemplateInputComposition = {
+    dataType?: TypeDataType | null;
+    templateInput?: TemplateInput;
+    source: 'inline' | 'referenced';
+    referencedType?: string;
+    content?: string;
+};
+export type VariableTemplateInput = {
+    typeName: string;
+    dataType: string;
+    primitiveType: string;
+    itemType?: string;
+};
+export type TemplateInput = ObjectTemplateInput | EnumTemplateInput | VariableTemplateInput;
 export type GenerationResult = {
     groupedTypes: GroupedTypesOutput;
     types: GeneratedTypes;
@@ -92,6 +127,7 @@ export type GeneratedType = {
     content: string;
     references: Set<string>;
     primitives: Set<string>;
+    templateInput?: TemplateInput;
 };
 export type GroupedTypesOutput = Record<GroupName, GeneratedTypes>;
 export type GeneratedTypes = Record<TypeName, GeneratedType>;

package/dist/utils/index.d.ts

@@ -7,6 +7,7 @@ export declare function getRequiredKeys(object: unknown): string[];
 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 registerTemplateHelpers(): void;
 export declare function readNestedValue(json: JSONObject, keyPath: string[]): JSONObject;
 export declare function generateRelativePath(fromPath: string, toPath: string): string;

package/package.json

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