@goast/typescript 0.0.1

package/esm/lib/file-builder.js

@@ -0,0 +1,240 @@
+import { SourceBuilder, notNullish } from '@goast/core';
+import { ImportExportCollection } from './import-collection';
+export class TypeScriptFileBuilder extends SourceBuilder {
+    get options() {
+        return super.options;
+    }
+    constructor(filePath, options) {
+        super(options);
+        this.imports = new ImportExportCollection();
+        this.filePath = filePath;
+    }
+    addImport(name, moduleNameOrfilePath) {
+        this.imports.addImport(name, moduleNameOrfilePath);
+        return this;
+    }
+    addExport(name, filePath) {
+        this.imports.addExport(name, filePath);
+        return this;
+    }
+    clear() {
+        super.clear();
+        this.imports.clear();
+    }
+    toString(addPadding = true) {
+        return new SourceBuilder(this.options)
+            .append((builder) => this.imports.writeTo(builder, this.filePath, this.options.importModuleTransformer))
+            .appendIf(addPadding, (builder) => builder.ensurePreviousLineEmpty())
+            .append(super.toString())
+            .appendIf(addPadding, (builder) => builder.ensureCurrentLineEmpty())
+            .toString();
+    }
+    appendGenericArguments(...genericArguments) {
+        genericArguments = genericArguments.filter(notNullish);
+        if (genericArguments.length === 0)
+            return this;
+        const multiline = genericArguments.length > 1;
+        return this.parenthesize('<>', (builder) => builder.appendSeparated(genericArguments, multiline ? ',\n' : ', '), {
+            multiline,
+            indent: multiline,
+        });
+    }
+    appendParameter(parameter) {
+        var _a;
+        if (!parameter)
+            return;
+        if (typeof parameter === 'object') {
+            return this.append(parameter.name)
+                .appendIf(parameter.isOptional === true, '?')
+                .appendIf(parameter.type !== undefined, ': ', (builder) => {
+                if (!parameter.type)
+                    throw new Error('Unreachable error');
+                return typeof parameter.type === 'object'
+                    ? builder.appendExternalTypeUsage(parameter.type)
+                    : builder.append(parameter.type);
+            })
+                .appendGenericArguments(...((_a = parameter.genericArguments) !== null && _a !== void 0 ? _a : []))
+                .appendIf(parameter.defaultValue !== undefined, ' = ', parameter.defaultValue);
+        }
+        else {
+            return this.append(parameter);
+        }
+    }
+    appendParameters(...parameters) {
+        parameters = parameters.filter(notNullish);
+        if (parameters.length === 0)
+            return this.append('()');
+        const multiline = parameters.length > 1;
+        return this.parenthesize('()', (builder) => builder.forEach(parameters, (builder, param) => builder.appendParameter(param), {
+            separator: multiline ? ',\n' : ', ',
+        }), { multiline, indent: multiline });
+    }
+    appendObjectLiteral(...properties) {
+        properties = properties.filter(notNullish);
+        if (properties.length === 0)
+            return this.append('{}');
+        const multiline = properties.length > 1;
+        return this.parenthesize('{}', (builder) => builder
+            .appendIf(!multiline, ' ')
+            .appendSeparated(properties, multiline ? ',\n' : ', ')
+            .appendIf(!multiline, ' '), { multiline, indent: multiline });
+    }
+    appendArrayLiteral(...items) {
+        items = items.filter(notNullish);
+        if (items.length === 0)
+            return this.append('[]');
+        const multiline = items.length > 1;
+        return this.parenthesize('[]', (builder) => builder.appendSeparated(items, multiline ? ',\n' : ', '), {
+            multiline,
+            indent: multiline,
+        });
+    }
+    appendCodeBlock(...content) {
+        return this.parenthesize('{}', (builder) => builder.append(...content).ensureCurrentLineEmpty(), {
+            multiline: true,
+        });
+    }
+    appendComment(style, comment) {
+        if (!comment)
+            return this;
+        if (typeof comment === 'string') {
+            comment = comment.trim();
+        }
+        return style === '//'
+            ? this.appendLineWithLinePrefix('// ', comment)
+            : this.appendLine(style === '/**/' ? '/*' : '/**')
+                .appendWithLinePrefix(' * ', comment)
+                .ensureCurrentLineEmpty()
+                .appendLine(' */');
+    }
+    appendDocumentation(documentation) {
+        return this.appendComment('/***/', documentation);
+    }
+    appendModelUsage(type) {
+        this.append(type.component);
+        for (const i of type.imports) {
+            this.addImport(i.name, i.modulePath);
+        }
+        return this;
+    }
+    appendExternalTypeUsage(type) {
+        return this.append(type.name).addImport(type.name, type.module);
+    }
+    appendTypeDeclaration(options) {
+        return this.appendDocumentation(options.documentation)
+            .appendIf(options.omitExport !== true, 'export ')
+            .append('type ')
+            .append(options.name)
+            .append(' = ')
+            .append(options.type)
+            .appendLine(';');
+    }
+    appendAnnotation(options) {
+        var _a;
+        if (options.module)
+            this.addImport(options.name, options.module);
+        return this.append(`@${options.name}`).appendParameters(...((_a = options.args) !== null && _a !== void 0 ? _a : []));
+    }
+    appendAnnotations(annotations, separator) {
+        if (annotations.length === 0)
+            return this;
+        return this.forEach(annotations, (builder, annotation) => builder.appendAnnotation(annotation).append(separator));
+    }
+    appendClass(options) {
+        var _a;
+        return this.appendComment('/***/', options.documentation)
+            .appendAnnotations((_a = options.annotations) !== null && _a !== void 0 ? _a : [], '\n')
+            .appendIf(options.omitExport !== true, 'export ')
+            .appendIf(options.isAbstract === true, 'abstract ')
+            .append('class ')
+            .append(options.name)
+            .indent((builder) => {
+            var _a;
+            return builder
+                .appendGenericArguments(...((_a = options === null || options === void 0 ? void 0 : options.genericArguments) !== null && _a !== void 0 ? _a : []))
+                .appendIf(options.extends !== undefined, '\nextends ', options.extends)
+                .appendIf(options.implements !== undefined && options.implements.length > 0, ' implements ', (builder) => { var _a; return builder.appendSeparated((_a = options.implements) !== null && _a !== void 0 ? _a : [], ', '); });
+        })
+            .append(options.extends || (options.implements !== undefined && options.implements.length > 0) ? '\n' : ' ')
+            .appendCodeBlock(options.body)
+            .appendLine();
+    }
+    appendConstructor(options) {
+        var _a, _b;
+        return this.appendComment('/***/', options.documentation)
+            .appendAnnotations((_a = options.annotations) !== null && _a !== void 0 ? _a : [], '\n')
+            .append('constructor')
+            .appendParameters(...((_b = options === null || options === void 0 ? void 0 : options.parameters) !== null && _b !== void 0 ? _b : []))
+            .append(' ')
+            .appendCodeBlock(options.body)
+            .appendLine();
+    }
+    appendMethod(options) {
+        var _a, _b, _c;
+        return this.appendComment('/***/', options.documentation)
+            .appendAnnotations((_a = options.annotations) !== null && _a !== void 0 ? _a : [], '\n')
+            .appendIf(options.accessibility !== undefined, options.accessibility, ' ')
+            .appendIf(options.isAbstract === true, 'abstract ')
+            .appendIf(options.isStatic === true, 'static ')
+            .appendIf(options.isAsync === true, 'async ')
+            .append(options.name)
+            .appendGenericArguments(...((_b = options === null || options === void 0 ? void 0 : options.genericArguments) !== null && _b !== void 0 ? _b : []))
+            .appendParameters(...((_c = options === null || options === void 0 ? void 0 : options.parameters) !== null && _c !== void 0 ? _c : []))
+            .appendIf(options.returnType !== undefined, ': ', options.returnType)
+            .append(' ')
+            .appendCodeBlock(options.body)
+            .appendLine();
+    }
+    appendProperty(options) {
+        var _a, _b, _c, _d, _e;
+        if (options.kind === 'getter' || options.kind === 'setter' || options.kind === 'getter-setter') {
+            if (options.kind === 'getter-setter' || options.kind === 'getter') {
+                this.appendComment('/***/', options.documentation)
+                    .appendAnnotations([...((_a = options.annotations) !== null && _a !== void 0 ? _a : []), ...((_b = options.getterAnnotations) !== null && _b !== void 0 ? _b : [])], '\n')
+                    .appendIf(options.accessibility !== undefined, options.accessibility, ' ')
+                    .appendIf(options.isAbstract === true, 'abstract ')
+                    .appendIf(options.isStatic === true, 'static ')
+                    .append('get ', options.name, '()')
+                    .appendIf(options.type !== undefined, ': ', options.type)
+                    .if(options.isAbstract === true, (builder) => builder.append(';'), (builder) => builder.append(' ').appendCodeBlock(options.getter))
+                    .ensureCurrentLineEmpty();
+            }
+            if (options.kind === 'getter-setter' || options.kind === 'setter') {
+                this.appendComment('/***/', options.documentation)
+                    .appendAnnotations([...((_c = options.annotations) !== null && _c !== void 0 ? _c : []), ...((_d = options.setterAnnotations) !== null && _d !== void 0 ? _d : [])], '\n')
+                    .appendIf(options.accessibility !== undefined, options.accessibility, ' ')
+                    .appendIf(options.isAbstract === true, 'abstract ')
+                    .appendIf(options.isStatic === true, 'static ')
+                    .append('set ', options.name)
+                    .parenthesize('()', (builder) => builder.append('value: ', options.type))
+                    .if(options.isAbstract === true, (builder) => builder.append(';'), (builder) => builder.append(' ').appendCodeBlock(options.setter))
+                    .ensureCurrentLineEmpty();
+            }
+            return this;
+        }
+        return this.appendComment('/***/', options.documentation)
+            .appendAnnotations((_e = options.annotations) !== null && _e !== void 0 ? _e : [], '\n')
+            .appendIf(options.accessibility !== undefined, options.accessibility, ' ')
+            .appendIf(options.isAbstract === true, 'abstract ')
+            .appendIf(options.isStatic === true, 'static ')
+            .appendIf(options.isReadonly === true, 'readonly ')
+            .append(options.name)
+            .appendIf(options.isOptional === true, '?')
+            .appendIf(options.type !== undefined, ': ', options.type)
+            .appendIf(options.initializer !== undefined, ' = ', options.initializer)
+            .appendLine(';');
+    }
+    appendFunction(options) {
+        var _a, _b;
+        const kind = (_a = options.kind) !== null && _a !== void 0 ? _a : 'arrow-function';
+        return this.appendIf(kind === 'arrow-function' && !!options.name, 'const ', options.name, ' = ')
+            .appendIf(options.isAsync === true, 'async ')
+            .appendIf(kind === 'function', 'function')
+            .appendIf(kind === 'function' && !!options.name, ' ', options.name)
+            .appendParameters(...((_b = options === null || options === void 0 ? void 0 : options.parameters) !== null && _b !== void 0 ? _b : []))
+            .appendIf(options.returnType !== undefined, ': ', options.returnType)
+            .append(' ')
+            .appendIf(kind === 'arrow-function', '=> ')
+            .parenthesizeIf(kind === 'function' || options.singleLine !== true, '{}', (builder) => builder.append(options.body), { multiline: true });
+    }
+}

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

@@ -0,0 +1,22 @@
+import { toCasing } from '@goast/core';
+import { toTypeScriptPropertyName, toTypeScriptStringLiteral } from '../utils';
+export class TypeScriptFileGenerator {
+    getAnyType(context) {
+        return context.config.preferUnknown ? 'unknown' : 'any';
+    }
+    toTypeName(context, name) {
+        return toCasing(name, context.config.typeNameCasing);
+    }
+    toMethodName(context, name) {
+        return toTypeScriptPropertyName(toCasing(name, context.config.methodNameCasing), context.config.useSingleQuotes);
+    }
+    toPropertyName(context, name, keepCasing = false) {
+        return toTypeScriptPropertyName(keepCasing ? name : toCasing(name, context.config.propertyNameCasing), context.config.useSingleQuotes);
+    }
+    toEnumValueName(context, name) {
+        return toTypeScriptPropertyName(toCasing(name, context.config.enumValueNameCasing), context.config.useSingleQuotes);
+    }
+    toStringLiteral(context, text) {
+        return toTypeScriptStringLiteral(text, context.config.useSingleQuotes);
+    }
+}

package/esm/lib/generators/index.js

@@ -0,0 +1,4 @@
+export * from './file-generator';
+export * from './models';
+export * from './services/angular-services';
+export * from './services/fetch-clients';

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

@@ -0,0 +1,3 @@
+export * from './model-generator';
+export * from './models';
+export * from './models-generator';

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

@@ -0,0 +1,313 @@
+import { dirname, resolve } from 'path';
+import { ensureDirSync, writeFileSync } from 'fs-extra';
+import { getSchemaReference, resolveAnyOfAndAllOf, toCasing, } from '@goast/core';
+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());
+            return { component: name, filePath, imports: [{ kind: 'file', name, modulePath: filePath }] };
+        }
+        else {
+            const builder = new TypeScriptFileBuilder(undefined, ctx.config);
+            this.generateType(ctx, builder, ctx.schema);
+            const imports = builder.imports.imports;
+            builder.imports.clear();
+            return { component: builder.toString(false), imports };
+        }
+    }
+    generateFileContent(ctx, builder) {
+        const interfaceSchema = this.resolveInterfaceSchema(ctx);
+        if (interfaceSchema) {
+            this.generateInterface(ctx, builder, interfaceSchema);
+        }
+        else if (ctx.config.enumGeneration !== 'union' &&
+            ctx.schema.kind === 'string' &&
+            ctx.schema.enum !== undefined &&
+            ctx.schema.enum.length > 0) {
+            this.generateEnum(ctx, builder);
+        }
+        else {
+            this.generateTypeAlias(ctx, builder);
+        }
+    }
+    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) {
+        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(';');
+        }
+    }
+    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(';');
+    }
+    generateTypeAliasSignature(ctx, builder) {
+        builder.append('export type ').append(this.getDeclarationTypeName(ctx, ctx.schema));
+    }
+    generateTypeUsage(ctx, builder, schema) {
+        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);
+            }
+            builder.append(name);
+        }
+        else {
+            this.generateType(ctx, builder, schema);
+        }
+    }
+    generateType(ctx, builder, schema) {
+        if (schema.enum !== undefined && schema.enum.length > 0) {
+            this.generateEnumType(ctx, builder, schema);
+            return;
+        }
+        switch (schema.kind) {
+            case 'boolean':
+                builder.append('boolean');
+                break;
+            case 'integer':
+            case 'number':
+                builder.append('number');
+                break;
+            case 'string':
+                builder.append('string');
+                break;
+            case 'null':
+                builder.append('null');
+                break;
+            case 'unknown':
+                builder.append(this.getAnyType(ctx));
+                break;
+            case 'array':
+                this.generateArrayType(ctx, builder, schema);
+                break;
+            case 'object':
+                this.generateObjectType(ctx, builder, schema);
+                break;
+            case 'combined':
+                this.generateCombinedType(ctx, builder, schema);
+                break;
+            case 'multi-type':
+                this.generateMultiType(ctx, builder, schema);
+                break;
+            case 'oneOf':
+                this.generateOneOfType(ctx, builder, schema);
+                break;
+            default:
+                builder.append(this.getAnyType(ctx));
+                break;
+        }
+    }
+    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('[]');
+    }
+    generateCombinedType(ctx, builder, schema) {
+        if (schema.allOf.length === 0 && schema.anyOf.length === 0) {
+            builder.append(this.getAnyType(ctx));
+            return;
+        }
+        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: ' & ' }));
+    }
+    generateOneOfType(ctx, builder, schema) {
+        if (schema.oneOf.length === 0) {
+            builder.append(this.getAnyType(ctx));
+            return;
+        }
+        builder.parenthesizeIf(schema.oneOf.length > 1, '()', (builder) => builder.forEach(schema.oneOf, (builder, schema) => this.generateTypeUsage(ctx, builder, schema), {
+            separator: ' | ',
+        }));
+    }
+    generateMultiType(ctx, builder, schema) {
+        if (schema.type.length === 0) {
+            builder.append(this.getAnyType(ctx));
+            return;
+        }
+        const parenthesize = schema.type.length > 1;
+        builder.parenthesizeIf(parenthesize, '()', (builder) => builder
+            .appendIf(parenthesize, (builder) => builder.appendLine().append('| '))
+            .forEach(schema.type, (builder, type) => {
+            switch (type) {
+                case 'string':
+                    builder.append('string');
+                    break;
+                case 'number':
+                case 'integer':
+                    builder.append('number');
+                    break;
+                case 'boolean':
+                    builder.append('boolean');
+                    break;
+                case 'null':
+                    builder.append('null');
+                    break;
+                case 'array':
+                    this.generateArrayType(ctx, builder, schema);
+                    break;
+                case 'object':
+                    this.generateObjectType(ctx, builder, schema);
+                    break;
+                default:
+                    builder.append('never');
+                    break;
+            }
+        }, { 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
+        if (!schema.isNameGenerated) {
+            return true;
+        }
+        // All enum types should have its own type declaration
+        if (schema.kind === 'string' && schema.enum !== undefined && schema.enum.length > 0) {
+            return true;
+        }
+        // All primitive types already exist and do not need its own type declaration
+        if (schema.kind !== 'array' &&
+            schema.kind !== 'combined' &&
+            schema.kind !== 'multi-type' &&
+            schema.kind !== 'object' &&
+            schema.kind !== 'oneOf') {
+            return false;
+        }
+        // For all other types, check if the user has enabled inline unnamed schemas
+        return !ctx.config.inlineUnnamedSchemas;
+    }
+    resolveInterfaceSchema(ctx) {
+        if (ctx.config.typeDeclaration === 'prefer-interface' &&
+            (ctx.schema.kind === 'object' || ctx.schema.kind === 'combined')) {
+            return resolveAnyOfAndAllOf(ctx.schema, true);
+        }
+        return undefined;
+    }
+    getDeclarationTypeName(ctx, schema) {
+        return toCasing(schema.name, ctx.config.typeNameCasing);
+    }
+    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

@@ -0,0 +1,63 @@
+import { dirname, resolve } from 'path';
+import { ensureDirSync, writeFileSync } from 'fs-extra';
+import { OpenApiSchemasGenerationProviderBase, Factory } from '@goast/core';
+import { DefaultTypeScriptModelGenerator } from './model-generator';
+import { defaultTypeScriptModelsGeneratorConfig, } from './models';
+import { TypeScriptFileBuilder } from '../../file-builder';
+import { ImportExportCollection } from '../../import-collection';
+export class TypeScriptModelsGenerator extends OpenApiSchemasGenerationProviderBase {
+    constructor(modelGeneratorFactory) {
+        super();
+        this._modelGeneratorFactory = modelGeneratorFactory !== null && modelGeneratorFactory !== void 0 ? modelGeneratorFactory : Factory.fromValue(new DefaultTypeScriptModelGenerator());
+    }
+    initResult() {
+        return {
+            models: {},
+            modelIndexFilePath: undefined,
+        };
+    }
+    buildContext(context, config) {
+        return this.getProviderContext(context, config, defaultTypeScriptModelsGeneratorConfig);
+    }
+    onGenerate(ctx) {
+        const output = super.onGenerate(ctx);
+        output.modelIndexFilePath = this.generateIndexFile(ctx);
+        return output;
+    }
+    generateSchema(ctx, schema) {
+        const modelGenerator = this._modelGeneratorFactory.create();
+        return modelGenerator.generate(Object.assign(Object.assign({}, ctx), { schema }));
+    }
+    addSchemaResult(ctx, schema, result) {
+        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());
+        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);
+    }
+}

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

@@ -0,0 +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 defaultTypeScriptModelsGeneratorConfig = Object.assign(Object.assign({}, defaultTypeScriptModelGeneratorConfig), { indexFilePath: 'models.ts' });