@goast/typescript 0.0.5 → 0.2.1

package/esm/lib/generators/models/model-generator.js

@@ -1,281 +1,211 @@
-import { dirname, resolve } from 'path';
-import { ensureDirSync, writeFileSync } from 'fs-extra';
-import { getSchemaReference, resolveAnyOfAndAllOf, toCasing, } from '@goast/core';
+import { resolve } from 'path';
+import { appendValueGroup, getSchemaReference, notNullish, resolveAnyOfAndAllOf, toCasing, } from '@goast/core';
+import { ts } from '../../ast';
 import { TypeScriptFileBuilder } from '../../file-builder';
-import { toTypeScriptPropertyName } from '../../utils';
 import { TypeScriptFileGenerator } from '../file-generator';
 export class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator {
     generate(ctx) {
         if (this.shouldGenerateTypeDeclaration(ctx, ctx.schema)) {
             const name = this.getDeclarationTypeName(ctx, ctx.schema);
             const filePath = this.getFilePath(ctx, ctx.schema);
-            console.log(`Generating model ${name} to ${filePath}...`);
-            ensureDirSync(dirname(filePath));
-            const builder = new TypeScriptFileBuilder(filePath, ctx.config);
-            this.generateFileContent(ctx, builder);
-            writeFileSync(filePath, builder.toString());
+            TypeScriptFileBuilder.generate({
+                logName: `model ${name}`,
+                filePath,
+                options: ctx.config,
+                generator: (b) => b.append(this.getFileContent(ctx)),
+            });
             return { component: name, filePath, imports: [{ kind: 'file', name, modulePath: filePath }] };
         }
         else {
             const builder = new TypeScriptFileBuilder(undefined, ctx.config);
-            this.generateType(ctx, builder, ctx.schema);
+            builder.append(this.getType(ctx, ctx.schema));
             const imports = builder.imports.imports;
             builder.imports.clear();
             return { component: builder.toString(false), imports };
         }
     }
-    generateFileContent(ctx, builder) {
+    getFileContent(ctx) {
+        const content = appendValueGroup([], '\n');
         const interfaceSchema = this.resolveInterfaceSchema(ctx);
         if (interfaceSchema) {
-            this.generateInterface(ctx, builder, interfaceSchema);
+            content.values.push(this.getInterface(ctx, interfaceSchema));
         }
         else if (ctx.config.enumGeneration !== 'union' &&
             ctx.schema.kind === 'string' &&
             ctx.schema.enum !== undefined &&
             ctx.schema.enum.length > 0) {
-            this.generateEnum(ctx, builder);
+            content.values.push(this.getEnum(ctx));
         }
         else {
-            this.generateTypeAlias(ctx, builder);
+            content.values.push(this.getTypeAlias(ctx, ctx.schema));
         }
+        return content;
     }
-    generateEnum(ctx, builder) {
-        builder
-            .append((builder) => this.generateTypeDocumentation(ctx, builder))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateEnumSignature(ctx, builder))
-            .parenthesize('{}', (builder) => this.generateEnumValues(ctx, builder), { multiline: true })
-            .ensureCurrentLineEmpty();
-    }
-    generateEnumSignature(ctx, builder) {
-        builder.append('export enum ').append(this.getDeclarationTypeName(ctx, ctx.schema));
-    }
-    generateEnumValues(ctx, builder) {
+    getEnum(ctx) {
         var _a, _b;
-        builder.forEach((_b = (_a = ctx.schema.enum) === null || _a === void 0 ? void 0 : _a.map((x) => String(x))) !== null && _b !== void 0 ? _b : [], (builder, enumValue) => builder.append(`${this.toEnumValueName(ctx, enumValue)} = ${this.toStringLiteral(ctx, enumValue)}`), { separator: ',\n' });
-    }
-    generateInterface(ctx, builder, schema) {
-        builder
-            .append((builder) => this.generateTypeDocumentation(ctx, builder))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateInterfaceSignature(ctx, builder))
-            .parenthesize('{}', (builder) => builder.append((builder) => this.generateInterfaceContent(ctx, builder, schema)), { multiline: true })
-            .ensureCurrentLineEmpty();
-    }
-    generateInterfaceSignature(ctx, builder) {
-        builder.append('export interface ').append(this.getDeclarationTypeName(ctx, ctx.schema));
-    }
-    generateInterfaceContent(ctx, builder, schema) {
-        this.generateObjectTypeProperties(ctx, builder, schema);
-        if (schema.additionalProperties) {
-            builder.append('[key: string]: ');
-            if (schema.additionalProperties === true) {
-                builder.append(this.getAnyType(ctx));
-            }
-            else {
-                this.generateTypeUsage(ctx, builder, schema.additionalProperties);
-            }
-            builder.appendLine(';');
-        }
+        return ts.enum(this.getDeclarationTypeName(ctx, ctx.schema), {
+            export: true,
+            members: ((_b = (_a = ctx.schema.enum) === null || _a === void 0 ? void 0 : _a.map((x) => String(x))) !== null && _b !== void 0 ? _b : []).map((x) => ts.enumValue(toCasing(x, ctx.config.enumValueNameCasing), { value: ts.string(x) })),
+        });
     }
-    generateTypeAlias(ctx, builder) {
-        builder
-            .append((builder) => this.generateTypeDocumentation(ctx, builder))
-            .ensureCurrentLineEmpty()
-            .append((builder) => this.generateTypeAliasSignature(ctx, builder))
-            .append(' = ')
-            .append((builder) => this.generateType(ctx, builder, ctx.schema))
-            .appendLine(';');
+    getInterface(ctx, schema) {
+        return ts.interface(this.getDeclarationTypeName(ctx, ctx.schema), {
+            export: true,
+            doc: ts.doc({ description: schema.description }),
+            members: [...this.getProperties(ctx, schema), this.getIndexer(ctx, schema)],
+        });
     }
-    generateTypeAliasSignature(ctx, builder) {
-        builder.append('export type ').append(this.getDeclarationTypeName(ctx, ctx.schema));
+    getTypeAlias(ctx, schema) {
+        var _a;
+        const result = ts.typeAlias(this.getDeclarationTypeName(ctx, schema), (_a = this.getType(ctx, schema, true)) !== null && _a !== void 0 ? _a : this.getAnyType(ctx), {
+            export: true,
+            doc: ts.doc({ description: schema.description }),
+        });
+        if (schema.discriminator && Object.keys(schema.discriminator.mapping).length > 0) {
+            const propertyValue = ts.unionType(Object.keys(schema.discriminator.mapping).map((x) => ts.string(x)));
+            result.generics.push(ts.genericParameter(this.getDiscriminatorGenericParamName(ctx, schema), {
+                constraint: propertyValue,
+                default: propertyValue,
+            }));
+        }
+        return result;
+    }
+    getIndexer(ctx, schema) {
+        var _a;
+        return schema.additionalProperties
+            ? ts.indexer('string', (_a = (schema.additionalProperties === true ? null : this.getType(ctx, schema.additionalProperties))) !== null && _a !== void 0 ? _a : this.getAnyType(ctx), { readonly: ctx.config.immutableTypes })
+            : null;
+    }
+    getProperties(ctx, schema) {
+        return Array.from(schema.properties.values()).map((property) => {
+            return ts.property(property.name, {
+                doc: ts.doc({ description: property.schema.description }),
+                readonly: ctx.config.immutableTypes,
+                optional: !schema.required.has(property.name),
+                type: ts.unionType([this.getType(ctx, property.schema), property.schema.nullable ? 'null' : null]),
+            });
+        });
     }
-    generateTypeUsage(ctx, builder, schema) {
+    getType(ctx, schema, skipSchemas = false) {
+        if (!schema)
+            return this.getAnyType(ctx);
         schema = getSchemaReference(schema, ['description']);
-        if (this.shouldGenerateTypeDeclaration(ctx, schema)) {
-            const name = this.getDeclarationTypeName(ctx, schema);
-            const filePath = this.getFilePath(ctx, schema);
-            if (filePath) {
-                builder.addImport(name, filePath);
+        if (!skipSchemas && this.shouldGenerateTypeDeclaration(ctx, schema)) {
+            if (schema.id === ctx.schema.id) {
+                return null;
             }
-            builder.append(name);
+            return ts.reference(this.getDeclarationTypeName(ctx, schema), this.getFilePath(ctx, schema));
         }
-        else {
-            this.generateType(ctx, builder, schema);
+        if (schema.id === ctx.schema.id && schema.inheritedSchemas.length > 0) {
+            return ts.intersectionType(this.getInheritedSchemas(ctx, schema).map((x) => {
+                var _a;
+                const mappingValue = (_a = Object.entries(x.discriminator.mapping).find(([_, value]) => value.id === schema.id)) === null || _a === void 0 ? void 0 : _a[0];
+                return ts.reference(this.getDeclarationTypeName(ctx, x), this.getFilePath(ctx, x), {
+                    generics: [mappingValue !== undefined ? ts.string(mappingValue) : null],
+                });
+            }));
         }
-    }
-    generateType(ctx, builder, schema) {
-        if (schema.enum !== undefined && schema.enum.length > 0) {
-            this.generateEnumType(ctx, builder, schema);
-            return;
+        if (schema.enum) {
+            return ts.unionType(schema.enum.map((x) => ts.toNode(x)));
         }
         switch (schema.kind) {
             case 'boolean':
-                builder.append('boolean');
-                break;
+                return 'boolean';
             case 'integer':
             case 'number':
-                builder.append('number');
-                break;
+                return 'number';
             case 'string':
-                builder.append('string');
-                break;
+                return 'string';
             case 'null':
-                builder.append('null');
-                break;
+                return 'null';
             case 'unknown':
-                builder.append(this.getAnyType(ctx));
-                break;
+                return this.getAnyType(ctx);
             case 'array':
-                this.generateArrayType(ctx, builder, schema);
-                break;
+                return this.getArrayType(ctx, schema);
             case 'object':
-                this.generateObjectType(ctx, builder, schema);
-                break;
+                return this.getObjectType(ctx, schema);
             case 'combined':
-                this.generateCombinedType(ctx, builder, schema);
-                break;
+                return this.getCombinedType(ctx, schema);
             case 'multi-type':
-                this.generateMultiType(ctx, builder, schema);
-                break;
+                return this.getMultiType(ctx, schema);
             case 'oneOf':
-                this.generateOneOfType(ctx, builder, schema);
-                break;
+                return this.getOneOfType(ctx, schema);
             default:
-                builder.append(this.getAnyType(ctx));
-                break;
+                return this.getAnyType(ctx);
         }
     }
-    generateArrayType(ctx, builder, schema) {
-        builder
-            .appendIf(ctx.config.immutableTypes, 'readonly ')
-            .parenthesize('()', (builder) => schema.items ? this.generateTypeUsage(ctx, builder, schema.items) : builder.append(this.getAnyType(ctx)))
-            .append('[]');
+    getArrayType(ctx, schema) {
+        var _a;
+        return ts.arrayType((_a = this.getType(ctx, schema.items)) !== null && _a !== void 0 ? _a : this.getAnyType(ctx), {
+            readonly: ctx.config.immutableTypes,
+        });
     }
-    generateCombinedType(ctx, builder, schema) {
+    getObjectType(ctx, schema) {
+        const parts = [
+            schema.properties.size > 0 ? ts.objectType({ members: this.getProperties(ctx, schema) }) : null,
+            schema.additionalProperties ? ts.objectType({ members: [this.getIndexer(ctx, schema)] }) : null,
+            schema.allOf.length > 0 || schema.anyOf.length > 0 ? this.getCombinedType(ctx, schema) : null,
+        ].filter(notNullish);
+        if (parts.length === 0) {
+            parts.push(ts.objectType());
+        }
+        const type = ts.intersectionType(parts);
+        if (schema.discriminator && Object.keys(schema.discriminator.mapping).length > 0) {
+            const discriminator = schema.discriminator;
+            return ts.intersectionType([
+                type,
+                ts.lookupType(ts.objectType({
+                    members: Object.entries(discriminator.mapping).map(([key, value]) => ts.property(key, {
+                        type: ts.intersectionType([
+                            ts.objectType({
+                                members: [ts.property(discriminator.propertyName, { type: ts.string(key) })],
+                            }),
+                            this.getType(ctx, value, true),
+                        ]),
+                    })),
+                }), this.getDiscriminatorGenericParamName(ctx, schema)),
+            ]);
+        }
+        return type;
+    }
+    getCombinedType(ctx, schema) {
         if (schema.allOf.length === 0 && schema.anyOf.length === 0) {
-            builder.append(this.getAnyType(ctx));
-            return;
+            return this.getAnyType(ctx);
         }
-        builder
-            .forEach(schema.allOf, (builder, schema) => this.generateTypeUsage(ctx, builder, schema), { separator: ' & ' })
-            .appendIf(schema.anyOf.length > 0, (builder) => builder
-            .appendIf(schema.allOf.length > 0, ' & ')
-            .forEach(schema.anyOf, (builder, schema) => builder
-            .append('Partial')
-            .parenthesize('<>', (builder) => this.generateTypeUsage(ctx, builder, schema), { indent: false }), { separator: ' & ' }));
+        return ts.intersectionType([
+            ...schema.allOf.map((x) => this.getType(ctx, x)),
+            ...schema.anyOf.map((x) => ts.reference('Partial', null, { generics: [this.getType(ctx, x)] })),
+        ]);
     }
-    generateOneOfType(ctx, builder, schema) {
+    getOneOfType(ctx, schema) {
         if (schema.oneOf.length === 0) {
-            builder.append(this.getAnyType(ctx));
-            return;
+            return this.getAnyType(ctx);
         }
-        builder.parenthesizeIf(schema.oneOf.length > 1, '()', (builder) => builder.forEach(schema.oneOf, (builder, schema) => this.generateTypeUsage(ctx, builder, schema), {
-            separator: ' | ',
-        }));
+        return ts.unionType(schema.oneOf.map((x) => this.getType(ctx, x)));
     }
-    generateMultiType(ctx, builder, schema) {
+    getMultiType(ctx, schema) {
         if (schema.type.length === 0) {
-            builder.append(this.getAnyType(ctx));
-            return;
+            return this.getAnyType(ctx);
         }
-        const parenthesize = schema.type.length > 1;
-        builder.parenthesizeIf(parenthesize, '()', (builder) => builder
-            .appendIf(parenthesize, (builder) => builder.appendLine().append('| '))
-            .forEach(schema.type, (builder, type) => {
-            switch (type) {
+        return ts.unionType(schema.type.map((x) => {
+            switch (x) {
                 case 'string':
-                    builder.append('string');
-                    break;
+                    return 'string';
                 case 'number':
                 case 'integer':
-                    builder.append('number');
-                    break;
+                    return 'number';
                 case 'boolean':
-                    builder.append('boolean');
-                    break;
+                    return 'boolean';
                 case 'null':
-                    builder.append('null');
-                    break;
+                    return 'null';
                 case 'array':
-                    this.generateArrayType(ctx, builder, schema);
-                    break;
+                    return this.getArrayType(ctx, schema);
                 case 'object':
-                    this.generateObjectType(ctx, builder, schema);
-                    break;
+                    return this.getObjectType(ctx, schema);
                 default:
-                    builder.append('never');
-                    break;
+                    return 'never';
             }
-        }, { separator: (builder) => builder.appendLine().append('| ') }));
-    }
-    generateObjectType(ctx, builder, schema) {
-        if (schema.properties.size === 0 &&
-            !schema.additionalProperties &&
-            schema.allOf.length === 0 &&
-            schema.anyOf.length === 0 &&
-            schema.discriminator === undefined) {
-            builder.append('{}');
-            return;
-        }
-        // properties
-        if (schema.properties.size > 0) {
-            builder
-                .parenthesize('{}', (builder) => builder.appendLine().append((builder) => this.generateObjectTypeProperties(ctx, builder, schema)))
-                .appendIf(!!schema.additionalProperties || schema.allOf.length > 0 || schema.anyOf.length > 0, ' & ');
-        }
-        // additional properties
-        if (schema.additionalProperties) {
-            this.generateObjectTypeAdditionalProperties(ctx, builder, schema);
-            if (schema.allOf.length > 0 || schema.anyOf.length > 0) {
-                builder.append(' & ');
-            }
-        }
-        // allOf & anyOf
-        if (schema.allOf.length > 0 || schema.anyOf.length > 0) {
-            this.generateCombinedType(ctx, builder, schema);
-        }
-    }
-    generateObjectTypeProperties(ctx, builder, schema) {
-        builder.forEach(schema.properties.values(), (builder, property) => {
-            this.generatePropertyDocumentation(ctx, builder, property);
-            builder
-                .appendIf(ctx.config.immutableTypes, 'readonly ')
-                .append(toTypeScriptPropertyName(property.name, ctx.config.useSingleQuotes))
-                .appendIf(!schema.required.has(property.name), '?')
-                .append(': ')
-                .append((builder) => this.generateTypeUsage(ctx, builder, property.schema))
-                .appendIf(property.schema.nullable === true, ' | null')
-                .appendLine(';');
-        });
-    }
-    generateObjectTypeAdditionalProperties(ctx, builder, schema) {
-        if (!schema.additionalProperties)
-            return;
-        builder
-            .appendIf(ctx.config.immutableTypes, 'Readonly')
-            .parenthesizeIf(ctx.config.immutableTypes, '<>', (builder) => builder
-            .append('Record')
-            .appendGenericArguments('string', schema.additionalProperties === true
-            ? this.getAnyType(ctx)
-            : (builder) => this.generateTypeUsage(ctx, builder, schema.additionalProperties)));
-    }
-    generateEnumType(ctx, builder, schema) {
-        builder.indent((builder) => {
-            var _a;
-            builder.forEach((_a = schema.enum) !== null && _a !== void 0 ? _a : [], (builder, item) => builder.append(this.toStringLiteral(ctx, String(item))), {
-                separator: ' | ',
-            });
-        });
-    }
-    generateTypeDocumentation(ctx, builder) {
-        this.generateDocumentation(ctx, builder, ctx.schema);
-    }
-    generatePropertyDocumentation(ctx, builder, property) {
-        this.generateDocumentation(ctx, builder, property.schema);
-    }
-    generateDocumentation(ctx, builder, schema) {
-        builder.appendComment('/***/', schema.description);
+        }));
     }
     shouldGenerateTypeDeclaration(ctx, schema) {
         // All named schemas should have its own type declaration
@@ -283,7 +213,7 @@ export class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator {
             return true;
         }
         // All enum types should have its own type declaration
-        if (schema.kind === 'string' && schema.enum !== undefined && schema.enum.length > 0) {
+        if (schema.enum !== undefined && schema.enum.length > 0) {
             return true;
         }
         // All primitive types already exist and do not need its own type declaration
@@ -307,6 +237,15 @@ export class DefaultTypeScriptModelGenerator extends TypeScriptFileGenerator {
     getDeclarationTypeName(ctx, schema) {
         return toCasing(schema.name, ctx.config.typeNameCasing);
     }
+    getDiscriminatorGenericParamName(ctx, schema) {
+        var _a;
+        return toCasing((_a = schema.discriminator) === null || _a === void 0 ? void 0 : _a.propertyName, ctx.config.genericParamNameCasing);
+    }
+    getInheritedSchemas(ctx, schema) {
+        return schema.inheritedSchemas
+            .filter((schema) => this.shouldGenerateTypeDeclaration(ctx, schema) && !schema.isNameGenerated)
+            .filter((item, index, self) => self.indexOf(item) === index);
+    }
     getFilePath(ctx, schema) {
         return resolve(ctx.config.outputDir, ctx.config.modelsDirPath, `${toCasing(schema.name, ctx.config.fileNameCasing)}.ts`);
     }

package/esm/lib/generators/models/models-generator.js

@@ -1,10 +1,9 @@
-import { dirname, resolve } from 'path';
-import { ensureDirSync, writeFileSync } from 'fs-extra';
-import { OpenApiSchemasGenerationProviderBase, Factory } from '@goast/core';
+import { resolve } from 'path';
+import { OpenApiSchemasGenerationProviderBase, Factory, appendValueGroup, } from '@goast/core';
 import { DefaultTypeScriptModelGenerator } from './model-generator';
 import { defaultTypeScriptModelsGeneratorConfig, } from './models';
+import { ts } from '../../ast';
 import { TypeScriptFileBuilder } from '../../file-builder';
-import { ImportExportCollection } from '../../import-collection';
 export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderBase {
     constructor(modelGeneratorFactory) {
         super();
@@ -13,7 +12,7 @@ export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderB
     initResult() {
         return {
             models: {},
-            modelIndexFilePath: undefined,
+            indexFiles: { models: undefined },
         };
     }
     buildContext(context, config) {
@@ -21,7 +20,7 @@ export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderB
     }
     onGenerate(ctx) {
         const output = super.onGenerate(ctx);
-        output.modelIndexFilePath = this.generateIndexFile(ctx);
+        output.indexFiles.models = this.generateIndexFile(ctx);
         return output;
     }
     generateSchema(ctx, schema) {
@@ -32,32 +31,19 @@ export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderB
         ctx.output.models[schema.id] = result;
     }
     generateIndexFile(ctx) {
-        if (!this.shouldGenerateIndexFile(ctx)) {
-            return undefined;
-        }
         const filePath = this.getIndexFilePath(ctx);
-        console.log(`Generating model index file to ${filePath}...`);
-        ensureDirSync(dirname(filePath));
-        const builder = new TypeScriptFileBuilder(filePath, ctx.config);
-        this.generateIndexFileContent(ctx, builder);
-        writeFileSync(filePath, builder.toString());
+        TypeScriptFileBuilder.tryGenerate({
+            logName: 'model index file',
+            filePath,
+            options: ctx.config,
+            generator: (b) => b.append(this.getIndexFileContent(ctx)),
+        });
         return filePath;
     }
     getIndexFilePath(ctx) {
-        var _a;
-        return resolve(ctx.config.outputDir, (_a = ctx.config.indexFilePath) !== null && _a !== void 0 ? _a : 'models.ts');
-    }
-    shouldGenerateIndexFile(ctx) {
-        return ctx.config.indexFilePath !== null;
-    }
-    generateIndexFileContent(ctx, builder) {
-        const exports = new ImportExportCollection();
-        for (const modelId in ctx.output.models) {
-            const model = ctx.output.models[modelId];
-            if (model.filePath) {
-                exports.addExport(model.component, model.filePath);
-            }
-        }
-        exports.writeTo(builder);
+        return ctx.config.indexFilePath ? resolve(ctx.config.outputDir, ctx.config.indexFilePath) : null;
+    }
+    getIndexFileContent(ctx) {
+        return appendValueGroup(Object.values(ctx.output.models).map((x) => (x.filePath ? ts.export(x.component, x.filePath) : null)));
     }
 }

package/esm/lib/generators/models/models.js

@@ -1,3 +1,3 @@
 import { defaultTypeScriptGeneratorConfig } from '../../config';
-export const defaultTypeScriptModelGeneratorConfig = Object.assign(Object.assign({}, defaultTypeScriptGeneratorConfig), { fileNameCasing: 'kebab', typeNameCasing: 'pascal', enumGeneration: 'union', immutableTypes: false, inlineUnnamedSchemas: true, modelsDirPath: 'models', typeDeclaration: 'type' });
+export const defaultTypeScriptModelGeneratorConfig = Object.assign(Object.assign({}, defaultTypeScriptGeneratorConfig), { enumGeneration: 'union', immutableTypes: false, inlineUnnamedSchemas: true, modelsDirPath: 'models', typeDeclaration: 'type' });
 export const defaultTypeScriptModelsGeneratorConfig = Object.assign(Object.assign({}, defaultTypeScriptModelGeneratorConfig), { indexFilePath: 'models.ts' });