type-crafter 0.3.0 → 0.5.0

package/dist/runtime.d.ts

@@ -1,4 +1,4 @@
-import type { Configuration, EnumTemplateInput, ExporterModuleTemplateInput, ObjectTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
+import type { Configuration, EnumTemplateInput, ExporterModuleTemplateInput, GeneratedReferencedType, ObjectTemplateInput, OneOfTemplateInput, SpecFileData, TypeFilePath, TypesFileTemplateInput } from '$types';
 declare function setConfig(newConfig: Configuration): void;
 declare function getConfig(): Configuration;
 declare function setSpecFileData(newSpecFileData: SpecFileData): void;
@@ -8,8 +8,12 @@ declare function getObjectTemplate(): HandlebarsTemplateDelegate<ObjectTemplateI
 declare function getExporterModuleTemplate(): HandlebarsTemplateDelegate<ExporterModuleTemplateInput>;
 declare function getTypesFileTemplate(): HandlebarsTemplateDelegate<TypesFileTemplateInput>;
 declare function getEnumTemplate(): HandlebarsTemplateDelegate<EnumTemplateInput>;
+declare function getOneOfTemplate(): HandlebarsTemplateDelegate<OneOfTemplateInput>;
 declare function setExpectedOutputFiles(newExpectedOutputFiles: Map<string, TypeFilePath>): void;
 declare function getExpectedOutputFiles(): Map<string, TypeFilePath>;
+declare function getCachedReferencedTypes(): Map<string, GeneratedReferencedType>;
+declare function getCachedReferenceType(referencePath: string): GeneratedReferencedType | null;
+declare function cacheReferenceType(referencePath: string, generatedData: GeneratedReferencedType): void;
 declare const _default: {
     getConfig: typeof getConfig;
     setConfig: typeof setConfig;
@@ -22,5 +26,9 @@ declare const _default: {
     getEnumTemplate: typeof getEnumTemplate;
     getExpectedOutputFiles: typeof getExpectedOutputFiles;
     compileTemplates: typeof compileTemplates;
+    getOneOfTemplate: typeof getOneOfTemplate;
+    getCachedReferencedTypes: typeof getCachedReferencedTypes;
+    getCachedReferenceType: typeof getCachedReferenceType;
+    cacheReferenceType: typeof cacheReferenceType;
 };
 export default _default;

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

@@ -1,4 +1,13 @@
-export type {{enumName}} =
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
+export type {{typeName}} =
 {{#each values}}
-  | {{#if (eq ../enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../enumType 'string')}}'{{/if}}
+  | {{#if (eq ../type 'string') }}'{{/if}}{{{this}}}{{#if (eq ../type 'string')}}'{{/if}}
 {{/each}};

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

@@ -1,5 +1,24 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
 export type {{typeName}} = {
   {{#each properties}}
+  /**
+  {{#if this.description}}
+   * @description {{{this.description}}}
+  {{/if}}
+   * @type { {{this.type}} }
+   * @memberof {{../typeName}}
+  {{#if this.example}}
+   * @example {{{this.example}}}
+  {{/if}}
+   */
   {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
   {{/each}}
 };

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

@@ -0,0 +1,19 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  | {{#if (eq this.source 'referenced')}}{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{#each this.templateInput.values}}
+        {{#unless @first}}|{{/unless}} {{#if (eq ../this.templateInput.enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../this.templateInput/enumType 'string')}}'{{/if}}
+      {{/each}}
+    {{else if (eq this.dataType 'object')}}
+      {
+        {{#each this.templateInput.properties}}
+        {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
+        {{/each}}
+      }
+    {{else}}
+      {{this.templateInput.dataType}}
+    {{/if}}
+  {{/if}}
+{{/each}};

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

@@ -1,13 +1,21 @@
-export type {{enumName}} =
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
+export type {{typeName}} =
 {{#each values}}
-  | {{#if (eq ../enumType 'string') }}'{{/if}}{{{this}}}{{#if (eq ../enumType 'string')}}'{{/if}}
+  | {{#if (eq ../type 'string') }}'{{/if}}{{{this}}}{{#if (eq ../type 'string')}}'{{/if}}
 {{/each}};
 
-
-export function decode{{enumName}}(rawInput: unknown): {{enumName}} | null {
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
   switch (rawInput) {
     {{#each values}}
-    case {{#if (eq ../enumType 'string') }}'{{/if}}{{this}}{{#if (eq ../enumType 'string')}}'{{/if}}:
+    case {{#if (eq ../type 'string') }}'{{/if}}{{this}}{{#if (eq ../type 'string')}}'{{/if}}:
     {{/each}}
      return rawInput;
   }

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

@@ -1,5 +1,24 @@
+/**
+ * @type { {{typeName}} }
+ {{#if description}}
+ * @description {{{description}}}
+ {{/if}}
+ {{#if example}}
+ * @example {{{example}}}
+ {{/if}}
+ */
 export type {{typeName}} = {
   {{#each properties}}
+  /**
+  {{#if this.description}}
+   * @description {{{this.description}}}
+  {{/if}}
+   * @type { {{this.type}} }
+   * @memberof {{../typeName}}
+  {{#if this.example}}
+   * @example {{{this.example}}}
+  {{/if}}
+   */
   {{@key}}: {{{this.type}}}{{#unless this.required}} | null{{/unless}};
   {{/each}}
 };

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

@@ -0,0 +1,74 @@
+export type {{typeName}} =
+  {{#each compositions}}
+  | {{#if (eq this.source 'referenced')}}C{{referencedType}}
+  {{else if (eq this.source 'inline')}}
+    {{#if this.templateInput.values}}
+      {{this.templateInput.typeName}}
+    {{else if (eq this.dataType 'object')}}
+      C{{this.templateInput.typeName}}
+    {{else}}
+      {{this.templateInput.dataType}}
+    {{/if}}
+  {{/if}}
+{{/each}};
+
+export function decode{{typeName}}(rawInput: unknown): {{typeName}} | null {
+  const result: {{typeName}} | null =
+  {{#each compositions}}
+  {{#if (eq this.source 'referenced')}}
+    decodeC{{referencedType}}(rawInput)
+  {{else if (eq this.dataType 'object')}}
+    decodeC{{this.templateInput.typeName}}(rawInput)
+  {{else if (eq this.templateInput.primitiveType 'array')}}
+    decodeArray(rawInput, decode{{{toPascalCase this.templateInput.itemType}}})
+  {{else if this.templateInput.values}}
+    decode{{this.templateInput.typeName}}(rawInput)
+  {{else}}
+    decode{{{toPascalCase this.templateInput.dataType}}}(rawInput)
+  {{/if}}{{#unless @last}}??{{/unless}}
+  {{/each}};
+  return result;
+}
+
+
+{{#each compositions}}
+
+{{#if this.templateInput.values}}
+{{{this.content}}}
+{{else if (eq this.source 'referenced')}}
+export class C{{referencedType}} {
+  data: {{referencedType}};
+  constructor(data: {{referencedType}}) {
+    this.data = data;
+  }
+}
+
+export function decodeC{{referencedType}}(rawInput: unknown): C{{referencedType}} | null {
+  const result = decode{{referencedType}}(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new C{{referencedType}}(result);
+}
+
+{{else if (eq this.dataType 'object')}}
+
+{{{this.content}}}
+
+export class C{{this.templateInput.typeName}} {
+  data: {{this.templateInput.typeName}};
+  constructor(data: {{this.templateInput.typeName}}) {
+    this.data = data;
+  }
+}
+
+export function decodeC{{this.templateInput.typeName}}(rawInput: unknown) {
+  const result = decode{{this.templateInput.typeName}}(rawInput);
+  if (result === null) {
+    return null;
+  }
+  return new C{{this.templateInput.typeName}}(result);
+}
+
+{{/if}}
+{{/each}}

package/dist/types/decoders.d.ts

@@ -1,6 +1,7 @@
-import type { EnumTemplateInput, GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypesWriterMode } from '.';
+import type { EnumTemplateInput, GroupedTypesWriterMode, ObjectTemplateInputProperties, SpecFileData, TypeInfo, TypesWriterMode } 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 decodeTypeInfo(rawInput: unknown): TypeInfo | null;
 export declare function decodeObjectTemplateInputProperties(rawInput: unknown): ObjectTemplateInputProperties | null;
 export declare function decodeEnumTemplateInput(rawInput: unknown): EnumTemplateInput | null;

package/dist/types/index.d.ts

@@ -21,6 +21,7 @@ export type Template = {
     exporterModuleSyntax: string;
     typesFileSyntax: string;
     enumSyntax: string;
+    oneOfSyntax: string;
 };
 export type LanguageConfig = {
     exporterModuleName: string;
@@ -35,6 +36,14 @@ export type FormatType = {
     default: string;
     [format: string]: string | undefined;
 };
+export type ResolveReferenceData = {
+    typeInfo: TypeInfo;
+    referenceName: string;
+    sourceFile?: string;
+};
+export type GeneratedReferencedType = ResolveReferenceData & {
+    templateData: GeneratedType<TemplateInput>;
+};
 export type SpecFileData = {
     info: SpecInfo;
     groupedTypes: GroupedTypes | null;
@@ -48,24 +57,31 @@ type GroupName = string;
 export type GroupedTypes = Record<GroupName, Types>;
 type TypeName = string;
 export type Types = Record<TypeName, TypeInfo>;
-export type TypeInfo = {
+export type TypeInfo = TypeDescriptors & {
     required: string[] | null;
     type: TypeDataType | null;
     format: string | null;
     items: TypeInfo | null;
     properties: TypeProperties | null;
     $ref: string | null;
+    oneOf: TypeInfo[] | null;
     enum: string[] | number[] | null;
 };
 type PropertyName = string;
 export type TypeProperties = Record<PropertyName, TypeInfo>;
 export type TypeDataType = 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'object' | 'unknown';
-export type ObjectTemplateInput = {
+export type TypeDescriptors = {
+    summary: string | null;
+    example: string | number | null;
+    description: string | null;
+};
+export type ObjectTemplateInput = TypeDescriptors & {
     typeName: string;
+    type: string;
     properties: ObjectTemplateInputProperties;
 };
 export type ObjectTemplateInputProperties = Record<PropertyName, ObjectTemplateInputProperty>;
-export type ObjectTemplateInputProperty = {
+export type ObjectTemplateInputProperty = TypeDescriptors & {
     type: string;
     required: boolean;
     referenced: boolean;
@@ -86,22 +102,41 @@ export type ReferencedModule = {
     moduleRelativePath: string;
     referencedTypes: string[];
 };
-export type EnumTemplateInput = {
-    enumName: string;
-    enumType: string;
+export type EnumTemplateInput = TypeDescriptors & {
+    typeName: string;
+    type: string;
     values: string[] | number[];
 };
+export type OneOfTemplateInput = TypeDescriptors & {
+    typeName: string;
+    type: string;
+    compositions: OneOfTemplateInputComposition[];
+};
+export type OneOfTemplateInputComposition = {
+    dataType?: TypeDataType | null;
+    templateInput?: TemplateInput;
+    source: 'inline' | 'referenced';
+    referencedType?: string;
+    content?: string;
+};
+export type VariableTemplateInput = TypeDescriptors & {
+    typeName: string;
+    type: string;
+    composerType?: string;
+};
+export type TemplateInput = ObjectTemplateInput | EnumTemplateInput | OneOfTemplateInput | VariableTemplateInput;
 export type GenerationResult = {
     groupedTypes: GroupedTypesOutput;
     types: GeneratedTypes;
 };
-export type GeneratedType = {
+export type GeneratedType<TemplateType extends TemplateInput> = {
     content: string;
     references: Set<string>;
     primitives: Set<string>;
+    templateInput: TemplateType;
 };
 export type GroupedTypesOutput = Record<GroupName, GeneratedTypes>;
-export type GeneratedTypes = Record<TypeName, GeneratedType>;
+export type GeneratedTypes = Record<TypeName, GeneratedType<TemplateInput>>;
 export type TypeFilePath = {
     modulePath: string;
     filePath: string;

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

@@ -6,3 +6,4 @@ export declare function deleteFolder(folderPath: string): Promise<void>;
 export declare function getCompleteFolderPath(folderName: string): Promise<string>;
 export declare function getExpectedWrittenPath(basePath: string, fileName: string): Promise<string>;
 export declare function writeFile(basePath: string, fileName: string, content: string): Promise<void>;
+export declare function readYaml(filePath: string): Promise<unknown>;

package/dist/utils/index.d.ts

@@ -7,7 +7,8 @@ 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;
+export declare function toPascalCaseHelper(input: unknown): string | unknown;
 export declare function registerTemplateHelpers(): void;
-export declare function readNestedValue(json: JSONObject, keyPath: string[]): JSONObject;
+export declare function readNestedValue(json: unknown, keyPath: string[]): JSONObject;
 export declare function generateRelativePath(fromPath: string, toPath: string): string;
 export declare function stripPrefix(value: string, prefix: string): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "type-crafter",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "A tool to generate types from a yaml schema for any language",
   "main": "./dist/index.js",
   "type": "module",
@@ -68,7 +68,7 @@
     "rollup": "^4.5.1",
     "rollup-plugin-copy": "^3.5.0",
     "tslib": "^2.6.2",
-    "type-decoder": "^1.2.0",
+    "type-decoder": "^2.0.1",
     "typescript": "^5.2.2",
     "yaml": "^2.3.2"
   }