type-crafter 0.8.0 → 0.8.2

package/dist/index.js

@@ -19409,7 +19409,16 @@ function resolveFilePath(filePath, useCurrentDirectory = true) {
         : path$1.join(useCurrentDirectory ? process.cwd() : getSourceFileDirectory(), filePath);
     return path$1.resolve(normalizedPath);
 }
-async function readFile(filePath, useCurrentWorkingDirectory = true) {
+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, caseSensitive = false) {
+    if (caseSensitive && !(await checkFileNameCase(filePath))) {
+        throw new Error(`File not found: ${filePath}`);
+    }
     const data = await fs$1.readFile(resolveFilePath(filePath, useCurrentWorkingDirectory), 'utf-8');
     return data;
 }
@@ -19454,7 +19463,7 @@ async function writeFile(basePath, fileName, content) {
     await fs$1.writeFile(filePath, content);
 }
 async function readYaml(filePath) {
-    const fileData = await readFile(filePath);
+    const fileData = await readFile(filePath, true, true);
     return YAML.parse(fileData);
 }
 
@@ -19573,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)) {
@@ -19789,7 +19810,7 @@ async function generateObjectType(typeName, typeInfo, parentTypes) {
         summary: typeInfo.summary,
         properties: {}
     };
-    let recursiveTypeGenOutput = null;
+    const compositions = [];
     let dynamicGeneratedType = '';
     const primitives = [];
     const references = [];
@@ -19832,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);
@@ -19869,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),
@@ -19993,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);
@@ -20045,13 +20069,13 @@ async function generateAllOfTypes(typeName, typeInfo, parentTypes) {
     for (let index = 0; index < typeInfo.allOf.length; index++) {
         const allOfItem = typeInfo.allOf[index];
         if (allOfItem.$ref !== null) {
-            const referenceData = await resolveTypeReference(allOfItem.$ref);
+            const referenceData = await generateReferencedType(typeName + 'AllOf' + index, allOfItem, 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), allOfItem, parentTypes);
@@ -20484,7 +20508,7 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.8.0');
+const program = new Command().version('0.8.2');
 program
     .command('generate')
     .description('Generate types for your language from a type spec file')

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/utils/file-system.d.ts

@@ -1,5 +1,5 @@
 export declare function resolveFilePath(filePath: string, useCurrentDirectory?: boolean): string;
-export declare function readFile(filePath: string, useCurrentWorkingDirectory?: boolean): Promise<string>;
+export declare function readFile(filePath: string, useCurrentWorkingDirectory?: boolean, caseSensitive?: boolean): Promise<string>;
 export declare function createFolderWithBasePath(basePath: string, folderName: string): Promise<void>;
 export declare function createFolder(folderPath: string): Promise<void>;
 export declare function deleteFolder(folderPath: string): Promise<void>;

package/package.json

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