type-crafter 0.14.0 → 0.16.0

package/dist/index.js

@@ -21308,6 +21308,7 @@ function registerTemplateHelpers() {
             return value1 || value2;
         }
     });
+    Handlebars.registerHelper('subtract', (a, b) => typeof a === 'number' && typeof b === 'number' ? a - b : 0);
 }
 function readNestedValue(json, keyPath) {
     if (!isJSON(json)) {
@@ -21552,7 +21553,10 @@ async function generateAdditionalPropertiesType(typeName, typeInfo, parentTypes)
                 valuePrimitiveType: isArray ? 'array' : (valueTypeInfo.type ?? 'object'),
                 valueComposerType: 'composerType' in generatedValueType.templateInput
                     ? (generatedValueType.templateInput.composerType ?? null)
-                    : null
+                    : null,
+                valueArrayNestingDepth: 'arrayNestingDepth' in generatedValueType.templateInput
+                    ? (generatedValueType.templateInput.arrayNestingDepth ?? 0)
+                    : 0
             },
             primitives: generatedValueType.primitives
         };
@@ -21570,7 +21574,10 @@ async function generateAdditionalPropertiesType(typeName, typeInfo, parentTypes)
                 valuePrimitiveType: isArray ? 'array' : (valueTypeInfo.type ?? 'object'),
                 valueComposerType: 'composerType' in generatedValueType.templateInput
                     ? (generatedValueType.templateInput.composerType ?? null)
-                    : null
+                    : null,
+                valueArrayNestingDepth: 'arrayNestingDepth' in generatedValueType.templateInput
+                    ? (generatedValueType.templateInput.arrayNestingDepth ?? 0)
+                    : 0
             },
             primitives: generatedValueType.primitives
         };
@@ -21606,6 +21613,7 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
         }
         const primitiveType = propertyType ?? 'object';
         let composerType = null;
+        let arrayNestingDepth = 0;
         let recursivePropertyName;
         let languageDataType = null;
         let isReferenced = false;
@@ -21627,6 +21635,7 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
             references.push(...arrayDataGenOutput.references);
             languageDataType = arrayDataGenOutput.templateInput.type;
             composerType = arrayDataGenOutput.templateInput.composerType ?? null;
+            arrayNestingDepth = arrayDataGenOutput.templateInput.arrayNestingDepth ?? 0;
             dynamicGeneratedType += arrayDataGenOutput.content;
         }
         else if (propertyType === 'object') {
@@ -21655,6 +21664,7 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
                 referenced: isReferenced,
                 primitiveType,
                 composerType,
+                arrayNestingDepth,
                 example: propertyDetails.example,
                 description: propertyDetails.description,
                 summary: propertyDetails.summary,
@@ -21697,7 +21707,8 @@ function generateEnumType(typeName, typeInfo) {
         values: typeInfo.enum,
         example: typeInfo.example,
         description: typeInfo.description,
-        summary: typeInfo.summary
+        summary: typeInfo.summary,
+        customAttributes: typeInfo.customAttributes ?? null
     };
     const result = {
         content: '',
@@ -21756,6 +21767,13 @@ async function generateArrayType(typeName, typeInfo, parentTypes) {
         throw new InvalidSpecFileError('Invalid array type for: ' + typeName);
     }
     const dataType = fillPatterns(arrayTypeMap, fillerPatterns);
+    const innerComposerType = 'composerType' in arrayItemsType.templateInput
+        ? (arrayItemsType.templateInput.composerType ?? arrayItemsType.templateInput.type)
+        : arrayItemsType.templateInput.type;
+    const innerNestingDepth = 'arrayNestingDepth' in arrayItemsType.templateInput
+        ? (arrayItemsType.templateInput.arrayNestingDepth ?? 0)
+        : 0;
+    const arrayNestingDepth = typeInfo.items?.type === 'array' ? innerNestingDepth + 1 : 0;
     const result = {
         content: dynamicGeneratedType,
         references: arrayItemsType.references,
@@ -21763,7 +21781,8 @@ async function generateArrayType(typeName, typeInfo, parentTypes) {
         templateInput: {
             typeName,
             type: dataType,
-            composerType: arrayItemsType.templateInput.type,
+            composerType: innerComposerType,
+            arrayNestingDepth,
             description: typeInfo.description,
             example: typeInfo.example,
             summary: typeInfo.summary
@@ -21823,7 +21842,8 @@ async function generateOneOfTypes(typeName, typeInfo, parentTypes) {
         compositions: [],
         description: typeInfo.description,
         example: typeInfo.example,
-        summary: typeInfo.summary
+        summary: typeInfo.summary,
+        customAttributes: typeInfo.customAttributes ?? null
     };
     const result = {
         content: '',
@@ -21875,7 +21895,8 @@ async function generateAllOfTypes(typeName, typeInfo, parentTypes) {
         compositions: [],
         description: typeInfo.description,
         example: typeInfo.example,
-        summary: typeInfo.summary
+        summary: typeInfo.summary,
+        customAttributes: typeInfo.customAttributes ?? null
     };
     const result = {
         content: '',
@@ -22526,7 +22547,7 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.14.0');
+const program = new Command().version('0.16.0');
 program
     .command('generate')
     .description('Generate types for your language from a type spec file')

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

@@ -18,6 +18,7 @@ export type {{typeName}} =
 {{/if}}
 {{/each}}
 
+{{#unless customAttributes.skipDecoderGeneration}}
 export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   {{#each compositions}}
   {{#if (eq this.source 'referenced')}}
@@ -40,3 +41,4 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
     }
   return null;
 }
+{{/unless}}

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

@@ -12,6 +12,7 @@ export type {{typeName}} =
   | {{#if (eq ../type 'string') }}'{{/if}}{{{this}}}{{#if (eq ../type 'string')}}'{{/if}}
 {{/each}};
 
+{{#unless customAttributes.skipDecoderGeneration}}
 export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   switch (rawInput) {
     {{#each values}}
@@ -21,7 +22,9 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   }
   return null;
 }
+{{/unless}}
 
+{{#if customAttributes.generateOptionalDecoder}}
 export function _decode{{typeName}}(rawInput: unknown): {{typeName}} | undefined {
   switch (rawInput) {
     {{#each values}}
@@ -31,3 +34,4 @@ export function _decode{{typeName}}(rawInput: unknown): {{typeName}} | undefined
   }
   return;
 }
+{{/if}}

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

@@ -1,3 +1,10 @@
+{{#*inline "nestedArrayDecoder"}}
+{{~#if depth~}}
+(item: unknown) => decodeArray(item, {{~> nestedArrayDecoder depth=(subtract depth 1) composerType=composerType~}})
+{{~else~}}
+decode{{{toPascalCase composerType}}}
+{{~/if~}}
+{{/inline}}
 /**
  * @type { {{typeName}} }
  {{#if description}}
@@ -42,8 +49,8 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
     const decoded{{variableName @key}} = {{#if this.referenced ~}}
       {{#if this.optional}}_{{/if}}decode{{{toPascalCase this.type}}}(rawInput[{{{indexKey @key}}}]);
     {{~else~}}
-      {{~#if (eq this.primitiveType 'array')~}} 
-      decodeArray(rawInput[{{{indexKey @key}}}], decode{{{toPascalCase this.composerType}}})
+      {{~#if (eq this.primitiveType 'array')~}}
+      decodeArray(rawInput[{{{indexKey @key}}}], {{~> nestedArrayDecoder depth=this.arrayNestingDepth composerType=this.composerType~}})
       {{~else~}}
        {{#if this.optional}}_{{/if}}decode{{{toPascalCase this.type}}}(rawInput[{{{indexKey @key}}}])
       {{~/if~}};
@@ -67,13 +74,13 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
     for (const key in rawInput) {
       {{#if additionalProperties.valueTypeReferenced}}
       const decodedValue = {{#if (eq additionalProperties.valuePrimitiveType 'array')~}}
-        decodeArray(rawInput[key], decode{{{toPascalCase additionalProperties.valueComposerType}}});
+        decodeArray(rawInput[key], {{~> nestedArrayDecoder depth=additionalProperties.valueArrayNestingDepth composerType=additionalProperties.valueComposerType~}});
       {{~else~}}
         decode{{{toPascalCase additionalProperties.valueType}}}(rawInput[key]);
       {{~/if}}
       {{else}}
       {{#if (eq additionalProperties.valuePrimitiveType 'array')}}
-      const decodedValue = decodeArray(rawInput[key], decode{{{toPascalCase additionalProperties.valueComposerType}}});
+      const decodedValue = decodeArray(rawInput[key], {{~> nestedArrayDecoder depth=additionalProperties.valueArrayNestingDepth composerType=additionalProperties.valueComposerType~}});
       {{else}}
       const decodedValue = decode{{{toPascalCase additionalProperties.valueType}}}(rawInput[key]);
       {{/if}}
@@ -91,13 +98,13 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
       if (!knownKeys.has(key)) {
         {{#if additionalProperties.valueTypeReferenced}}
         const decodedValue = {{#if (eq additionalProperties.valuePrimitiveType 'array')~}}
-          decodeArray(rawInput[key], decode{{{toPascalCase additionalProperties.valueComposerType}}});
+          decodeArray(rawInput[key], {{~> nestedArrayDecoder depth=additionalProperties.valueArrayNestingDepth composerType=additionalProperties.valueComposerType~}});
         {{~else~}}
           decode{{{toPascalCase additionalProperties.valueType}}}(rawInput[key]);
         {{~/if}}
         {{else}}
         {{#if (eq additionalProperties.valuePrimitiveType 'array')}}
-        const decodedValue = decodeArray(rawInput[key], decode{{{toPascalCase additionalProperties.valueComposerType}}});
+        const decodedValue = decodeArray(rawInput[key], {{~> nestedArrayDecoder depth=additionalProperties.valueArrayNestingDepth composerType=additionalProperties.valueComposerType~}});
         {{else}}
         const decodedValue = decode{{{toPascalCase additionalProperties.valueType}}}(rawInput[key]);
         {{/if}}
@@ -135,7 +142,7 @@ export function _decode{{typeName}}(rawInput: unknown): {{typeName}} | undefined
       {{#if this.optional}}_{{/if}}decode{{{toPascalCase this.type}}}(rawInput[{{{indexKey @key}}}]);
     {{~else~}}
       {{~#if (eq this.primitiveType 'array')~}}
-      decodeArray(rawInput[{{{indexKey @key}}}], decode{{{toPascalCase this.composerType}}})
+      decodeArray(rawInput[{{{indexKey @key}}}], {{~> nestedArrayDecoder depth=this.arrayNestingDepth composerType=this.composerType~}})
       {{~else~}}
         {{#if this.optional}}_{{/if}}decode{{{toPascalCase this.type}}}(rawInput[{{{indexKey @key}}}])
       {{~/if~}};
@@ -159,13 +166,13 @@ export function _decode{{typeName}}(rawInput: unknown): {{typeName}} | undefined
     for (const key in rawInput) {
       {{#if additionalProperties.valueTypeReferenced}}
       const decodedValue = {{#if (eq additionalProperties.valuePrimitiveType 'array')~}}
-        decodeArray(rawInput[key], decode{{{toPascalCase additionalProperties.valueComposerType}}});
+        decodeArray(rawInput[key], {{~> nestedArrayDecoder depth=additionalProperties.valueArrayNestingDepth composerType=additionalProperties.valueComposerType~}});
       {{~else~}}
         decode{{{toPascalCase additionalProperties.valueType}}}(rawInput[key]);
       {{~/if}}
       {{else}}
       {{#if (eq additionalProperties.valuePrimitiveType 'array')}}
-      const decodedValue = decodeArray(rawInput[key], decode{{{toPascalCase additionalProperties.valueComposerType}}});
+      const decodedValue = decodeArray(rawInput[key], {{~> nestedArrayDecoder depth=additionalProperties.valueArrayNestingDepth composerType=additionalProperties.valueComposerType~}});
       {{else}}
       const decodedValue = decode{{{toPascalCase additionalProperties.valueType}}}(rawInput[key]);
       {{/if}}
@@ -183,13 +190,13 @@ export function _decode{{typeName}}(rawInput: unknown): {{typeName}} | undefined
       if (!knownKeys.has(key)) {
         {{#if additionalProperties.valueTypeReferenced}}
         const decodedValue = {{#if (eq additionalProperties.valuePrimitiveType 'array')~}}
-          decodeArray(rawInput[key], decode{{{toPascalCase additionalProperties.valueComposerType}}});
+          decodeArray(rawInput[key], {{~> nestedArrayDecoder depth=additionalProperties.valueArrayNestingDepth composerType=additionalProperties.valueComposerType~}});
         {{~else~}}
           decode{{{toPascalCase additionalProperties.valueType}}}(rawInput[key]);
         {{~/if}}
         {{else}}
         {{#if (eq additionalProperties.valuePrimitiveType 'array')}}
-        const decodedValue = decodeArray(rawInput[key], decode{{{toPascalCase additionalProperties.valueComposerType}}});
+        const decodedValue = decodeArray(rawInput[key], {{~> nestedArrayDecoder depth=additionalProperties.valueArrayNestingDepth composerType=additionalProperties.valueComposerType~}});
         {{else}}
         const decodedValue = decode{{{toPascalCase additionalProperties.valueType}}}(rawInput[key]);
         {{/if}}

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

@@ -1,3 +1,10 @@
+{{#*inline "nestedArrayDecoder"}}
+{{~#if depth~}}
+(item: unknown) => decodeArray(item, {{~> nestedArrayDecoder depth=(subtract depth 1) composerType=composerType~}})
+{{~else~}}
+decode{{{toPascalCase composerType}}}
+{{~/if~}}
+{{/inline}}
 export type {{typeName}} =
   {{#each compositions}}
   | {{#if (eq this.source 'referenced')}}C{{../typeName}}{{referencedType}}
@@ -12,6 +19,7 @@ export type {{typeName}} =
   {{/if}}
 {{/each}};
 
+{{#unless customAttributes.skipDecoderGeneration}}
 export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   const result: {{typeName}} | null =
   {{#each compositions}}
@@ -20,7 +28,7 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   {{else if (eq this.dataType 'object')}}
     decodeC{{this.templateInput.typeName}}(rawInput)
   {{else if (eq this.dataType 'array')}}
-    decodeArray(rawInput, decode{{{toPascalCase this.templateInput.composerType}}})
+    decodeArray(rawInput, {{~> nestedArrayDecoder depth=this.templateInput.arrayNestingDepth composerType=this.templateInput.composerType~}})
   {{else if this.templateInput.values}}
     decode{{this.templateInput.typeName}}(rawInput)
   {{else}}
@@ -29,6 +37,7 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   {{/each}};
   return result;
 }
+{{/unless}}
 
 
 {{#each compositions}}
@@ -43,6 +52,7 @@ export class C{{../typeName}}{{referencedType}} {
   }
 }
 
+{{#unless ../customAttributes.skipDecoderGeneration}}
 export function decodeC{{../typeName}}{{referencedType}}(rawInput: unknown): C{{../typeName}}{{referencedType}} | null {
   const result = decode{{referencedType}}(rawInput);
   if (result === null) {
@@ -50,6 +60,7 @@ export function decodeC{{../typeName}}{{referencedType}}(rawInput: unknown): C{{
   }
   return new C{{../typeName}}{{referencedType}}(result);
 }
+{{/unless}}
 
 {{else if (eq this.dataType 'object')}}
 
@@ -62,6 +73,7 @@ export class C{{../typeName}}{{this.templateInput.typeName}} {
   }
 }
 
+{{#unless ../customAttributes.skipDecoderGeneration}}
 export function decodeC{{this.templateInput.typeName}}(rawInput: unknown) {
   const result = decode{{this.templateInput.typeName}}(rawInput);
   if (result === null) {
@@ -69,6 +81,7 @@ export function decodeC{{this.templateInput.typeName}}(rawInput: unknown) {
   }
   return new C{{../typeName}}{{this.templateInput.typeName}}(result);
 }
+{{/unless}}
 
 {{/if}}
 {{/each}}

package/dist/types/index.d.ts

@@ -129,6 +129,7 @@ export type ObjectTemplateInputProperty = TypeDescriptors & {
     referenced: boolean;
     primitiveType: string;
     composerType: string | null;
+    arrayNestingDepth?: number;
     optional: boolean;
     customAttributes?: Record<string, unknown> | null;
 };
@@ -138,6 +139,7 @@ export type AdditionalPropertiesTemplateInput = {
     valueTypeReferenced: boolean;
     valuePrimitiveType: string;
     valueComposerType: string | null;
+    valueArrayNestingDepth?: number;
 };
 export type AdditionalPropertiesGenerationResult = {
     templateInput: AdditionalPropertiesTemplateInput;
@@ -163,11 +165,13 @@ export type EnumTemplateInput = TypeDescriptors & {
     typeName: string;
     type: string;
     values: string[] | number[];
+    customAttributes?: Record<string, unknown> | null;
 };
 export type OneOfTemplateInput = TypeDescriptors & {
     typeName: string;
     type: string;
     compositions: OneOfTemplateInputComposition[];
+    customAttributes?: Record<string, unknown> | null;
 };
 export type OneOfTemplateInputComposition = {
     dataType?: TypeDataType | null;
@@ -180,6 +184,7 @@ export type AllOfTemplateInput = TypeDescriptors & {
     typeName: string;
     type: string;
     compositions: AllOfTemplateInputComposition[];
+    customAttributes?: Record<string, unknown> | null;
 };
 export type AllOfTemplateInputComposition = {
     dataType?: TypeDataType | null;
@@ -192,6 +197,7 @@ export type VariableTemplateInput = TypeDescriptors & {
     typeName: string;
     type: string;
     composerType?: string;
+    arrayNestingDepth?: number;
 };
 export type TemplateInput = ObjectTemplateInput | EnumTemplateInput | OneOfTemplateInput | AllOfTemplateInput | VariableTemplateInput;
 export type GenerationResult = {

package/package.json

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