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

package/dist/common/VersionedSchema/Utils/validateUnknownKeys.js

@@ -0,0 +1,32 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateUnknownKeys = validateUnknownKeys;
+const leven_1 = __importDefault(require("leven"));
+function validateUnknownKeys(rawInputKeys, allowed) {
+    const errors = [];
+    for (const key of rawInputKeys) {
+        if (!allowed.has(key)) {
+            let bestMatch = null;
+            let bestDistance = Infinity;
+            for (const candidate of allowed) {
+                const d = (0, leven_1.default)(key, candidate);
+                if (d < bestDistance) {
+                    bestDistance = d;
+                    bestMatch = candidate;
+                }
+            }
+            if (bestMatch && bestDistance <= 3) {
+                errors.push(`The "${key}" field is not recognized. Perhaps you meant "${bestMatch}".`);
+            }
+            else {
+                errors.push(`The "${key}" field is not recognized.`);
+            }
+        }
+    }
+    if (errors.length) {
+        throw new Error(errors.join('\n'));
+    }
+}

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

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

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

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

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

@@ -0,0 +1,227 @@
+"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 Utils_1 = require("common/Utils");
+(0, node_test_1.describe)('convertArrayToObject', () => {
+    (0, node_test_1.test)('@unit: Empty array', () => {
+        const input = [];
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        const expected = {
+            items: [],
+            exportCore: undefined,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            request: undefined,
+            useOptions: undefined,
+            useCancelableRequest: undefined,
+        };
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.test)('@unit: An array with one element', () => {
+        const input = [
+            {
+                input: 'url1',
+                output: 'res1',
+                exportCore: true,
+                request: 'req1',
+                useOptions: true,
+            },
+        ];
+        const expected = {
+            httpClient: undefined,
+            useOptions: true,
+            useUnionTypes: undefined,
+            exportCore: true,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            clean: undefined,
+            request: 'req1',
+            interfacePrefix: undefined,
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
+            items: [
+                {
+                    input: 'url1',
+                    output: 'res1',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+            ],
+        };
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.test)('@unit: Multiple elements with the same outer margins', () => {
+        const input = [
+            { input: 'url1', output: 'res1', exportCore: true, request: 'req1', useOptions: true },
+            { input: 'url2', output: 'res2', exportCore: true, request: 'req1', useOptions: true },
+        ];
+        const expected = {
+            httpClient: undefined,
+            useOptions: true,
+            useUnionTypes: undefined,
+            exportCore: true,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            clean: undefined,
+            request: 'req1',
+            interfacePrefix: undefined,
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
+            items: [
+                {
+                    input: 'url1',
+                    output: 'res1',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+                {
+                    input: 'url2',
+                    output: 'res2',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+            ],
+        };
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.test)('@unit: Multiple elements with different external margins', () => {
+        const input = [
+            { input: 'url1', output: 'res1', exportCore: true, request: 'req1', useOptions: true },
+            { input: 'url2', output: 'res2', exportCore: false, request: 'req2', useOptions: false },
+        ];
+        const expected = {
+            httpClient: undefined,
+            useOptions: true,
+            useUnionTypes: undefined,
+            exportCore: true,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            clean: undefined,
+            request: 'req1',
+            interfacePrefix: undefined,
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
+            items: [
+                {
+                    input: 'url1',
+                    output: 'res1',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+                {
+                    input: 'url2',
+                    output: 'res2',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+            ],
+        };
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.test)('@unit: No optional fields', () => {
+        const input = [
+            { input: 'url1', output: 'res1' },
+            { input: 'url2', output: 'res2' },
+        ];
+        const expected = {
+            httpClient: undefined,
+            useOptions: undefined,
+            useUnionTypes: undefined,
+            exportCore: undefined,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            clean: undefined,
+            request: undefined,
+            interfacePrefix: undefined,
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
+            items: [
+                {
+                    input: 'url1',
+                    output: 'res1',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+                {
+                    input: 'url2',
+                    output: 'res2',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+            ],
+        };
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+    (0, node_test_1.test)('@unit: Mixed presence of optional fields', () => {
+        const input = [
+            { input: 'url1', output: 'res1', exportCore: true },
+            { input: 'url2', output: 'res2', request: 'req2' },
+        ];
+        const expected = {
+            httpClient: undefined,
+            useOptions: undefined,
+            useUnionTypes: undefined,
+            exportCore: true,
+            exportServices: undefined,
+            exportModels: undefined,
+            exportSchemas: undefined,
+            clean: undefined,
+            request: undefined,
+            interfacePrefix: undefined,
+            enumPrefix: undefined,
+            typePrefix: undefined,
+            useCancelableRequest: undefined,
+            items: [
+                {
+                    input: 'url1',
+                    output: 'res1',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+                {
+                    input: 'url2',
+                    output: 'res2',
+                    outputCore: undefined,
+                    outputServices: undefined,
+                    outputModels: undefined,
+                    outputSchemas: undefined,
+                },
+            ],
+        };
+        const result = (0, Utils_1.convertArrayToObject)(input);
+        node_assert_1.default.deepStrictEqual(result, expected);
+    });
+});

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

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

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

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

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

@@ -0,0 +1,26 @@
+"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 OptionsVersionedSchemas_1 = require("common/VersionedSchema/OptionsVersionedSchemas");
+const core_1 = require("../../core");
+const guessVersion_1 = require("../VersionedSchema/Utils/guessVersion");
+(0, node_test_1.describe)('guessVersion', () => {
+    (0, node_test_1.test)('@unit: should correctly identify version for 1.0.0 data', () => {
+        const dataV1 = { input: 'source/path', output: 'generated/path', client: core_1.HttpClient.AXIOS };
+        const result = (0, guessVersion_1.guessVersion)(dataV1, OptionsVersionedSchemas_1.optionsVersionedSchemas);
+        node_assert_1.default.deepEqual(result, { version: '1.0.0', index: 0 }, 'Should detect 1.0.0 schema');
+    });
+    (0, node_test_1.test)('@unit: should correctly identify version for 2.0.0 data', () => {
+        const dataV2 = { input: 'source/path', output: 'generated/path', httpClient: core_1.HttpClient.FETCH };
+        const result = (0, guessVersion_1.guessVersion)(dataV2, OptionsVersionedSchemas_1.optionsVersionedSchemas);
+        node_assert_1.default.deepEqual(result, { version: '2.0.0', index: 2 }, 'Should detect 2.0.0 schema');
+    });
+    (0, node_test_1.test)('@unit: should throw error for data matching no schemas', () => {
+        const invalidData = { input: 'source/path', output: 'generated/path', unknownField: 'value' };
+        node_assert_1.default.throws(() => (0, guessVersion_1.guessVersion)(invalidData, OptionsVersionedSchemas_1.optionsVersionedSchemas), /Data does not conform to any known version schema/, 'Should throw for invalid data');
+    });
+});

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

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

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

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

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

@@ -0,0 +1,35 @@
+"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 joi_1 = __importDefault(require("joi"));
+const OptionsSchemaV2_1 = require("../VersionedSchema/OptionsSchemaV2");
+const mergeObjectSchemas_1 = require("../VersionedSchema/Utils/mergeObjectSchemas");
+(0, node_test_1.describe)('mergeObjectSchemas', () => {
+    (0, node_test_1.test)('@unit: should combine multiple schemas correctly', () => {
+        const schema1 = joi_1.default.object({ a: joi_1.default.string().required() });
+        const schema2 = joi_1.default.object({ b: joi_1.default.number().optional() });
+        const mergedSchema = (0, mergeObjectSchemas_1.mergeObjectSchemas)(schema1, schema2);
+        const validData = { a: 'test', b: 123 };
+        const invalidData = { a: 'test', b: 'not a number' };
+        node_assert_1.default.equal(mergedSchema.validate(validData).error, null, 'Valid data should pass validation');
+        node_assert_1.default.notEqual(mergedSchema.validate(invalidData).error, null, 'Invalid data should fail validation');
+    });
+    (0, node_test_1.test)('@unit: should work with real schemas from OptionSchemas', () => {
+        const validData = {
+            input: 'source/path',
+            httpClient: 'axios',
+            output: 'output/path',
+            useOptions: true,
+        };
+        const invalidData = {
+            input: 'source/path',
+            httpClient: 'invalid-client', // Некорректное значение для httpClient
+        };
+        node_assert_1.default.equal(OptionsSchemaV2_1.optionsSchemaV2.validate(validData).error, null, 'Valid data should pass optionsSchemaV2 validation');
+        node_assert_1.default.notEqual(OptionsSchemaV2_1.optionsSchemaV2.validate(invalidData).error, null, 'Invalid data should fail optionsSchemaV2 validation');
+    });
+});

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

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

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

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

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

@@ -0,0 +1,87 @@
+"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', () => {
+    (0, node_test_1.test)('@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: 'source/path' }, { input: 'source/path' }],
+        };
+        const expectedDataMultiV3 = {
+            httpClient: core_1.HttpClient.AXIOS,
+            items: [
+                { input: 'source/path', output: 'generated/path', outputCore: undefined, outputServices: undefined, outputModels: undefined, outputSchemas: undefined },
+                { input: 'source/path', output: 'generated/path', outputCore: undefined, outputServices: undefined, outputModels: undefined, outputSchemas: undefined },
+            ],
+            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');
+    });
+    (0, node_test_1.test)('@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: 'source/path', output: 'generated/path', outputCore: undefined, outputServices: undefined, outputModels: undefined, outputSchemas: undefined },
+                { input: 'source/path', output: 'generated/path', outputCore: undefined, outputServices: undefined, outputModels: undefined, outputSchemas: undefined },
+            ],
+        };
+        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 1.0.1 data to 2.0.0 correctly');
+    });
+    (0, node_test_1.test)('@unit: should throw error if not conform any known version schema', () => {
+        const dataMultiV1 = {
+            input: 'source/path',
+            output: 'generated/path',
+            client: 'invalid-client',
+            items: [{ input: 'item1' }, { input: 'item2' }],
+        };
+        node_assert_1.default.throws(() => {
+            (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+                rawInput: dataMultiV1,
+                versionedSchemas: MultiOptionsVersionedSchemas_1.multiOptionsVersionedSchema,
+                migrationPlans: MultiOptionsMigrationPlan_1.multiOptionsMigrationPlan,
+            });
+        }, /Data does not conform to any known version schema/, 'Should throw error if not conform any known version schema');
+    });
+    (0, node_test_1.test)('@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,63 @@
+"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');
+    });
+    (0, node_test_1.test)('@unit: should throw error if not conform any known version schema', () => {
+        const dataV1 = { input: 'source/path', output: 'generated/path', client: 'invalid-client' };
+        node_assert_1.default.throws(() => {
+            (0, migrateToLatestVersion_1.migrateToLatestVersion)({
+                rawInput: dataV1,
+                versionedSchemas: OptionsVersionedSchemas_1.optionsVersionedSchemas,
+                migrationPlans: OptionsMigrationPlans_1.optionsMigrationPlans,
+            });
+        }, /Data does not conform to any known version schema/, 'Should throw error if not conform any known version schema');
+    });
+    (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;AAItB,eAAO,MAAM,cAAc,uBA0BV,CAAC"}

package/dist/common/defaultOptions.js

@@ -0,0 +1,29 @@
+"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"));
+const Enums_1 = require("../core/types/Enums");
+exports.defaultOptions = joi_1.default.object({
+    input: joi_1.default.string().required(),
+    output: joi_1.default.string().required(),
+    httpClient: joi_1.default.string().valid(...Object.values(Enums_1.HttpClient)),
+    outputCore: joi_1.default.string().optional(),
+    outputServices: joi_1.default.string().optional(),
+    outputModels: joi_1.default.string().optional(),
+    outputSchemas: joi_1.default.string().optional(),
+    useOptions: joi_1.default.boolean().optional(),
+    useUnionTypes: joi_1.default.boolean().optional(),
+    exportCore: joi_1.default.boolean().optional(),
+    exportServices: joi_1.default.boolean().optional(),
+    exportModels: joi_1.default.boolean().optional(),
+    exportSchemas: joi_1.default.boolean().optional(),
+    clean: joi_1.default.boolean().optional(),
+    request: joi_1.default.string().optional(),
+    interfacePrefix: joi_1.default.string().optional(),
+    enumPrefix: joi_1.default.string().optional(),
+    typePrefix: joi_1.default.string().optional(),
+    useCancelableRequest: joi_1.default.boolean().optional(),
+}).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;