ts-openapi-codegen 1.0.0-beta.1 → 1.0.0-beta.2

package/dist/common/__tests__/migrationForMultiOptions.test.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const MultiOptionsMigrationPlan_1 = require("common/VersionedSchema/MultiOptionsMigrationPlan");
+const MultiOptionsVersionedSchemas_1 = require("common/VersionedSchema/MultiOptionsVersionedSchemas");
+const core_1 = require("../../core");
+const Enums_1 = require("../VersionedSchema/Enums");
+const migrateToLatestVersion_1 = require("../VersionedSchema/Utils/migrateToLatestVersion");
+(0, node_test_1.describe)('migrateToLatestVersion for Multioptions', () => {
+    node_test_1.test.skip('@unit: should migrate Multioptions data from 1.0.0 to 2.0.0', () => {
+        const dataMultiV1 = {
+            input: 'source/path',
+            output: 'generated/path',
+            client: core_1.HttpClient.AXIOS,
+            items: [{ input: 'item1', output: 'generated/path', }, { input: 'item2', output: 'generated/path', }],
+        };
+        const expectedDataMultiV3 = {
+            input: 'source/path',
+            httpClient: core_1.HttpClient.AXIOS,
+            items: [{ input: 'item1' }, { input: 'item2' }],
+            useCancelableRequest: false,
+        };
+        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+            rawInput: dataMultiV1,
+            versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
+            migrationPlans: MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan,
+        });
+        node_assert_1.default.deepEqual(result, { value: expectedDataMultiV3, schemaVersion: '2.0.0', schemaType: Enums_1.EVersionedSchemaType.MULTI_OPTIONS }, 'Should migrate Multioptions V1 data to V3 correctly');
+    });
+    node_test_1.test.skip('@unit: should migrate Multioptions data from 1.0.1 to 2.0.0', () => {
+        const dataMultiV2 = {
+            input: 'source/path',
+            output: 'generated/path',
+            httpClient: core_1.HttpClient.FETCH,
+            items: [{ input: 'item1' }, { input: 'item2' }],
+        };
+        const expectedDataMultiV3 = {
+            httpClient: core_1.HttpClient.FETCH,
+            items: [{ input: 'item1', output: 'generated/path', }, { input: 'item2', output: 'generated/path' }],
+        };
+        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+            rawInput: dataMultiV2,
+            versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
+            migrationPlans: MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan,
+        });
+        node_assert_1.default.deepEqual(result, { value: expectedDataMultiV3, schemaVersion: '2.0.0', schemaType: Enums_1.EVersionedSchemaType.MULTI_OPTIONS }, 'Should migrate Multioptions V2 data to V3 correctly');
+    });
+    node_test_1.test.skip('@unit: should return null for invalid Multioptions data after migration', () => {
+        const dataMultiV1 = {
+            input: 'source/path',
+            output: 'generated/path',
+            client: 'invalid-client', // Некорректное значение
+            items: [{ input: 'item1' }, { input: 'item2' }],
+        };
+        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+            rawInput: dataMultiV1,
+            versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
+            migrationPlans: MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan,
+        });
+        node_assert_1.default.equal(result, null, 'Should return null for invalid Multioptions data');
+    });
+    node_test_1.test.skip('@unit: should throw error if no migration plan exists for Multioptions', () => {
+        const dataMultiV1 = {
+            input: 'source/path',
+            output: 'generated/path',
+            client: 'axios',
+            items: [{ input: 'item1' }, { input: 'item2' }],
+        };
+        node_assert_1.default.throws(() => {
+            (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+                rawInput: dataMultiV1,
+                versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
+                migrationPlans: [],
+            });
+        }, /No migration plan from 1.0.0/, 'Should throw for missing migration plan in Multioptions');
+    });
+});

package/dist/common/__tests__/migrationForOptions.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=migrationForOptions.test.d.ts.map

package/dist/common/__tests__/migrationForOptions.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"migrationForOptions.test.d.ts","sourceRoot":"","sources":["../../../src/common/__tests__/migrationForOptions.test.ts"],"names":[],"mappings":""}

package/dist/common/__tests__/migrationForOptions.test.js

@@ -0,0 +1,62 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const OptionsMigrationPlans_1 = require("common/VersionedSchema/OptionsMigrationPlans");
+const OptionsVersionedSchemas_1 = require("common/VersionedSchema/OptionsVersionedSchemas");
+const core_1 = require("../../core");
+const Enums_1 = require("../VersionedSchema/Enums");
+const migrateToLatestVersion_1 = require("../VersionedSchema/Utils/migrateToLatestVersion");
+(0, node_test_1.describe)('migrateToLatestVersion', () => {
+    (0, node_test_1.test)('@unit: should migrate data from 1.0.0 to 2.0.0', () => {
+        const dataV1 = { input: 'source/path', output: 'generated/path', client: core_1.HttpClient.AXIOS };
+        const expectedDataV3 = {
+            input: 'source/path',
+            output: 'generated/path',
+            httpClient: core_1.HttpClient.AXIOS,
+            useCancelableRequest: false,
+        };
+        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+            rawInput: dataV1,
+            versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
+            migrationPlans: OptionsMigrationPlans_1.optionsMigrationPlans,
+        });
+        node_assert_1.default.deepEqual(result, { value: expectedDataV3, schemaVersion: '2.0.0', schemaType: Enums_1.EVersionedSchemaType.OPTIONS }, 'Should migrate 1.0.0 data to 2.0.0 correctly');
+    });
+    (0, node_test_1.test)('@unit: should migrate data from 1.0.1 to 2.0.0', () => {
+        const dataV2 = { input: 'source/path', output: 'generated/path', httpClient: core_1.HttpClient.FETCH };
+        const expectedDataV3 = {
+            input: 'source/path',
+            output: 'generated/path',
+            httpClient: core_1.HttpClient.FETCH,
+        };
+        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+            rawInput: dataV2,
+            versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
+            migrationPlans: OptionsMigrationPlans_1.optionsMigrationPlans,
+        });
+        node_assert_1.default.deepEqual(result, { value: expectedDataV3, schemaVersion: '2.0.0', schemaType: Enums_1.EVersionedSchemaType.OPTIONS }, 'Should migrate 1.0.1 data to 2.0.0 correctly');
+    });
+    node_test_1.test.skip('@unit: should return null for invalid data after migration', () => {
+        const dataV1 = { input: 'source/path', output: 'generated/path', client: 'invalid-client' };
+        const result = (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+            rawInput: dataV1,
+            versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
+            migrationPlans: OptionsMigrationPlans_1.optionsMigrationPlans,
+        });
+        node_assert_1.default.equal(result, null, 'Should return null for invalid data');
+    });
+    (0, node_test_1.test)('@unit: should throw error if no migration plan exists', () => {
+        const dataV1 = { input: 'source/path', output: 'generated/path', client: core_1.HttpClient.AXIOS };
+        node_assert_1.default.throws(() => {
+            (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+                rawInput: dataV1,
+                versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
+                migrationPlans: [],
+            });
+        }, /No migration plan from 1.0.0/, 'Should throw for missing migration plan');
+    });
+});

package/dist/common/defaultOptions.d.ts

@@ -0,0 +1,3 @@
+import Joi from 'joi';
+export declare const defaultOptions: Joi.ObjectSchema<any>;
+//# sourceMappingURL=defaultOptions.d.ts.map

package/dist/common/defaultOptions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"defaultOptions.d.ts","sourceRoot":"","sources":["../../src/common/defaultOptions.ts"],"names":[],"mappings":"AAAA,OAAO,GAAG,MAAM,KAAK,CAAC;AAGtB,eAAO,MAAM,cAAc,uBAA8B,CAAC"}

package/dist/common/defaultOptions.js

@@ -0,0 +1,9 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultOptions = void 0;
+const joi_1 = __importDefault(require("joi"));
+// Заполнить
+exports.defaultOptions = joi_1.default.object().unknown(false);

package/dist/core/Context.d.ts

@@ -0,0 +1,21 @@
+import { JSONSchema4Type, JSONSchema6Type, JSONSchema7Type } from 'json-schema';
+import RefParser from 'json-schema-ref-parser';
+import { IOutput, Prefix } from './types/Models';
+/**
+ * A Context wich can share a data between methods
+ */
+export declare class Context {
+    private _refs;
+    private _root;
+    private _output;
+    prefix: Prefix;
+    constructor(input: string | Record<string, any>, output: IOutput, prefix?: Prefix);
+    addRefs(refs: RefParser.$Refs): Context;
+    values(...types: string[]): Record<string, any>;
+    get($ref: string): JSONSchema4Type | JSONSchema6Type | JSONSchema7Type;
+    paths(...types: string[]): string[];
+    exists($ref: string): boolean;
+    fileName(): string;
+    get output(): IOutput;
+}
+//# sourceMappingURL=Context.d.ts.map

package/dist/core/Context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Context.d.ts","sourceRoot":"","sources":["../../src/core/Context.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AAChF,OAAO,SAAS,MAAM,wBAAwB,CAAC;AAE/C,OAAO,EAAS,OAAO,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAKxD;;GAEG;AACH,qBAAa,OAAO;IAChB,OAAO,CAAC,KAAK,CAA8B;IAC3C,OAAO,CAAC,KAAK,CAAoB;IACjC,OAAO,CAAC,OAAO,CAAU;IAClB,MAAM,EAAE,MAAM,CAInB;gBAEU,KAAK,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,CAAC,EAAE,MAAM;IAc1E,OAAO,CAAC,IAAI,EAAE,SAAS,CAAC,KAAK,GAAG,OAAO;IAKvC,MAAM,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC;IAO/C,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,eAAe,GAAG,eAAe;IAOtE,KAAK,CAAC,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE;IAOnC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAO7B,QAAQ,IAAI,MAAM;IAOzB,IAAW,MAAM,YAKhB;CACJ"}

package/dist/core/Context.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+const getFileName_1 = require("./utils/getFileName");
+const isString_1 = require("./utils/isString");
+const pathHelpers_1 = require("./utils/pathHelpers");
+/**
+ * A Context wich can share a data between methods
+ */
+class Context {
+    _refs;
+    _root;
+    _output;
+    prefix = {
+        interface: 'I',
+        enum: 'E',
+        type: 'T',
+    };
+    constructor(input, output, prefix) {
+        this._output = output;
+        this._refs = {};
+        if ((0, isString_1.isString)(input)) {
+            this._root = { path: (0, pathHelpers_1.dirName)(input), fileName: (0, getFileName_1.getFileName)(input) };
+        }
+        else {
+            this._root = { path: '' };
+        }
+        if (prefix) {
+            this.prefix = prefix;
+        }
+        return this;
+    }
+    addRefs(refs) {
+        this._refs = refs;
+        return this;
+    }
+    values(...types) {
+        if (!this._refs) {
+            throw new Error('Context must be initialized');
+        }
+        return this._refs.values(...types);
+    }
+    get($ref) {
+        if (!this._refs) {
+            throw new Error('Context must be initialized');
+        }
+        return this._refs.get($ref);
+    }
+    paths(...types) {
+        if (!this._refs) {
+            throw new Error('Context must be initialized');
+        }
+        return this._refs.paths(...types);
+    }
+    exists($ref) {
+        if (!this._refs) {
+            throw new Error('Context must be initialized');
+        }
+        return this._refs.exists($ref);
+    }
+    fileName() {
+        if (!this._root) {
+            throw new Error('Context must be initialized');
+        }
+        return this._root.fileName ? this._root.fileName : '';
+    }
+    get output() {
+        if (!this._output) {
+            throw new Error('Context must be initialized');
+        }
+        return this._output;
+    }
+}
+exports.Context = Context;

package/dist/core/api/v2/Parser.d.ts

@@ -0,0 +1,32 @@
+import { Context } from '../../Context';
+import { getModel } from '../v2/parser/getModel';
+import { getModelComposition } from './parser/getModelComposition';
+import { getModelProperties } from './parser/getModelProperties';
+import { getModels } from './parser/getModels';
+import { getOperation } from './parser/getOperation';
+import { getOperationParameter } from './parser/getOperationParameter';
+import { getOperationParameters } from './parser/getOperationParameters';
+import { getOperationResponse } from './parser/getOperationResponse';
+import { getOperationResponses } from './parser/getOperationResponses';
+import { getServices } from './parser/getServices';
+import { getType } from './parser/getType';
+import { parse } from './parserV2';
+export declare class Parser {
+    _context: Context;
+    constructor(context: Context);
+    get context(): Context;
+    getTypeNameByRef(value: string, ref?: string): string;
+    parse: typeof parse;
+    getModels: typeof getModels;
+    getType: typeof getType;
+    getModel: typeof getModel;
+    getModelComposition: typeof getModelComposition;
+    getModelProperties: typeof getModelProperties;
+    getServices: typeof getServices;
+    getOperationParameters: typeof getOperationParameters;
+    getOperationParameter: typeof getOperationParameter;
+    getOperation: typeof getOperation;
+    getOperationResponses: typeof getOperationResponses;
+    getOperationResponse: typeof getOperationResponse;
+}
+//# sourceMappingURL=Parser.d.ts.map

package/dist/core/api/v2/Parser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"Parser.d.ts","sourceRoot":"","sources":["../../../../src/core/api/v2/Parser.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AACxC,OAAO,EAAE,QAAQ,EAAE,MAAM,uBAAuB,CAAC;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAC;AACnE,OAAO,EAAE,kBAAkB,EAAE,MAAM,6BAA6B,CAAC;AACjE,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,sBAAsB,EAAE,MAAM,iCAAiC,CAAC;AACzE,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,EAAE,qBAAqB,EAAE,MAAM,gCAAgC,CAAC;AACvE,OAAO,EAAE,WAAW,EAAE,MAAM,sBAAsB,CAAC;AACnD,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAE,KAAK,EAAE,MAAM,YAAY,CAAC;AAEnC,qBAAa,MAAM;IACR,QAAQ,EAAE,OAAO,CAAC;gBAEb,OAAO,EAAE,OAAO;IAI5B,IAAI,OAAO,IAAI,OAAO,CAErB;IAEM,gBAAgB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,CAAC,EAAE,MAAM,GAAG,MAAM;IAcrD,KAAK,eAAS;IACd,SAAS,mBAAa;IACtB,OAAO,iBAAW;IAClB,QAAQ,kBAAY;IACpB,mBAAmB,6BAAuB;IAC1C,kBAAkB,4BAAsB;IACxC,WAAW,qBAAe;IAC1B,sBAAsB,gCAA0B;IAChD,qBAAqB,+BAAyB;IAC9C,YAAY,sBAAgB;IAC5B,qBAAqB,+BAAyB;IAC9C,oBAAoB,8BAAwB;CACtD"}

package/dist/core/api/v2/Parser.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Parser = void 0;
+const getModel_1 = require("../v2/parser/getModel");
+const getModelComposition_1 = require("./parser/getModelComposition");
+const getModelProperties_1 = require("./parser/getModelProperties");
+const getModels_1 = require("./parser/getModels");
+const getOperation_1 = require("./parser/getOperation");
+const getOperationParameter_1 = require("./parser/getOperationParameter");
+const getOperationParameters_1 = require("./parser/getOperationParameters");
+const getOperationResponse_1 = require("./parser/getOperationResponse");
+const getOperationResponses_1 = require("./parser/getOperationResponses");
+const getServices_1 = require("./parser/getServices");
+const getType_1 = require("./parser/getType");
+const parserV2_1 = require("./parserV2");
+class Parser {
+    _context;
+    constructor(context) {
+        this._context = context;
+    }
+    get context() {
+        return this._context;
+    }
+    getTypeNameByRef(value, ref) {
+        if (ref) {
+            const definition = this.context.get(ref);
+            if (definition.oneOf || definition.anyOf || definition.allOf || ['string', 'number', 'integer', 'boolean', 'array'].includes(definition.type)) {
+                return `${this.context.prefix.type}${value}`;
+            }
+            else if (definition.enum && definition !== 'boolean') {
+                return `${this.context.prefix.enum}${value}`;
+            }
+            else if (definition.type === 'object') {
+                return `${this.context.prefix.interface}${value}`;
+            }
+        }
+        return value;
+    }
+    parse = parserV2_1.parse;
+    getModels = getModels_1.getModels;
+    getType = getType_1.getType;
+    getModel = getModel_1.getModel;
+    getModelComposition = getModelComposition_1.getModelComposition;
+    getModelProperties = getModelProperties_1.getModelProperties;
+    getServices = getServices_1.getServices;
+    getOperationParameters = getOperationParameters_1.getOperationParameters;
+    getOperationParameter = getOperationParameter_1.getOperationParameter;
+    getOperation = getOperation_1.getOperation;
+    getOperationResponses = getOperationResponses_1.getOperationResponses;
+    getOperationResponse = getOperationResponse_1.getOperationResponse;
+}
+exports.Parser = Parser;

package/dist/core/api/v2/parser/__tests__/getServer.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getServer.test.d.ts.map

package/dist/core/api/v2/parser/__tests__/getServer.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getServer.test.d.ts","sourceRoot":"","sources":["../../../../../../src/core/api/v2/parser/__tests__/getServer.test.ts"],"names":[],"mappings":""}

package/dist/core/api/v2/parser/__tests__/getServer.test.js

@@ -0,0 +1,23 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const getServer_1 = require("../getServer");
+(0, node_test_1.describe)('getServer', () => {
+    (0, node_test_1.test)('@unit: should produce correct result', () => {
+        node_assert_1.default.strictEqual((0, getServer_1.getServer)({
+            swagger: '2.0',
+            info: {
+                title: 'dummy',
+                version: '1.0',
+            },
+            host: 'localhost:8080',
+            basePath: '/api',
+            schemes: ['http', 'https'],
+            paths: {},
+        }), 'http://localhost:8080/api');
+    });
+});

package/dist/core/api/v2/parser/__tests__/getType.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=getType.test.d.ts.map

package/dist/core/api/v2/parser/__tests__/getType.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getType.test.d.ts","sourceRoot":"","sources":["../../../../../../src/core/api/v2/parser/__tests__/getType.test.ts"],"names":[],"mappings":""}

package/dist/core/api/v2/parser/__tests__/getType.test.js

@@ -0,0 +1,61 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_assert_1 = __importDefault(require("node:assert"));
+const node_test_1 = require("node:test");
+const json_schema_ref_parser_1 = __importDefault(require("json-schema-ref-parser"));
+const Context_1 = require("../../../../Context");
+const getOutputPaths_1 = require("../../../../utils/getOutputPaths");
+const Parser_1 = require("../../Parser");
+(0, node_test_1.describe)('getType', () => {
+    (0, node_test_1.test)('@unit: should convert int', async () => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const parser = new json_schema_ref_parser_1.default();
+        const context = new Context_1.Context('test/spec/v3.yml', (0, getOutputPaths_1.getOutputPaths)({ output: './generated' }));
+        context.addRefs(await parser.resolve('test/spec/v3.yml'));
+        const type = new Parser_1.Parser(context).getType('int', '');
+        node_assert_1.default.strictEqual(type.type, 'number');
+        node_assert_1.default.strictEqual(type.base, 'number');
+        node_assert_1.default.strictEqual(type.template, null);
+        node_assert_1.default.deepStrictEqual(type.imports, []);
+    });
+    (0, node_test_1.test)('@unit: should support file with ext', async () => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const parser = new json_schema_ref_parser_1.default();
+        const context = new Context_1.Context('test/spec/v3.yml', (0, getOutputPaths_1.getOutputPaths)({ output: './generated' }));
+        context.addRefs(await parser.resolve('test/spec/v3.yml'));
+        const type = new Parser_1.Parser(context).getType('schemas/ModelWithString.yml', '');
+        node_assert_1.default.strictEqual(type.type, 'IModelWithString');
+        node_assert_1.default.strictEqual(type.base, 'IModelWithString');
+        node_assert_1.default.strictEqual(type.template, null);
+        node_assert_1.default.deepStrictEqual(type.imports, [
+            {
+                name: 'IModelWithString',
+                alias: '',
+                path: './schemas/ModelWithString',
+            },
+        ]);
+    });
+    const object = {
+        components: {
+            schemas: {
+                someSpecialSchema: {
+                    type: 'object',
+                },
+            },
+        },
+    };
+    (0, node_test_1.test)('@unit: should support external generation type', async () => {
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        const parser = new json_schema_ref_parser_1.default();
+        const context = new Context_1.Context(object, (0, getOutputPaths_1.getOutputPaths)({ output: './generated' }));
+        context.addRefs(await parser.resolve(object));
+        const type = new Parser_1.Parser(context).getType('#/components/schemas/someSpecialSchema', '');
+        node_assert_1.default.strictEqual(type.type, 'ISomeSpecialSchema');
+    });
+});

package/dist/core/api/v2/parser/getModel.d.ts

@@ -0,0 +1,5 @@
+import type { Model } from '../../../types/shared/Model.model';
+import { Parser } from '../Parser';
+import { ModelConfig } from '../types/ModelConfig.model';
+export declare function getModel(this: Parser, config: ModelConfig): Model;
+//# sourceMappingURL=getModel.d.ts.map

package/dist/core/api/v2/parser/getModel.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getModel.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getModel.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,mCAAmC,CAAC;AAM/D,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAC;AAEzD,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,KAAK,CAyJjE"}

package/dist/core/api/v2/parser/getModel.js

@@ -0,0 +1,154 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getModel = getModel;
+const extendEnum_1 = require("../../../utils/extendEnum");
+const getComment_1 = require("../../../utils/getComment");
+const getEnum_1 = require("../../../utils/getEnum");
+const getEnumFromDescription_1 = require("../../../utils/getEnumFromDescription");
+const getPattern_1 = require("../../../utils/getPattern");
+function getModel(config) {
+    const { openApi, definition, isDefinition = false, name = '', path = '', parentRef } = config;
+    const model = {
+        name,
+        path,
+        alias: '',
+        export: 'interface',
+        type: 'any',
+        base: 'any',
+        template: null,
+        link: null,
+        description: (0, getComment_1.getComment)(definition.description),
+        isDefinition,
+        isReadOnly: definition.readOnly === true,
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        isNullable: definition['x-nullable'] === true,
+        isRequired: definition.default !== undefined,
+        format: definition.format,
+        maximum: definition.maximum,
+        exclusiveMaximum: definition.exclusiveMaximum,
+        minimum: definition.minimum,
+        exclusiveMinimum: definition.exclusiveMinimum,
+        multipleOf: definition.multipleOf,
+        maxLength: definition.maxLength,
+        minLength: definition.minLength,
+        maxItems: definition.maxItems,
+        minItems: definition.minItems,
+        uniqueItems: definition.uniqueItems,
+        maxProperties: definition.maxProperties,
+        minProperties: definition.minProperties,
+        pattern: (0, getPattern_1.getPattern)(definition.pattern),
+        imports: [],
+        enum: [],
+        enums: [],
+        properties: [],
+    };
+    if (definition.$ref) {
+        const definitionRef = this.getType(definition.$ref, parentRef);
+        model.export = 'reference';
+        model.type = definitionRef.type;
+        model.base = definitionRef.base;
+        model.template = definitionRef.template;
+        model.imports.push(...definitionRef.imports);
+        return model;
+    }
+    if (definition.enum && definition.type !== 'boolean') {
+        const enumerators = (0, getEnum_1.getEnum)(definition.enum);
+        const extendedEnumerators = (0, extendEnum_1.extendEnum)(enumerators, definition);
+        if (extendedEnumerators.length) {
+            model.export = 'enum';
+            model.type = 'string';
+            model.base = 'string';
+            model.enum.push(...extendedEnumerators);
+            return model;
+        }
+    }
+    if ((definition.type === 'int' || definition.type === 'integer') && definition.description) {
+        const enumerators = (0, getEnumFromDescription_1.getEnumFromDescription)(definition.description);
+        if (enumerators.length) {
+            model.export = 'enum';
+            model.type = 'number';
+            model.base = 'number';
+            model.enum.push(...enumerators);
+            return model;
+        }
+    }
+    if (definition.type === 'array' && definition.items) {
+        if (definition.items.$ref) {
+            const arrayItems = this.getType(definition.items.$ref, parentRef);
+            model.export = 'array';
+            model.type = arrayItems.type;
+            model.base = arrayItems.base;
+            model.template = arrayItems.template;
+            model.imports.push(...arrayItems.imports);
+            return model;
+        }
+        else {
+            const arrayItems = this.getModel({ openApi: openApi, definition: definition.items, parentRef });
+            model.export = 'array';
+            model.type = arrayItems.type;
+            model.base = arrayItems.base;
+            model.template = arrayItems.template;
+            model.link = arrayItems;
+            model.imports.push(...arrayItems.imports);
+            return model;
+        }
+    }
+    if (definition.type === 'object' && typeof definition.additionalProperties === 'object') {
+        if (definition.additionalProperties.$ref) {
+            const additionalProperties = this.getType(definition.additionalProperties.$ref, parentRef);
+            model.export = 'dictionary';
+            model.type = additionalProperties.type;
+            model.base = additionalProperties.base;
+            model.template = additionalProperties.template;
+            model.imports.push(...additionalProperties.imports);
+            return model;
+        }
+        else {
+            const additionalProperties = this.getModel({ openApi: openApi, definition: definition.additionalProperties, parentRef });
+            model.export = 'dictionary';
+            model.type = additionalProperties.type;
+            model.base = additionalProperties.base;
+            model.template = additionalProperties.template;
+            model.link = additionalProperties;
+            model.imports.push(...additionalProperties.imports);
+            return model;
+        }
+    }
+    if (definition.allOf?.length) {
+        const composition = this.getModelComposition(openApi, definition, definition.allOf, 'all-of', parentRef);
+        model.export = composition.type;
+        model.imports.push(...composition.imports);
+        model.properties.push(...composition.properties);
+        model.enums.push(...composition.enums);
+        return model;
+    }
+    if (definition.type === 'object') {
+        model.export = 'interface';
+        model.type = 'any';
+        model.base = 'any';
+        if (definition.properties) {
+            const properties = this.getModelProperties(openApi, definition, parentRef);
+            properties.forEach(property => {
+                model.imports.push(...property.imports);
+                model.enums.push(...property.enums);
+                model.properties.push(property);
+                if (property.export === 'enum') {
+                    model.enums.push(property);
+                }
+            });
+        }
+        return model;
+    }
+    // If the schema has a type than it can be a basic or generic type.
+    if (definition.type) {
+        const definitionType = this.getType(definition.type, parentRef);
+        model.export = 'generic';
+        model.type = definitionType.type;
+        model.base = definitionType.base;
+        model.template = definitionType.template;
+        model.imports.push(...definitionType.imports);
+        return model;
+    }
+    return model;
+}

package/dist/core/api/v2/parser/getModelComposition.d.ts

@@ -0,0 +1,6 @@
+import type { ModelComposition } from '../../../types/shared/ModelComposition.model';
+import { Parser } from '../Parser';
+import type { OpenApi } from '../types/OpenApi.model';
+import type { OpenApiSchema } from '../types/OpenApiSchema.model';
+export declare function getModelComposition(this: Parser, openApi: OpenApi, definition: OpenApiSchema, definitions: OpenApiSchema[], type: 'one-of' | 'any-of' | 'all-of', parentRef: string): ModelComposition;
+//# sourceMappingURL=getModelComposition.d.ts.map

package/dist/core/api/v2/parser/getModelComposition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getModelComposition.d.ts","sourceRoot":"","sources":["../../../../../src/core/api/v2/parser/getModelComposition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AACrF,OAAO,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACnC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,wBAAwB,CAAC;AACtD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,8BAA8B,CAAC;AAElE,wBAAgB,mBAAmB,CAC/B,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,OAAO,EAChB,UAAU,EAAE,aAAa,EACzB,WAAW,EAAE,aAAa,EAAE,EAC5B,IAAI,EAAE,QAAQ,GAAG,QAAQ,GAAG,QAAQ,EACpC,SAAS,EAAE,MAAM,GAClB,gBAAgB,CAkDlB"}