ts-openapi-codegen 2.1.0-beta.1 → 2.1.0-beta.10

package/dist/core/utils/__tests__/prepareDtoModels.test.js

@@ -81,7 +81,7 @@ const createInterfaceModel = (name, properties) => ({
         node_assert_1.default.strictEqual(profileProperty?.dtoToJSON, 'this.profile.toJSON()');
         const profilesProperty = preparedUser?.properties.find(prop => prop.name === 'profiles');
         node_assert_1.default.ok(profilesProperty);
-        node_assert_1.default.strictEqual(profilesProperty?.dtoType, 'IProfileDto[]');
+        node_assert_1.default.strictEqual(profilesProperty?.dtoType, 'IProfileDto[] | undefined');
         node_assert_1.default.strictEqual(profilesProperty?.rawType, 'IProfileRaw[]');
         node_assert_1.default.strictEqual(profilesProperty?.dtoInit, 'data.profiles ? fromArray(IProfileDto, data.profiles) : undefined');
         node_assert_1.default.strictEqual(profilesProperty?.dtoToJSON, 'this.profiles ? this.profiles.map(item => item.toJSON()) : undefined');
@@ -113,4 +113,171 @@ const createInterfaceModel = (name, properties) => ({
         node_assert_1.default.strictEqual(preparedUser?.dtoGetters?.[0].oldName, 'oldName');
         node_assert_1.default.strictEqual(preparedUser?.dtoGetters?.[0].newName, 'fullName');
     });
+    (0, node_test_1.test)('resolves one-of and dictionary property types', () => {
+        const tag = createPrimitiveModel('tag', 'string');
+        const tagRef = {
+            ...createPrimitiveModel('value', 'string'),
+            export: 'reference',
+            type: 'string',
+            isRequired: true,
+        };
+        const oneOfProp = {
+            ...createPrimitiveModel('payload', 'string | number'),
+            export: 'one-of',
+            properties: [createPrimitiveModel('a', 'string'), createPrimitiveModel('b', 'number')],
+            isRequired: true,
+        };
+        const dictProp = {
+            ...createPrimitiveModel('tags', 'Record<string, string>'),
+            export: 'dictionary',
+            link: tagRef,
+            isRequired: false,
+        };
+        const container = createInterfaceModel('IContainer', [oneOfProp, dictProp]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [container, tag],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const preparedContainer = prepared.models.find(model => model.name === 'IContainer');
+        const preparedOneOf = preparedContainer?.properties.find(prop => prop.name === 'payload');
+        const preparedDict = preparedContainer?.properties.find(prop => prop.name === 'tags');
+        node_assert_1.default.ok(preparedOneOf?.dtoType?.includes('|'));
+        node_assert_1.default.match(preparedDict?.dtoType ?? '', /Record<string, string>/);
+    });
+    (0, node_test_1.test)('resolves enum property types in dtoType', () => {
+        const statusEnum = {
+            ...createPrimitiveModel('Status', 'string'),
+            export: 'enum',
+            enum: [
+                { name: 'Active', value: "'active'", type: 'string', description: null },
+                { name: 'Inactive', value: "'inactive'", type: 'string', description: null },
+            ],
+        };
+        const statusProp = {
+            ...createPrimitiveModel('status', 'string'),
+            export: 'enum',
+            enum: statusEnum.enum,
+            isRequired: true,
+        };
+        const model = createInterfaceModel('IUser', [statusProp]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [model, statusEnum],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const property = prepared.models[0]?.properties[0];
+        node_assert_1.default.match(property?.dtoType ?? '', /active/);
+        node_assert_1.default.match(property?.dtoType ?? '', /inactive/);
+    });
+    (0, node_test_1.test)('uses optional toJSON for non-required reference properties', () => {
+        const profile = createInterfaceModel('IProfile', [createPrimitiveModel('bio', 'string')]);
+        const profileRef = {
+            ...createPrimitiveModel('profile', 'IProfile'),
+            export: 'reference',
+            type: 'IProfile',
+            isRequired: false,
+        };
+        const user = createInterfaceModel('IUser', [profileRef]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [user, profile],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const property = prepared.models.find(m => m.name === 'IUser')?.properties[0];
+        node_assert_1.default.match(property?.dtoInit ?? '', /\? new IProfileDto/);
+        node_assert_1.default.match(property?.dtoToJSON ?? '', /\? this.profile.toJSON/);
+    });
+    (0, node_test_1.test)('assigns unique raw/dto names for duplicate models with aliases', () => {
+        const ingredient1 = createInterfaceModel('IIngredient', [createPrimitiveModel('id', 'string')]);
+        ingredient1.path = 'components/schemas-v2/Ingredient';
+        const ingredient2 = createInterfaceModel('IIngredient', [createPrimitiveModel('pathwayId', 'string')]);
+        ingredient2.alias = 'IIngredient$2';
+        ingredient2.path = 'components/schemas/Ingredient';
+        const ref = {
+            ...createPrimitiveModel('items', 'IIngredient'),
+            export: 'reference',
+            type: 'IIngredient$2',
+            isRequired: true,
+        };
+        const container = createInterfaceModel('IContainer', [ref]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [container, ingredient1, ingredient2],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const prepared1 = prepared.models.find(model => model.name === 'IIngredient' && !model.alias);
+        const prepared2 = prepared.models.find(model => model.alias === 'IIngredient$2');
+        node_assert_1.default.strictEqual(prepared1?.rawName, 'IIngredientRaw');
+        node_assert_1.default.strictEqual(prepared1?.dtoName, 'IIngredientDto');
+        node_assert_1.default.strictEqual(prepared2?.rawName, 'IIngredient$2Raw');
+        node_assert_1.default.strictEqual(prepared2?.dtoName, 'IIngredient$2Dto');
+        const itemsProperty = prepared.models.find(model => model.name === 'IContainer')?.properties[0];
+        node_assert_1.default.strictEqual(itemsProperty?.rawType, 'IIngredient$2Raw');
+        node_assert_1.default.strictEqual(itemsProperty?.dtoType, 'IIngredient$2Dto');
+    });
+    (0, node_test_1.test)('adds undefined fallback for optional dto fields without defaults', () => {
+        const optionalProp = createPrimitiveModel('detail', 'string');
+        optionalProp.isRequired = false;
+        const model = createInterfaceModel('IProblem', [optionalProp]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [model],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const property = prepared.models[0]?.properties[0];
+        node_assert_1.default.match(property?.dtoType ?? '', /undefined/);
+        node_assert_1.default.strictEqual(property?.dtoInit, 'data.detail ?? undefined');
+    });
+    (0, node_test_1.test)('attaches dto getters for aliased duplicate models', () => {
+        const sequence = createInterfaceModel('ISequence', [createPrimitiveModel('pathwayId', 'string')]);
+        sequence.alias = 'ISequence$2';
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [sequence],
+            services: [],
+            miracles: [
+                {
+                    type: 'RENAME',
+                    oldPath: '$.components.schemas.Sequence.properties.pathway_id',
+                    newPath: '$.components.schemas.Sequence.properties.pathwayId',
+                    confidence: 1,
+                    status: 'confirmed',
+                    modelName: 'ISequence$2',
+                    oldProperty: 'pathway_id',
+                    newProperty: 'pathwayId',
+                },
+            ],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const preparedSequence = prepared.models.find(model => model.alias === 'ISequence$2');
+        node_assert_1.default.ok(preparedSequence?.dtoGetters);
+        node_assert_1.default.strictEqual(preparedSequence?.dtoGetters?.[0].oldName, 'pathway_id');
+        node_assert_1.default.strictEqual(preparedSequence?.dtoGetters?.[0].newName, 'pathwayId');
+    });
+    (0, node_test_1.test)('uses bracket accessor for quoted property names', () => {
+        const quotedProp = createPrimitiveModel("'weird-name'", 'string');
+        const model = createInterfaceModel('IQuoted', [quotedProp]);
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [model],
+            services: [],
+        };
+        const prepared = (0, prepareDtoModels_1.prepareDtoModels)(client);
+        const property = prepared.models[0]?.properties[0];
+        node_assert_1.default.strictEqual(property?.dtoInit, "data['weird-name'] ?? undefined");
+        node_assert_1.default.strictEqual(property?.dtoTarget, "['weird-name']");
+    });
 });

package/dist/core/utils/__tests__/registerHandlebarHelpers.test.js

@@ -39,8 +39,20 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const node_assert_1 = __importDefault(require("node:assert"));
 const node_test_1 = require("node:test");
 const Handlebars = __importStar(require("handlebars/runtime"));
+const header_1 = __importDefault(require("../../../templatesCompiled/client/partials/header"));
 const HttpClient_enum_1 = require("../../types/enums/HttpClient.enum");
 const registerHandlebarHelpers_1 = require("../registerHandlebarHelpers");
+const GENERATED_FILE_COMMENT = 'This file was automatically generated by the generator';
+function renderHeaderPartial(useBatchEslintFix) {
+    (0, registerHandlebarHelpers_1.registerHandlebarHelpers)({
+        httpClient: HttpClient_enum_1.HttpClient.FETCH,
+        useOptions: false,
+        useUnionTypes: false,
+        useBatchEslintFix,
+    });
+    Handlebars.registerPartial('header', Handlebars.template(header_1.default));
+    return Handlebars.partials['header']({});
+}
 (0, node_test_1.describe)('@unit: registerHandlebarHelpers', () => {
     (0, node_test_1.test)('should register the helpers', () => {
         (0, registerHandlebarHelpers_1.registerHandlebarHelpers)({
@@ -54,5 +66,20 @@ const registerHandlebarHelpers_1 = require("../registerHandlebarHelpers");
         node_assert_1.default.ok(helpers.some(item => item === 'containsSpaces'));
         node_assert_1.default.ok(helpers.some(item => item === 'union'));
         node_assert_1.default.ok(helpers.some(item => item === 'intersection'));
+        node_assert_1.default.ok(helpers.some(item => item === 'useBatchEslintFix'));
+    });
+    (0, node_test_1.test)('header partial includes generated-file comment and disable directives when batch ESLint is off', () => {
+        const output = renderHeaderPartial(false);
+        node_assert_1.default.match(output, new RegExp(GENERATED_FILE_COMMENT));
+        node_assert_1.default.match(output, /\/\* istanbul ignore file \*\//);
+        node_assert_1.default.match(output, /\/\* tslint:disable \*\//);
+        node_assert_1.default.match(output, /\/\* eslint-disable \*\//);
+    });
+    (0, node_test_1.test)('header partial omits disable directives when batch ESLint is on', () => {
+        const output = renderHeaderPartial(true);
+        node_assert_1.default.match(output, new RegExp(GENERATED_FILE_COMMENT));
+        node_assert_1.default.match(output, /\/\* istanbul ignore file \*\//);
+        node_assert_1.default.doesNotMatch(output, /tslint:disable/);
+        node_assert_1.default.doesNotMatch(output, /eslint-disable/);
     });
 });

package/dist/core/utils/__tests__/resolveClassesModeTypes.test.d.ts

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

package/dist/core/utils/__tests__/resolveClassesModeTypes.test.d.ts.map

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

package/dist/core/utils/__tests__/resolveClassesModeTypes.test.js

@@ -0,0 +1,111 @@
+"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 prepareDtoModels_1 = require("../prepareDtoModels");
+const resolveClassesModeTypes_1 = require("../resolveClassesModeTypes");
+const createArrayResult = (itemBase, itemPath) => ({
+    in: 'response',
+    name: '',
+    alias: '',
+    path: '',
+    code: 200,
+    description: null,
+    export: 'array',
+    type: itemBase,
+    base: itemBase,
+    template: null,
+    link: null,
+    isDefinition: false,
+    isReadOnly: false,
+    isRequired: false,
+    isNullable: false,
+    imports: [{ name: itemBase, alias: '', path: `./${itemPath}` }],
+    enum: [],
+    enums: [],
+    properties: [],
+});
+(0, node_test_1.describe)('@unit: resolveClassesModeTypes', () => {
+    (0, node_test_1.test)('resolves array result types and imports to aliased export names', () => {
+        const ingredientCanonical = {
+            name: 'IIngredient',
+            alias: '',
+            path: 'components/schemas-v2/Ingredient',
+            export: 'interface',
+            type: 'IIngredient',
+            base: 'IIngredient',
+            template: null,
+            link: null,
+            description: null,
+            isDefinition: true,
+            isReadOnly: false,
+            isRequired: false,
+            isNullable: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties: [],
+        };
+        const ingredient = {
+            name: 'IIngredient',
+            alias: 'IIngredient$2',
+            path: 'components/schemas/Ingredient',
+            export: 'interface',
+            type: 'IIngredient',
+            base: 'IIngredient',
+            template: null,
+            link: null,
+            description: null,
+            isDefinition: true,
+            isReadOnly: false,
+            isRequired: false,
+            isNullable: false,
+            imports: [],
+            enum: [],
+            enums: [],
+            properties: [],
+        };
+        const service = {
+            name: 'IngredientsService',
+            originName: 'Ingredients',
+            imports: [{ name: 'IIngredient', alias: '', path: './components/schemas/Ingredient' }],
+            operations: [
+                {
+                    service: 'IngredientsService',
+                    name: 'listSequenceIngredients',
+                    summary: null,
+                    description: null,
+                    deprecated: false,
+                    method: 'GET',
+                    path: '/sequences/{sequenceId}/ingredients',
+                    parameters: [],
+                    parametersPath: [],
+                    parametersQuery: [],
+                    parametersForm: [],
+                    parametersHeader: [],
+                    parametersCookie: [],
+                    parametersBody: null,
+                    imports: [],
+                    errors: [],
+                    results: [createArrayResult('IIngredient', 'components/schemas/Ingredient')],
+                    responseHeader: null,
+                    responseType: null,
+                },
+            ],
+        };
+        const client = {
+            version: '1.0.0',
+            server: 'http://localhost',
+            models: [ingredientCanonical, ingredient],
+            services: [service],
+        };
+        const prepared = (0, resolveClassesModeTypes_1.resolveClassesModeTypes)((0, prepareDtoModels_1.prepareDtoModels)(client));
+        const operation = prepared.services[0]?.operations[0];
+        node_assert_1.default.strictEqual(prepared.services[0]?.imports[0].name, 'IIngredient$2');
+        node_assert_1.default.strictEqual(operation?.results[0].base, 'IIngredient$2');
+        node_assert_1.default.strictEqual(operation?.results[0].type, 'IIngredient$2');
+    });
+});

package/dist/core/utils/__tests__/semanticChangesToDiffEntries.test.d.ts

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

package/dist/core/utils/__tests__/semanticChangesToDiffEntries.test.d.ts.map

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

package/dist/core/utils/__tests__/semanticChangesToDiffEntries.test.js

@@ -0,0 +1,68 @@
+"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 semanticChangesToDiffEntries_1 = require("../semanticChangesToDiffEntries");
+(0, node_test_1.describe)('@unit: semanticChangesToDiffEntries', () => {
+    (0, node_test_1.test)('maps property type change to legacy diff entry', () => {
+        const change = {
+            type: 'model.property.type.changed',
+            severity: 'breaking',
+            path: '#/components/schemas/User/properties/age',
+            message: 'Property "age" type changed',
+            from: 'string',
+            to: 'integer',
+        };
+        const [entry] = (0, semanticChangesToDiffEntries_1.semanticChangesToDiffEntries)([change]);
+        node_assert_1.default.strictEqual(entry.action, 'changed');
+        node_assert_1.default.strictEqual(entry.severity, 'breaking');
+        node_assert_1.default.strictEqual(entry.path, '$.components.schemas.User.properties.age.type');
+        node_assert_1.default.strictEqual(entry.from, 'string');
+        node_assert_1.default.strictEqual(entry.to, 'integer');
+        node_assert_1.default.strictEqual(entry.note, change.message);
+    });
+    (0, node_test_1.test)('maps operation removed with metadata payload', () => {
+        const change = {
+            type: 'operation.removed',
+            severity: 'breaking',
+            path: '#/paths/GET /pets',
+            message: 'Operation removed',
+            from: {
+                operationId: 'listPets',
+                summary: 'List pets',
+                tags: ['pets'],
+            },
+        };
+        const [entry] = (0, semanticChangesToDiffEntries_1.semanticChangesToDiffEntries)([change]);
+        node_assert_1.default.strictEqual(entry.action, 'removed');
+        node_assert_1.default.strictEqual(entry.path, "$.paths['/pets'].get");
+        node_assert_1.default.deepStrictEqual(entry.from, change.from);
+    });
+    (0, node_test_1.test)('maps required flag change via fromRequired/toRequired', () => {
+        const change = {
+            type: 'model.property.required.changed',
+            severity: 'breaking',
+            path: '#/components/schemas/User/required/email',
+            message: 'required changed',
+            fromRequired: false,
+            toRequired: true,
+        };
+        const [entry] = (0, semanticChangesToDiffEntries_1.semanticChangesToDiffEntries)([change]);
+        node_assert_1.default.strictEqual(entry.action, 'changed');
+        node_assert_1.default.strictEqual(entry.from, false);
+        node_assert_1.default.strictEqual(entry.to, true);
+    });
+    (0, node_test_1.test)('exposes semantic mapping helpers', () => {
+        node_assert_1.default.strictEqual((0, semanticChangesToDiffEntries_1.semanticChangeTypeToAction)('model.property.removed'), 'removed');
+        node_assert_1.default.strictEqual((0, semanticChangesToDiffEntries_1.semanticSeverityToDiffSeverity)('non-breaking'), 'warning');
+        node_assert_1.default.strictEqual((0, semanticChangesToDiffEntries_1.semanticChangeToJsonPath)({
+            type: 'model.property.type.changed',
+            severity: 'breaking',
+            path: '#/components/schemas/User/properties/age',
+            message: 'type',
+        }), '$.components.schemas.User.properties.age.type');
+    });
+});

package/dist/core/utils/__tests__/serviceHelpers.test.js

@@ -107,16 +107,15 @@ function createOperationResponse(overrides = {}) {
         const aliasByPath = new Map(service.imports.map(item => [item.path, item.alias]));
         const aliasA = aliasByPath.get('models/a/Foo');
         const aliasB = aliasByPath.get('models/b/Foo');
-        node_assert_1.default.ok(aliasA);
-        node_assert_1.default.ok(aliasB);
-        node_assert_1.default.notEqual(aliasA, aliasB);
-        node_assert_1.default.equal(paramFooA.base, aliasA);
-        node_assert_1.default.equal(paramFooA.type, aliasA);
-        node_assert_1.default.equal(paramFooBArray.base, aliasB);
-        node_assert_1.default.equal(paramFooBArray.type, aliasB);
-        node_assert_1.default.equal(paramFooBArray.link?.base, aliasB);
-        node_assert_1.default.equal(paramFooBArray.link?.type, aliasB);
-        node_assert_1.default.equal(operation.results[0].base, aliasB);
-        node_assert_1.default.equal(operation.results[0].type, aliasB);
+        node_assert_1.default.strictEqual(aliasA, '');
+        node_assert_1.default.strictEqual(aliasB, 'Foo$2');
+        node_assert_1.default.equal(paramFooA.base, 'Foo');
+        node_assert_1.default.equal(paramFooA.type, 'Foo');
+        node_assert_1.default.equal(paramFooBArray.base, 'Foo$2');
+        node_assert_1.default.equal(paramFooBArray.type, 'Foo$2');
+        node_assert_1.default.equal(paramFooBArray.link?.base, 'Foo$2');
+        node_assert_1.default.equal(paramFooBArray.link?.type, 'Foo$2');
+        node_assert_1.default.equal(operation.results[0].base, 'Foo$2');
+        node_assert_1.default.equal(operation.results[0].type, 'Foo$2');
     });
 });

package/dist/core/utils/__tests__/sortByRequiredExtended.test.js

@@ -14,24 +14,15 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
             (0, createOperationParameter_1.createOperationParameter)('optional', { isRequired: false }),
             (0, createOperationParameter_1.createOperationParameter)('required', { isRequired: true }),
             (0, createOperationParameter_1.createOperationParameter)('optional-with-default', { isRequired: false, default: 'def' }),
-            (0, createOperationParameter_1.createOperationParameter)('required-with-default', { isRequired: true, default: 'def' })
+            (0, createOperationParameter_1.createOperationParameter)('required-with-default', { isRequired: true, default: 'def' }),
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
-        node_assert_1.default.deepStrictEqual(sortedNames, [
-            'required',
-            'required-with-default',
-            'optional',
-            'optional-with-default'
-        ]);
+        node_assert_1.default.deepStrictEqual(sortedNames, ['required', 'required-with-default', 'optional', 'optional-with-default']);
     });
     // Comparison tests within groups
     (0, node_test_1.test)('must sort by name within the required group', () => {
-        const params = [
-            (0, createOperationParameter_1.createOperationParameter)('Beta', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('Gamma', { isRequired: true })
-        ];
+        const params = [(0, createOperationParameter_1.createOperationParameter)('Beta', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('Gamma', { isRequired: true })];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['Alpha', 'Beta', 'Gamma']);
@@ -40,18 +31,14 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
         const params = [
             (0, createOperationParameter_1.createOperationParameter)('Zeta', { isRequired: true, default: 'def' }),
             (0, createOperationParameter_1.createOperationParameter)('Beta', { isRequired: true, default: 'def' }),
-            (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true, default: 'def' })
+            (0, createOperationParameter_1.createOperationParameter)('Alpha', { isRequired: true, default: 'def' }),
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['Alpha', 'Beta', 'Zeta']);
     });
     (0, node_test_1.test)('it should sort by name within the optional group', () => {
-        const params = [
-            (0, createOperationParameter_1.createOperationParameter)('Second', { isRequired: false }),
-            (0, createOperationParameter_1.createOperationParameter)('First', { isRequired: false }),
-            (0, createOperationParameter_1.createOperationParameter)('Third', { isRequired: false })
-        ];
+        const params = [(0, createOperationParameter_1.createOperationParameter)('Second', { isRequired: false }), (0, createOperationParameter_1.createOperationParameter)('First', { isRequired: false }), (0, createOperationParameter_1.createOperationParameter)('Third', { isRequired: false })];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['First', 'Second', 'Third']);
@@ -60,7 +47,7 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
         const params = [
             (0, createOperationParameter_1.createOperationParameter)('Dog', { isRequired: false, default: 'def' }),
             (0, createOperationParameter_1.createOperationParameter)('Cat', { isRequired: false, default: 'def' }),
-            (0, createOperationParameter_1.createOperationParameter)('Bird', { isRequired: false, default: 'def' })
+            (0, createOperationParameter_1.createOperationParameter)('Bird', { isRequired: false, default: 'def' }),
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
@@ -73,7 +60,7 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
         ['required', 'optional-with-default'],
         ['required-with-default', 'optional'],
         ['required-with-default', 'optional-with-default'],
-        ['optional', 'optional-with-default']
+        ['optional', 'optional-with-default'],
     ];
     for (const [groupA, groupB] of groupPairs) {
         (0, node_test_1.test)(`must place "${groupA}" before "${groupB}"`, () => {
@@ -118,7 +105,7 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
             (0, createOperationParameter_1.createOperationParameter)('Gamma', { isRequired: false }), // optional
             (0, createOperationParameter_1.createOperationParameter)('Delta', { isRequired: true, default: 'def' }), // required-with-default
             (0, createOperationParameter_1.createOperationParameter)('Epsilon', { isRequired: false, default: 'def' }), // optional-with-default
-            (0, createOperationParameter_1.createOperationParameter)('Alpha2', { isRequired: true }) // required
+            (0, createOperationParameter_1.createOperationParameter)('Alpha2', { isRequired: true }), // required
         ];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
@@ -128,16 +115,12 @@ const sortByRequiredExtended_1 = require("../sortByRequiredExtended");
             'Delta', // required-with-default
             'Beta', // optional
             'Gamma', // optional
-            'Epsilon' // optional-with-default
+            'Epsilon', // optional-with-default
         ]);
     });
     // A test for borderline cases
     (0, node_test_1.test)('It must handle empty names correctly.', () => {
-        const params = [
-            (0, createOperationParameter_1.createOperationParameter)('', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('B', { isRequired: true }),
-            (0, createOperationParameter_1.createOperationParameter)('A', { isRequired: true })
-        ];
+        const params = [(0, createOperationParameter_1.createOperationParameter)('', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('B', { isRequired: true }), (0, createOperationParameter_1.createOperationParameter)('A', { isRequired: true })];
         params.sort(sortByRequiredExtended_1.sortByRequiredExtended);
         const sortedNames = params.map(p => p.name);
         node_assert_1.default.deepStrictEqual(sortedNames, ['', 'A', 'B']);

package/dist/core/utils/__tests__/templateRendering.test.d.ts

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

package/dist/core/utils/__tests__/templateRendering.test.d.ts.map

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