type-crafter 0.13.1 → 0.13.3

package/dist/index.js

@@ -21521,18 +21521,19 @@ async function generateAdditionalPropertiesType(typeName, typeInfo, parentTypes)
         type: 'string'
     }).templateInput.type;
     if (typeof typeInfo.additionalProperties === 'boolean') {
+        const unknownType = getPrimitiveType(typeName, {
+            ...placeholderTypeInfo,
+            type: 'unknown'
+        });
         return {
             templateInput: {
                 keyType: stringKeyType,
-                valueType: getPrimitiveType(typeName, {
-                    ...placeholderTypeInfo,
-                    type: 'unknown'
-                }).templateInput.type,
+                valueType: unknownType.templateInput.type,
                 valueTypeReferenced: false,
                 valuePrimitiveType: 'unknown',
                 valueComposerType: null
             },
-            primitives: new Set()
+            primitives: unknownType.primitives
         };
     }
     else if (valueIsKeyedAdditionalProperties(typeInfo.additionalProperties)) {
@@ -21657,7 +21658,8 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
                 example: propertyDetails.example,
                 description: propertyDetails.description,
                 summary: propertyDetails.summary,
-                optional: typeInfo.optional?.includes(propertyName) ?? false
+                optional: typeInfo.optional?.includes(propertyName) ?? false,
+                customAttributes: propertyDetails.customAttributes ?? null
             }
         };
     }
@@ -21725,7 +21727,8 @@ async function generateArrayType(typeName, typeInfo, parentTypes) {
         arrayItemsType.templateInput.type = itemTypeName;
     }
     else {
-        arrayItemsType = await generateType(typeName + 'Item', typeInfo.items, parentTypes);
+        const itemName = toPascalCase(typeName) + 'Item';
+        arrayItemsType = await generateType(itemName, typeInfo.items, parentTypes);
         // For referenced types (e.g. enums via $ref), use the type name as the item type
         // identifier, consistent with how inline enums are handled above.
         // Also only keep the direct reference — the referenced type handles its own imports.
@@ -21738,6 +21741,11 @@ async function generateArrayType(typeName, typeInfo, parentTypes) {
                 references: new Set([refItemTypeName])
             };
         }
+        else {
+            // For inline types (e.g. anonymous objects), include the generated type definition
+            // so it is emitted alongside the struct that references it.
+            dynamicGeneratedType += arrayItemsType.content;
+        }
     }
     if (typeof arrayItemsType.templateInput?.type === 'undefined') {
         throw new InvalidSpecFileError('Invalid array type for: ' + typeName);
@@ -22142,7 +22150,9 @@ async function writeTypesToFile(config, types, fileName) {
 }
 async function writeExporterModules(files, folder) {
     const exporterModuleContent = Runtime.getExporterModuleTemplate()({
-        modules: [...files].map((file) => file.replace(Runtime.getConfig().output.fileExtension, ''))
+        modules: [...files]
+            .map((file) => file.replace(Runtime.getConfig().output.fileExtension, ''))
+            .sort()
     });
     const config = Runtime.getConfig();
     // Merging the contents of exporter module & types file in case their names are same.
@@ -22343,13 +22353,13 @@ async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTy
         language: {
             exporterModuleName: 'mod',
             typeMapper: {
-                string: { default: 'String' },
+                string: { default: 'String', date: 'time::Date', 'date-time': 'time::OffsetDateTime' },
                 number: { default: 'i32' },
                 integer: { default: 'i32' },
                 boolean: 'bool',
                 array: 'Vec<~ItemType~>',
                 object: 'type',
-                unknown: 'String'
+                unknown: 'serde_json::Value'
             },
             modulePathConfig: {
                 separator: '::',
@@ -22486,7 +22496,7 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.13.1');
+const program = new Command().version('0.13.3');
 program
     .command('generate')
     .description('Generate types for your language from a type spec file')

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

@@ -5,12 +5,23 @@
 /// Example: {{{example}}}
 {{/if}}
 #[derive(Debug, Clone, Serialize, Deserialize)]
+{{#if customAttributes.renameAll}}
+#[serde(rename_all = "{{{customAttributes.renameAll}}}")]
+{{/if}}
 pub struct {{typeName}} {
 {{#each properties}}
 {{#if this.description}}
     /// {{{this.description}}}
 {{/if}}
+{{#if this.customAttributes.[x-name]}}
+    #[serde(rename = "{{{this.customAttributes.[x-name]}}}")]
+{{else}}
+{{#unless ../customAttributes.renameAll}}
+{{#unless (eq @key (toSnakeCase @key))}}
     #[serde(rename = "{{@key}}")]
+{{/unless}}
+{{/unless}}
+{{/if}}
 {{#unless this.required}}
     #[serde(skip_serializing_if = "Option::is_none")]
 {{/unless}}

package/dist/types/index.d.ts

@@ -130,6 +130,7 @@ export type ObjectTemplateInputProperty = TypeDescriptors & {
     primitiveType: string;
     composerType: string | null;
     optional: boolean;
+    customAttributes?: Record<string, unknown> | null;
 };
 export type AdditionalPropertiesTemplateInput = {
     keyType: string;

package/package.json

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