type-crafter 0.6.0 → 0.7.0

package/dist/index.js

@@ -3533,9 +3533,20 @@ function decodeTypes(rawInput) {
     }
     return null;
 }
+function decodeAdditionalPropertiesKeyType(rawInput) {
+    if (typeof rawInput === 'string') {
+        switch (rawInput) {
+            case 'string':
+            case 'number':
+                return rawInput;
+        }
+    }
+    return null;
+}
 function decodeTypeInfo(rawInput) {
     if (isJSON(rawInput)) {
         const _type = decodeTypeDataType(rawInput.type);
+        const additionalProperties = decodeAdditionalProperties(rawInput.additionalProperties);
         const result = {
             type: _type,
             required: decodeArray(rawInput.required, decodeString),
@@ -3547,6 +3558,7 @@ function decodeTypeInfo(rawInput) {
             description: decodeString(rawInput.description),
             example: decodeString(rawInput.example) ?? decodeNumber(rawInput.example),
             oneOf: decodeArray(rawInput.oneOf, decodeTypeInfo),
+            additionalProperties,
             enum: _type === 'string'
                 ? decodeArray(rawInput.enum, decodeString)
                 : _type === 'number'
@@ -3557,6 +3569,28 @@ function decodeTypeInfo(rawInput) {
     }
     return null;
 }
+function decodeAdditionalProperties(rawInput) {
+    return (decodeKeyedAdditionalProperties(rawInput) ?? decodeTypeInfo(rawInput) ?? decodeBoolean(rawInput));
+}
+function decodeKeyedAdditionalProperties(rawInput) {
+    if (isJSON(rawInput)) {
+        const keyType = decodeAdditionalPropertiesKeyType(rawInput.keyType);
+        const valueType = decodeTypeInfo(rawInput.valueType);
+        if (keyType !== null && valueType !== null) {
+            return {
+                keyType,
+                valueType
+            };
+        }
+    }
+    return null;
+}
+function valueIsKeyedAdditionalProperties(value) {
+    return decodeKeyedAdditionalProperties(value) !== null;
+}
+function valueIsTypeInfo(value) {
+    return decodeTypeInfo(value) !== null;
+}
 function decodeTypeProperties(rawInput) {
     if (isJSON(rawInput)) {
         const result = {};
@@ -19647,6 +19681,20 @@ function fillPatterns(input, patterns) {
     return result;
 }
 
+const placeholderTypeInfo = {
+    required: null,
+    type: null,
+    format: null,
+    items: null,
+    properties: null,
+    $ref: null,
+    oneOf: null,
+    enum: null,
+    additionalProperties: null,
+    summary: null,
+    description: null,
+    example: null
+};
 /**
  * @description Generates the primitive type for the unit attribute in the spec.
  * @param typeName { string }
@@ -19688,6 +19736,39 @@ function getPrimitiveType(typeName, typeInfo) {
     result.primitives.add(languageDataType);
     return result;
 }
+async function generateAdditionalPropertiesType(typeName, typeInfo, parentTypes) {
+    let result = null;
+    const stringKeyType = getPrimitiveType(typeName, {
+        ...placeholderTypeInfo,
+        type: 'string'
+    }).templateInput.type;
+    if (typeof typeInfo.additionalProperties === 'boolean') {
+        result = {
+            keyType: stringKeyType,
+            valueType: getPrimitiveType(typeName, {
+                ...placeholderTypeInfo,
+                type: 'unknown'
+            }).templateInput.type
+        };
+    }
+    else if (valueIsKeyedAdditionalProperties(typeInfo.additionalProperties)) {
+        result = {
+            keyType: getPrimitiveType(typeName, {
+                ...placeholderTypeInfo,
+                type: typeInfo.additionalProperties.keyType
+            }).templateInput.type,
+            valueType: (await generateType(typeName + 'ValueType', typeInfo.additionalProperties.valueType, parentTypes)).templateInput.type
+        };
+    }
+    else if (valueIsTypeInfo(typeInfo.additionalProperties)) {
+        const valueType = await generateType(typeName + 'ValueType', typeInfo.additionalProperties, parentTypes);
+        result = {
+            keyType: stringKeyType,
+            valueType: valueType.templateInput.type
+        };
+    }
+    return result;
+}
 async function generateObjectType(typeName, typeInfo, parentTypes) {
     const templateInput = {
         typeName,
@@ -19708,7 +19789,10 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
         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 && propertyDetails.oneOf === null) {
+        if (propertyType === null &&
+            reference === null &&
+            propertyDetails.oneOf === null &&
+            propertyDetails.additionalProperties === null) {
             throw new InvalidSpecFileError('Invalid property type for: ' + typeName + '.' + propertyName);
         }
         const primitiveType = propertyType ?? 'object';
@@ -19726,7 +19810,7 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
         }
         else if (enumValues !== null) {
             const enumName = toPascalCase(propertyName) + 'Enum';
-            dynamicGeneratedType = generateEnumType(enumName, propertyDetails).content;
+            dynamicGeneratedType += generateEnumType(enumName, propertyDetails).content;
             languageDataType = enumName;
         }
         else if (propertyType === 'array') {
@@ -19748,7 +19832,7 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
             languageDataType = primitiveTypeGenOutput.templateInput.type;
             primitives.push(...primitiveTypeGenOutput.primitives);
             references.push(...primitiveTypeGenOutput.references);
-            dynamicGeneratedType = primitiveTypeGenOutput.content;
+            dynamicGeneratedType += primitiveTypeGenOutput.content;
         }
         if (languageDataType === null) {
             throw new InvalidSpecFileError(`Invalid language data type for: ${typeName}.${propertyName}`);
@@ -19767,6 +19851,11 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
             }
         };
     }
+    // Generating additional property types
+    const additionalProperties = await generateAdditionalPropertiesType(typeName + 'AdditionalProperty', typeInfo, parentTypes);
+    if (additionalProperties !== null) {
+        templateInput.additionalProperties = additionalProperties;
+    }
     const result = {
         content: Runtime.getObjectTemplate()(templateInput) +
             (recursiveTypeGenOutput?.content ?? '') +
@@ -20089,7 +20178,7 @@ async function writeTypesToFiles(config, types, folderName = '') {
     // 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 filterReferences = folderName !== '' && Runtime.getConfig().output.writerMode.groupedTypes !== 'FolderWithFiles';
     const typeNames = Object.keys(types);
     for (const typeName in types) {
         const typeData = types[typeName];
@@ -20325,15 +20414,15 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.6.0');
+const program = new Command().version('0.7.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', 'Files')
-    .argument('[groupedTypesWriterMode]', 'Writer mode for grouped types', 'FolderWithFiles')
+    .argument('[typesWriterMode]', 'Writer mode for types', 'SingleFile')
+    .argument('[groupedTypesWriterMode]', 'Writer mode for grouped types', 'SingleFile')
     .action(runner);
 program.parse();
 

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

@@ -21,4 +21,7 @@ export type {{typeName}} = {
    */
   {{{jsonKey @key}}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
   {{/each}}
+  {{#if additionalProperties}}
+  [keys: {{jsonKey additionalProperties.keyType}}]: {{additionalProperties.valueType}};
+  {{/if}}
 };

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

@@ -21,6 +21,9 @@ export type {{typeName}} = {
    */
   {{{jsonKey @key}}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
   {{/each}}
+  {{#if additionalProperties}}
+  [keys: {{jsonKey additionalProperties.keyType}}]: {{additionalProperties.valueType}};
+  {{/if}}
 };
 
 export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
@@ -40,6 +43,9 @@ export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
     {{/if}}
 
     return {
+      {{#if additionalProperties}}
+      ...rawInput,
+      {{/if}}
       {{#each properties}}
       {{{jsonKey @key}}}: decoded{{{variableName @key}}},
       {{/each}}

package/dist/types/decoders.d.ts

@@ -1,9 +1,12 @@
-import type { GroupRef, EnumTemplateInput, GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypeInfo, Types, TypesWriterMode, GroupTypesData } from '.';
+import type { GroupRef, EnumTemplateInput, GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypeInfo, Types, TypesWriterMode, GroupTypesData, KeyedAdditionalProperties, AdditionalPropertiesKeyType } 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 decodeAdditionalPropertiesKeyType(rawInput: unknown): AdditionalPropertiesKeyType | null;
 export declare function decodeTypeInfo(rawInput: unknown): TypeInfo | null;
+export declare function valueIsKeyedAdditionalProperties(value: unknown): value is KeyedAdditionalProperties;
+export declare function valueIsTypeInfo(value: unknown): value is TypeInfo;
 export declare function decodeObjectTemplateInputProperties(rawInput: unknown): ObjectTemplateInputProperties | null;
 export declare function decodeEnumTemplateInput(rawInput: unknown): EnumTemplateInput | null;

package/dist/types/index.d.ts

@@ -79,7 +79,14 @@ export type TypeInfo = TypeDescriptors & {
     $ref: string | null;
     oneOf: TypeInfo[] | null;
     enum: string[] | number[] | null;
+    additionalProperties: AdditionalProperties | null;
 };
+export type AdditionalProperties = KeyedAdditionalProperties | TypeInfo | boolean;
+export type KeyedAdditionalProperties = {
+    keyType: AdditionalPropertiesKeyType;
+    valueType: TypeInfo;
+};
+export type AdditionalPropertiesKeyType = 'string' | 'number';
 type PropertyName = string;
 export type TypeProperties = Record<PropertyName, TypeInfo>;
 export type TypeDataType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'unknown';
@@ -92,6 +99,7 @@ export type ObjectTemplateInput = TypeDescriptors & {
     typeName: string;
     type: string;
     properties: ObjectTemplateInputProperties;
+    additionalProperties?: AdditionalPropertiesTemplateInput;
 };
 export type ObjectTemplateInputProperties = Record<PropertyName, ObjectTemplateInputProperty>;
 export type ObjectTemplateInputProperty = TypeDescriptors & {
@@ -101,6 +109,10 @@ export type ObjectTemplateInputProperty = TypeDescriptors & {
     primitiveType: string;
     composerType: string | null;
 };
+export type AdditionalPropertiesTemplateInput = {
+    keyType: string;
+    valueType: string;
+};
 export type ExporterModuleTemplateInput = {
     modules: string[];
 };

package/package.json

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