type-crafter 0.1.0 → 0.2.0

package/dist/index.js

@@ -5,6 +5,7 @@ import path$1 from 'path';
 import require$$3 from 'fs';
 import require$$4 from 'process';
 import fs$1 from 'fs/promises';
+import { fileURLToPath } from 'url';
 
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
@@ -10857,11 +10858,15 @@ function decodeObjectTemplateInputProperty(rawInput) {
         const required = decodeBoolean(rawInput.required);
         const _type = decodeString(rawInput.type);
         const referenced = decodeBoolean(rawInput.referenced);
-        if (required !== null && _type !== null && referenced !== null) {
+        const primitiveType = decodeString(rawInput.primitiveType);
+        const composerType = decodeString(rawInput.composerType);
+        if (required !== null && _type !== null && referenced !== null && primitiveType !== null) {
             return {
                 type: _type,
                 required,
-                referenced
+                referenced,
+                primitiveType,
+                composerType
             };
         }
     }
@@ -19194,20 +19199,20 @@ function handleErrors(error) {
     }
 }
 
-let config$1 = null;
+let config$2 = null;
 let specFileData = null;
 let objectSyntaxTemplate = null;
 let exporterModuleSyntaxTemplate = null;
 let typesFileSyntaxTemplate = null;
 let expectedOutputFiles = null;
 function setConfig(newConfig) {
-    config$1 = newConfig;
+    config$2 = newConfig;
 }
 function getConfig() {
-    if (config$1 === null) {
+    if (config$2 === null) {
         throw new RuntimeError('Failed to load configuration!');
     }
-    return config$1;
+    return config$2;
 }
 function setSpecFileData(newSpecFileData) {
     specFileData = newSpecFileData;
@@ -19264,13 +19269,19 @@ var Runtime = {
     compileTemplates
 };
 
-function resolveFilePath(filePath) {
+function getSourceFileDirectory() {
+    const fileName = fileURLToPath(import.meta.url);
+    return path$1.dirname(fileName);
+}
+function resolveFilePath(filePath, useCurrentDirectory = true) {
     const isAbsolutePath = path$1.isAbsolute(filePath);
-    const normalizedPath = isAbsolutePath ? filePath : path$1.join(process.cwd(), filePath);
+    const normalizedPath = isAbsolutePath
+        ? filePath
+        : path$1.join(useCurrentDirectory ? process.cwd() : getSourceFileDirectory(), filePath);
     return path$1.resolve(normalizedPath);
 }
-async function readFile(filePath) {
-    const data = await fs$1.readFile(resolveFilePath(filePath), 'utf-8');
+async function readFile(filePath, useCurrentWorkingDirectory = true) {
+    const data = await fs$1.readFile(resolveFilePath(filePath, useCurrentWorkingDirectory), 'utf-8');
     return data;
 }
 async function createFolderWithBasePath(basePath, folderName) {
@@ -19284,7 +19295,12 @@ async function createFolder(folderPath) {
     await fs$1.mkdir(folderPath, { recursive: true });
 }
 async function deleteFolder(folderPath) {
-    await fs$1.rmdir(folderPath, { recursive: true });
+    try {
+        await fs$1.rm(folderPath, { recursive: true });
+    }
+    catch (e) {
+        console.log("Couldn't delete folder: ", folderPath);
+    }
 }
 async function getCompleteFolderPath(folderName) {
     const isAbsolutePath = path$1.isAbsolute(folderName);
@@ -19328,6 +19344,19 @@ function getOptionalKeys(object) {
     }
     return nullableKeys;
 }
+function getRequiredKeys(object) {
+    const requiredKeys = [];
+    const properties = decodeObjectTemplateInputProperties(object);
+    if (properties !== null) {
+        for (const propertyName in properties) {
+            const property = properties[propertyName];
+            if (property.required) {
+                requiredKeys.push(propertyName);
+            }
+        }
+    }
+    return requiredKeys;
+}
 function getReferencedTypes(object) {
     const referencedTypes = [];
     const properties = decodeObjectTemplateInputProperties(object);
@@ -19379,8 +19408,13 @@ function toPascalCase(input) {
 }
 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('isNonEmptyArray', (value) => Array.isArray(value) && value.length === 0);
+    Handlebars.registerHelper('eq', (value1, value2) => value1 === value2);
 }
 function readNestedValue(json, keyPath) {
     let result = json;
@@ -19455,13 +19489,21 @@ function getReferenceName(reference) {
     const referenceParts = reference.split('/');
     return referenceParts[referenceParts.length - 1];
 }
+function resolveAndGetReferenceName(reference) {
+    resolveReference(reference);
+    return getReferenceName(reference);
+}
 function getLanguageDataType(dataType, format, items) {
     const typeMapper = Runtime.getConfig().language.typeMapper ?? null;
     const mappedType = typeMapper !== null ? typeMapper[dataType] : null;
     const itemsType = 
     // eslint-disable-next-line
-    items !== null && items.type !== null
-        ? getLanguageDataType(items.type, items.format, items.items)
+    items !== null
+        ? items.type !== null
+            ? getLanguageDataType(items.type, items.format, items.items)
+            : items.$ref !== null
+                ? resolveAndGetReferenceName(items.$ref)
+                : null
         : null;
     const fillerPatterns = [];
     if (itemsType !== null) {
@@ -19499,6 +19541,8 @@ function generateType(typeName, typeInfo, groupedTypes = false) {
         if (propertyType === null && reference === null) {
             throw new InvalidSpecFileError('Invalid property type for: ' + typeName + '.' + propertyName);
         }
+        const primitiveType = propertyType ?? 'object';
+        let composerType = null;
         let recursivePropertyName;
         let languageDataType = null;
         let isReferenced = false;
@@ -19522,7 +19566,12 @@ function generateType(typeName, typeInfo, groupedTypes = false) {
         }
         else if (propertyType !== null) {
             languageDataType = getLanguageDataType(propertyType, propertyFormat, propertyItems);
-            result.primitives.add(languageDataType);
+            result.primitives.add(propertyItems !== null ? 'Array' : languageDataType);
+            if (propertyItems !== null) {
+                const itemsType = getReferenceName(propertyItems.$ref ?? '');
+                result.references.add(itemsType);
+                composerType = itemsType;
+            }
         }
         if (languageDataType === null) {
             throw new InvalidSpecFileError(`Invalid language data type for: ${typeName}.${propertyName}`);
@@ -19532,7 +19581,9 @@ function generateType(typeName, typeInfo, groupedTypes = false) {
             [propertyName]: {
                 type: languageDataType,
                 required: typeInfo.required?.includes(propertyName) ?? false,
-                referenced: isReferenced
+                referenced: isReferenced,
+                primitiveType,
+                composerType
             }
         };
     }
@@ -19704,12 +19755,51 @@ async function writeOutput(generationResult) {
     });
 }
 
-async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode) {
+async function config$1(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode) {
+    const devMode = 'PRODUCTION'.includes('DEVELOPMENT');
     // PRODUCTION will be replaced with PRODUCTION when package is built.
-    const directoryPrefix = 'PRODUCTION'.includes('DEVELOPMENT') ? 'src/' : 'dist/';
-    const objectSyntax = await readFile(directoryPrefix + 'templates/typescript/object-syntax.hbs');
-    const exporterModuleSyntax = await readFile(directoryPrefix + 'templates/typescript/exporter-module-syntax.hbs');
-    const typesFileSyntax = await readFile(directoryPrefix + 'templates/typescript/types-file-syntax.hbs');
+    const directoryPrefix = devMode ? 'src/' : './';
+    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 config = {
+        input: inputFilePath,
+        output: {
+            cleanWrite: true,
+            fileExtension: '.ts',
+            directory: outputDirectory,
+            writerMode: {
+                groupedTypes: groupedTypesWriterMode,
+                types: typesWriterMode
+            }
+        },
+        template: {
+            objectSyntax,
+            exporterModuleSyntax,
+            typesFileSyntax
+        },
+        language: {
+            exporterModuleName: 'index',
+            typeMapper: {
+                string: { default: 'string', date: 'Date' },
+                number: { default: 'number' },
+                integer: { default: 'integer' },
+                boolean: 'boolean',
+                array: '~ItemType~[]',
+                object: 'type',
+                unknown: 'unknown'
+            }
+        }
+    };
+    return config;
+}
+
+async function config(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode) {
+    const devMode = 'PRODUCTION'.includes('DEVELOPMENT');
+    const directoryPrefix = devMode ? 'src/' : './';
+    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 config = {
         input: inputFilePath,
         output: {
@@ -19770,6 +19860,9 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
         let generatorConfig = null;
         switch (language.toLowerCase()) {
             case 'typescript':
+                generatorConfig = await config$1(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode);
+                break;
+            case 'typescript-with-decoders':
                 generatorConfig = await config(inputFilePath, outputDirectory, typesWriterMode, groupedTypesWriterMode);
                 break;
             default:
@@ -19786,7 +19879,7 @@ async function runner(language, inputFilePath, outputDirectory, _typesWriterMode
     }
 }
 greeting();
-const program = new Command().version('0.1.0');
+const program = new Command().version('0.2.0');
 program
     .command('generate')
     .description('Generate types for your language from a type spec file')

package/dist/templates/index.d.ts

@@ -1 +1,2 @@
 export * as typescript from './typescript';
+export * as typescriptWithDecoders from './typescript-with-decoders';

package/dist/templates/typescript-with-decoders/index.d.ts

@@ -0,0 +1,2 @@
+import type { Configuration, GroupedTypesWriterMode, TypesWriterMode } from '$types';
+export declare function config(inputFilePath: string, outputDirectory: string, typesWriterMode: TypesWriterMode, groupedTypesWriterMode: GroupedTypesWriterMode): Promise<Configuration>;

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

@@ -0,0 +1,30 @@
+export type {{typeName}} = {
+  {{#each properties}}
+  {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
+  {{/each}}
+};
+
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
+  if (isJSON(rawInput)) {
+    {{#each properties}}
+    const {{@key}} = {{#if (eq this.primitiveType 'array') }} decodeArray(rawInput.{{@key}}, decode{{{toPascalCase this.composerType}}}){{else}} decode{{{toPascalCase this.type}}}(rawInput.{{@key}}){{/if}};
+    {{/each}}
+
+    {{#if (areRequiredKeysPresent properties)}}
+    if (
+      {{#each (getRequiredKeys properties)}}
+      {{this}} === null{{#unless @last}} ||{{/unless}}
+      {{/each}}
+    ) {
+      return null;
+    }
+    {{/if}}
+
+    return {
+      {{#each properties}}
+      {{@key}},
+      {{/each}}
+    };
+  }
+  return null;
+}

package/dist/templates/typescript-with-decoders/types-file-syntax.hbs

@@ -0,0 +1,7 @@
+{{#each (getReferencedTypeModules referencedTypes writtenAt)}}
+import { {{#each this.referencedTypes}}type {{this}}, decode{{this}}{{#unless @last}}, {{/unless}} {{/each}} } from '{{this.moduleRelativePath}}';
+{{/each}}
+import { isJSON, {{#each primitives}}decode{{{toPascalCase this}}}{{#unless @last}}, {{/unless}}{{/each}} } from 'type-decoder';
+
+{{{typesContent}}}
+

package/dist/types/index.d.ts

@@ -67,6 +67,8 @@ export type ObjectTemplateInputProperty = {
     type: string;
     required: boolean;
     referenced: boolean;
+    primitiveType: string;
+    composerType: string | null;
 };
 export type ExporterModuleTemplateInput = {
     modules: string[];

package/dist/utils/file-system.d.ts

@@ -1,5 +1,5 @@
-export declare function resolveFilePath(filePath: string): string;
-export declare function readFile(filePath: string): Promise<string>;
+export declare function resolveFilePath(filePath: string, useCurrentDirectory?: boolean): string;
+export declare function readFile(filePath: string, useCurrentWorkingDirectory?: 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/dist/utils/index.d.ts

@@ -3,6 +3,7 @@ export * from './file-system';
 export * from './logger';
 export declare function addValuesToMappedSet(map: Map<string, Set<string>>, key: string, values: string[]): void;
 export declare function getOptionalKeys(object: unknown): string[];
+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;

package/package.json

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