@redocly/openapi-docs 3.24.0-next.9 → 3.24.1

package/lib/models/__tests__/example.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/models/__tests__/example.test.js

@@ -0,0 +1,90 @@
+import { getExamples } from '../example.js';
+import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
+describe('Models', () => {
+    describe('getExamples', () => {
+        const testDefinition = {
+            openapi: '3.2.0',
+            info: {
+                title: 'Test API',
+                version: '1.0.0',
+            },
+            paths: {},
+        };
+        const opts = normalizeOptions({});
+        const parser = new OpenAPIParser(testDefinition, undefined, opts);
+        describe('OpenAPI 3.2 field priority', () => {
+            it('should prioritize dataValue over serializedValue and value', () => {
+                const exampleInput = {
+                    dataValue: { foo: 'bar', count: 42 },
+                    serializedValue: '{"foo":"baz"}',
+                    value: { foo: 'old' },
+                };
+                const result = getExamples({
+                    parser,
+                    infoOrRef: exampleInput,
+                    mime: 'application/json',
+                });
+                expect(result.value).toEqual({ foo: 'bar', count: 42 });
+                expect(result.rawValue).toEqual({ foo: 'bar', count: 42 });
+            });
+            it('should prioritize serializedValue over value when dataValue is absent', () => {
+                const exampleInput = {
+                    serializedValue: 'flag=true',
+                    value: { flag: false },
+                };
+                const result = getExamples({
+                    parser,
+                    infoOrRef: exampleInput,
+                    mime: 'application/x-www-form-urlencoded',
+                });
+                expect(result.value).toBe('flag=true');
+                expect(result.rawValue).toBe('flag=true');
+            });
+            it('should use value for backward compatibility when dataValue and serializedValue are absent', () => {
+                const exampleInput = {
+                    value: { name: 'John', age: 30 },
+                };
+                const result = getExamples({
+                    parser,
+                    infoOrRef: exampleInput,
+                    mime: 'application/json',
+                });
+                expect(result.value).toEqual({ name: 'John', age: 30 });
+                expect(result.rawValue).toEqual({ name: 'John', age: 30 });
+            });
+        });
+        describe('dataValue handling', () => {
+            it('should handle dataValue with objects and arrays', () => {
+                const objectExample = getExamples({
+                    parser,
+                    infoOrRef: { value: {}, dataValue: { author: 'A. Writer', title: 'Book' } },
+                    mime: 'application/json',
+                });
+                const arrayExample = getExamples({
+                    parser,
+                    infoOrRef: { value: [], dataValue: [1, 2, 3] },
+                    mime: 'application/json',
+                });
+                expect(objectExample.value).toEqual({ author: 'A. Writer', title: 'Book' });
+                expect(arrayExample.value).toEqual([1, 2, 3]);
+            });
+        });
+        describe('serializedValue handling', () => {
+            it('should handle serializedValue with different formats', () => {
+                const urlEncodedExample = getExamples({
+                    parser,
+                    infoOrRef: { value: '', serializedValue: 'name=John+Doe&age=30' },
+                    mime: 'application/x-www-form-urlencoded',
+                });
+                const xmlExample = getExamples({
+                    parser,
+                    infoOrRef: { value: '', serializedValue: '<user><name>John</name></user>' },
+                    mime: 'application/xml',
+                });
+                expect(urlEncodedExample.value).toBe('name=John+Doe&age=30');
+                expect(xmlExample.value).toBe('<user><name>John</name></user>');
+            });
+        });
+    });
+});
+//# sourceMappingURL=example.test.js.map

package/lib/models/__tests__/group.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/models/__tests__/group.test.js

@@ -0,0 +1,52 @@
+import { describe, it, expect } from 'vitest';
+import { getTagOrGroup } from '../group.js';
+import { joinWithSeparator } from '../../services/index.js';
+import { safeSlugify } from '../../utils/index.js';
+describe('getTagOrGroup', () => {
+    describe('ID generation - new branch for tag/group types', () => {
+        it('should use joinWithSeparator for tag type with parent id', () => {
+            const parent = {
+                id: 'parent-id',
+                href: '/parent',
+                name: 'Parent',
+                type: 'tag',
+                items: [],
+                depth: 0,
+                level: 1,
+            };
+            const tag = {
+                name: 'test-tag',
+            };
+            const result = getTagOrGroup('tag', tag, parent);
+            const expectedId = joinWithSeparator(parent.id, safeSlugify(tag.name));
+            expect(result.id).toBe(expectedId.toLowerCase());
+        });
+    });
+    describe('Name priority - summary first', () => {
+        it('should prioritize summary over x-displayName and name', () => {
+            const tag = {
+                name: 'fallback-name',
+                summary: 'summary-name',
+                'x-displayName': 'display-name',
+            };
+            const result = getTagOrGroup('tag', tag);
+            expect(result.name).toBe('summary-name');
+        });
+        it('should fallback to x-displayName when summary is not present', () => {
+            const tag = {
+                name: 'fallback-name',
+                'x-displayName': 'display-name',
+            };
+            const result = getTagOrGroup('tag', tag);
+            expect(result.name).toBe('display-name');
+        });
+        it('should fallback to name when summary and x-displayName are not present', () => {
+            const tag = {
+                name: 'fallback-name',
+            };
+            const result = getTagOrGroup('tag', tag);
+            expect(result.name).toBe('fallback-name');
+        });
+    });
+});
+//# sourceMappingURL=group.test.js.map

package/lib/models/__tests__/helpers.d.ts

@@ -0,0 +1,5 @@
+import type { SchemaModel } from '../types';
+export declare function circularDetailsPrinter(schema: SchemaModel): string;
+export declare function enumDetailsPrinter(schema: SchemaModel): string;
+export declare function printSchema(schema: SchemaModel, detailsPrinter?: (schema: SchemaModel) => string, identLevel?: number, inline?: boolean): string;
+export declare const replaceCircularJson: () => (_: unknown, value: unknown) => unknown;

package/lib/models/__tests__/helpers.js

@@ -0,0 +1,62 @@
+function printType(type) {
+    return `<${type}>`;
+}
+function printDescription(description) {
+    return description ? ` (${description})` : '';
+}
+export function circularDetailsPrinter(schema) {
+    return schema.isCircular ? ' !circular' : '';
+}
+export function enumDetailsPrinter(schema) {
+    return schema.enum ? `enum: [${schema.enum.toString()}]` : '';
+}
+export function printSchema(schema, detailsPrinter = () => '', identLevel = 0, inline = false) {
+    if (!schema)
+        return '';
+    const ident = '  '.repeat(identLevel);
+    if (schema.isPrimitive || schema.isCircular) {
+        if (schema.type === 'array' && schema.items) {
+            return `${inline ? ' ' : ident}[${printType(schema.items.type)}${detailsPrinter(schema.items)}]${printDescription(schema.items.description)}`;
+        }
+        else {
+            return `${inline ? ' ' : ident}${printType(schema.displayType)}${detailsPrinter(schema)}${printDescription(schema.description)}`;
+        }
+    }
+    if (schema.oneOf) {
+        return (`${inline ? ' ' : ident}oneOf\n` +
+            schema.oneOf
+                .map((sub) => {
+                return (`${ident}  ${sub.title || sub.displayType} ->` +
+                    printSchema(sub, detailsPrinter, identLevel + 2, true));
+            })
+                .join('\n'));
+    }
+    if (schema.fields) {
+        const prefix = inline ? '\n' : '';
+        return (prefix +
+            schema.fields
+                .map((f) => {
+                return `${ident}${f.name}${f.required ? '*' : ''}:${printSchema(f.schema, detailsPrinter, identLevel + 1, true)}`;
+            })
+                .join('\n'));
+    }
+    if (schema.items) {
+        return (`${inline ? ' ' : ident}[\n` +
+            printSchema(schema.items, detailsPrinter, identLevel) +
+            `\n${inline ? ident.slice(0, -2) : ident}]`);
+    }
+    return ' error';
+}
+export const replaceCircularJson = () => {
+    const visited = new WeakSet();
+    return (_, value) => {
+        if (typeof value === 'object' && value !== null) {
+            if (visited.has(value)) {
+                return;
+            }
+            visited.add(value);
+        }
+        return value;
+    };
+};
+//# sourceMappingURL=helpers.js.map

package/lib/models/__tests__/request.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/models/__tests__/request.test.js

@@ -0,0 +1,119 @@
+import { parseYaml } from '@redocly/openapi-core';
+import { outdent } from 'outdent';
+import { getRequestBody } from '../request.js';
+import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
+const opts = normalizeOptions({});
+describe('request', () => {
+    describe('getRequestBody', () => {
+        let parser, props;
+        beforeEach(() => {
+            parser = new OpenAPIParser({ openapi: '3.0.0' }, undefined, opts);
+            props = {
+                parser,
+                infoOrRef: {},
+                options: opts,
+                isEvent: false,
+            };
+        });
+        test('should work with default props', () => {
+            const consoleError = vi.spyOn(global.console, 'error');
+            const req = getRequestBody(props);
+            expect(consoleError).not.toHaveBeenCalled();
+            expect(req).toEqual({ description: '', required: undefined });
+        });
+        test('should work with set required', () => {
+            const consoleError = vi.spyOn(global.console, 'error');
+            props.infoOrRef.required = false;
+            const req = getRequestBody(props);
+            expect(consoleError).not.toHaveBeenCalled();
+            expect(req).toEqual({ description: '', required: false });
+        });
+        test('should have correct field property when it includes allOf', () => {
+            const spec = parseYaml(outdent `
+          openapi: 3.0.0
+          paths:
+            /user:
+              post:
+                tags:
+                  - user
+                summary: Create user
+                description: This can only be done by the logged in user.
+                operationId: createUser
+                requestBody:
+                  content:
+                    application/json:
+                      schema:
+                        $ref: '#/components/schemas/User'
+                  description: Created user object
+                  required: true
+          components:
+            schemas:
+              User:
+                allOf:
+                  - type: object
+                    properties:
+                      name:
+                        type: string
+                        description: correct description name
+                        readOnly: false
+                        writeOnly: false
+                        allOf:
+                          - $ref: '#/components/schemas/NameField'
+              NameField:
+                description: name description
+                readOnly: true
+                writeOnly: true
+          `);
+            parser = new OpenAPIParser(spec, undefined, opts);
+            const req = getRequestBody({
+                parser,
+                infoOrRef: spec.paths['/user'].post.requestBody,
+                options: opts,
+                isEvent: false,
+                operation: {},
+            });
+            expect(req.content?.mediaTypes[0].schema?.fields?.[0].schema.readOnly).toBe(false);
+            expect(req.content?.mediaTypes[0].schema?.fields?.[0].schema.writeOnly).toBe(false);
+            expect(req.content?.mediaTypes[0].schema?.fields?.[0].description).toMatchInlineSnapshot(`"correct description name"`);
+        });
+        test('should dereference $ref in requestBody content to components/mediaTypes (OpenAPI 3.2)', () => {
+            const spec = parseYaml(outdent `
+        openapi: 3.2.0
+        info:
+          title: Test
+          version: 1.0.0
+        paths:
+          /test:
+            post:
+              operationId: test
+              requestBody:
+                required: true
+                content:
+                  $ref: '#/components/mediaTypes/PatchRequest'
+              responses:
+                '204':
+                  description: No content
+        components:
+          mediaTypes:
+            PatchRequest:
+              application/json:
+                schema:
+                  type: string
+      `);
+            parser = new OpenAPIParser(spec, undefined, opts);
+            const req = getRequestBody({
+                parser,
+                infoOrRef: spec.paths['/test'].post.requestBody,
+                options: opts,
+                isEvent: false,
+                operation: { pointer: '#/paths/~1test/post' },
+            });
+            expect(req.required).toBe(true);
+            expect(req.content).toBeDefined();
+            expect(req.content?.mediaTypes).toHaveLength(1);
+            expect(req.content?.mediaTypes[0].name).toBe('application/json');
+            expect(req.content?.mediaTypes[0].schema?.type).toBe('string');
+        });
+    });
+});
+//# sourceMappingURL=request.test.js.map

package/lib/services/__tests__/OpenAPIParser.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/__tests__/OpenAPIParser.test.js

@@ -0,0 +1,80 @@
+import { OpenAPIParser } from '../OpenAPIParser.js';
+import { normalizeOptions } from '../config-options/index.js';
+const opts = normalizeOptions({});
+describe('Models', () => {
+    describe('Schema', () => {
+        let parser;
+        test('should hoist oneOfs when mergin allOf', async () => {
+            const spec = (await import('./fixtures/oneOfHoist.json'))
+                .default;
+            parser = new OpenAPIParser(spec, undefined, opts);
+            expect(parser.mergeAllOf(spec.components?.schemas?.test)).toMatchSnapshot();
+        });
+        test('should not crash on self-referencing array in allOf', async () => {
+            const spec = (await import('./fixtures/allOfSelfReferencingArray.json'))
+                .default;
+            parser = new OpenAPIParser(spec, undefined, opts);
+            expect(parser.mergeAllOf(spec.components?.schemas?.Test)).toMatchSnapshot();
+        });
+        test('should get schema name from named schema', async () => {
+            const spec = (await import('./fixtures/mergeAllOf.json'))
+                .default;
+            parser = new OpenAPIParser(spec, undefined, opts);
+            const schema = parser.mergeAllOf(spec.components?.schemas?.Case1, '#/components/schemas/Case1');
+            expect(schema.title).toEqual('Case1');
+        });
+        test('should get schema name from first allOf', async () => {
+            const spec = (await import('./fixtures/mergeAllOf.json'))
+                .default;
+            parser = new OpenAPIParser(spec, undefined, opts);
+            const Case2 = spec.components?.schemas?.Case2;
+            const schema = parser.mergeAllOf(Case2.properties.a, '#components/schemas/Case2/properties/a');
+            expect(schema.title).toEqual('Bar');
+        });
+        test('should get schema name from named schema in allOf', async () => {
+            const spec = (await import('./fixtures/mergeAllOf.json'))
+                .default;
+            parser = new OpenAPIParser(spec, undefined, opts);
+            const schema = parser.mergeAllOf(spec.components?.schemas?.Case3?.schemas?.Foo, '#components/schemas/Case3/schemas/Foo');
+            expect(schema.title).toEqual('Foo');
+        });
+        test('should merge oneOf to inside allOff', async () => {
+            // TODO: should hoist
+            const spec = (await import('./fixtures/mergeAllOf.json'))
+                .default;
+            parser = new OpenAPIParser(spec, undefined, opts);
+            const schema = parser.mergeAllOf(spec.components?.schemas?.Case4);
+            expect(schema.title).toEqual('Foo');
+            expect(schema['x-parentRefs']).toHaveLength(1);
+            expect(schema['x-parentRefs'][0]).toEqual('#/components/schemas/Ref');
+            expect(schema.oneOf).toEqual([{ title: 'Bar' }, { title: 'Baz' }]);
+        });
+        test('should preserve discriminated union when OAS 3.1 mergeRefs wraps $ref in allOf', async () => {
+            const spec = (await import('./fixtures/discriminatorWithSiblingRef.json'))
+                .default;
+            parser = new OpenAPIParser(spec, undefined, opts);
+            const merged = parser.mergeAllOf(spec.components?.schemas?.WithSiblingRef, '#/components/schemas/WithSiblingRef');
+            const expectedDiscriminator = (spec.components?.schemas).Discriminated.discriminator;
+            expect(merged.discriminator).toEqual(expectedDiscriminator);
+            expect(merged.oneOf).toHaveLength(2);
+            expect(merged.oneOf?.[0]).toMatchObject({ $ref: '#/components/schemas/OptionA' });
+            expect(merged.oneOf?.[1]).toMatchObject({ $ref: '#/components/schemas/OptionB' });
+        });
+        test('should preserve discriminated union for the same allOf on OAS 3.0 (no mergeRefs)', async () => {
+            const loaded = (await import('./fixtures/discriminatorWithSiblingRef.json'))
+                .default;
+            const spec = {
+                ...loaded,
+                openapi: '3.0.3',
+            };
+            parser = new OpenAPIParser(spec, undefined, opts);
+            const merged = parser.mergeAllOf(spec.components?.schemas?.WithSiblingRef, '#/components/schemas/WithSiblingRef');
+            const expectedDiscriminator = (spec.components?.schemas).Discriminated.discriminator;
+            expect(merged.discriminator).toEqual(expectedDiscriminator);
+            expect(merged.oneOf).toHaveLength(2);
+            expect(merged.oneOf?.[0]).toMatchObject({ $ref: '#/components/schemas/OptionA' });
+            expect(merged.oneOf?.[1]).toMatchObject({ $ref: '#/components/schemas/OptionB' });
+        });
+    });
+});
+//# sourceMappingURL=OpenAPIParser.test.js.map

package/lib/services/__tests__/check.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/__tests__/check.test.js

@@ -0,0 +1,22 @@
+import { isHostAllowed } from '../check.js';
+describe('license check', () => {
+    test('isHostAllowed should work properly', () => {
+        expect(isHostAllowed('', [])).toBe(false);
+        expect(isHostAllowed('dummyHost', [])).toBe(false);
+        expect(isHostAllowed('localhost', [])).toBe(true);
+        expect(isHostAllowed('.localhost', [])).toBe(true);
+        expect(isHostAllowed('127.0.0.1', [])).toBe(true);
+        expect(isHostAllowed('acme.com', ['acme.com'])).toBe(true);
+        expect(isHostAllowed('sub.acme.com', ['acme.com'])).toBe(true);
+        expect(isHostAllowed('fakeacme.com', ['acme.com'])).toBe(false);
+        expect(isHostAllowed('fakeacme.com', ['.acme.com'])).toBe(false);
+        expect(isHostAllowed('acme.com', ['acme*'])).toBe(false);
+        expect(isHostAllowed('acme.app.com', ['acme*com'])).toBe(false);
+        expect(isHostAllowed('acme.app.com', ['acme*acme.com'])).toBe(false);
+        expect(isHostAllowed('start-fakeAcmeVercel.com', ['start*Vercel.com'])).toBe(false);
+        expect(isHostAllowed('start-middle-end.vercel.com', ['start*end.vercel.com'])).toBe(true);
+        expect(isHostAllowed('start-acme.vercel.com', ['start*.vercel.com'])).toBe(true);
+        expect(isHostAllowed('api-acme.vercel.com', ['*acme.vercel.com'])).toBe(true);
+    });
+});
+//# sourceMappingURL=check.test.js.map

package/lib/services/__tests__/utils.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/__tests__/utils.test.js

@@ -0,0 +1,42 @@
+import { isSameMime, normalizeMimeType, unescapeServerVariables, arrayMergeStrategy, } from '../utils.js';
+describe('services utils', () => {
+    test('isSameMime should equal mime', () => {
+        expect(isSameMime('application/json;charset', 'application/json;charset=UTF-8')).toBeTruthy();
+        expect(isSameMime('app/json;charset', 'application/json;charset=UTF-8')).toBeFalsy();
+        expect(isSameMime('app/json;charset', '')).toBeFalsy();
+    });
+    test('normalizeMimeType should return correct value', () => {
+        expect(normalizeMimeType('application/json;charset')).toBe('application/json');
+        expect(normalizeMimeType('')).toBeUndefined();
+        expect(normalizeMimeType('application')).toBe('application');
+    });
+    test('unescapeServerVariables should return string with escaped brackets', () => {
+        expect(unescapeServerVariables('https://%7BsomeVar%7D/dev/echo/case-11_1')).toBe('https://{someVar}/dev/echo/case-11_1');
+        expect(unescapeServerVariables('https://{someVar}/dev/echo/case-11_1')).toBe('https://{someVar}/dev/echo/case-11_1');
+        expect(unescapeServerVariables('https://api./{someVar}/dev/echo/case-11_1')).toBe('https://api.{someVar}/dev/echo/case-11_1');
+    });
+    test('arrayMergeStrategy should leave the second array value if two arrays of primitives provided', () => {
+        expect(arrayMergeStrategy(['test1'], ['test2'])).toEqual(['test2']);
+    });
+    test('arrayMergeStrategy should leave the second array value if two arrays of primitives with different length provided', () => {
+        expect(arrayMergeStrategy(['test1', 'test2'], ['test3'])).toEqual(['test3']);
+    });
+    test('arrayMergeStrategy should merge two arrays of arrays into one', () => {
+        expect(arrayMergeStrategy([['test1']], [['test2']])).toEqual([['test1'], ['test2']]);
+    });
+    test('arrayMergeStrategy should merge two arrays of objects into one', () => {
+        expect(arrayMergeStrategy([{ id: 0, name: 'test1' }], [{ name: 'test2' }])).toEqual([
+            { id: 0, name: 'test2' },
+        ]);
+    });
+    test('arrayMergeStrategy should merge two arrays of objects even if the first array is empty', () => {
+        expect(arrayMergeStrategy([], [{ name: 'test1' }])).toEqual([{ name: 'test1' }]);
+    });
+    test('arrayMergeStrategy should merge two arrays of of objects of a different length', () => {
+        expect(arrayMergeStrategy([{ id: 0, name: 'test1' }], [{ name: 'test2' }, { id: 1, name: 'test3' }])).toEqual([
+            { id: 0, name: 'test2' },
+            { id: 1, name: 'test3' },
+        ]);
+    });
+});
+//# sourceMappingURL=utils.test.js.map

package/lib/services/code-samples/__tests__/apply-environments.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/code-samples/__tests__/apply-environments.test.js

@@ -0,0 +1,64 @@
+import { applyEnvironments } from '../apply-environments.js';
+describe('applyEnvironments', () => {
+    it('returns the same array when there are no env variables', () => {
+        const samples = [{ lang: 'curl', source: 'curl {{host}}' }];
+        expect(applyEnvironments(samples, undefined)).toBe(samples);
+    });
+    it('returns the same array when there are no samples', () => {
+        const samples = [];
+        expect(applyEnvironments(samples, { values: { host: 'example.com' } })).toBe(samples);
+    });
+    it('returns the same array when env values are empty', () => {
+        const samples = [{ source: 'curl {{host}}' }];
+        expect(applyEnvironments(samples, { values: {} })).toBe(samples);
+    });
+    it('substitutes {{var}} placeholders from env values', () => {
+        const [result] = applyEnvironments([{ source: 'curl https://{{host}}/v1' }], {
+            values: { host: 'api.example.com' },
+        });
+        expect(result.source).toBe('curl https://api.example.com/v1');
+    });
+    it('keeps the original placeholder when no env value matches', () => {
+        const [result] = applyEnvironments([{ source: 'curl {{missing}}' }], {
+            values: { host: 'api.example.com' },
+        });
+        expect(result.source).toBe('curl {{missing}}');
+    });
+    it('overrides defaults with server-specific values for the current server', () => {
+        const envVariables = {
+            values: { token: 'default-token' },
+            serverValues: { 'https://prod.example.com': { token: 'prod-token' } },
+        };
+        const [result] = applyEnvironments([{ source: '{{token}}' }], envVariables, {
+            server: 'https://prod.example.com',
+        });
+        expect(result.source).toBe('prod-token');
+    });
+    it('uses default values when the current server has no overrides', () => {
+        const envVariables = {
+            values: { token: 'default-token' },
+            serverValues: { 'https://prod.example.com': { token: 'prod-token' } },
+        };
+        const [result] = applyEnvironments([{ source: '{{token}}' }], envVariables, {
+            server: 'https://staging.example.com',
+        });
+        expect(result.source).toBe('default-token');
+    });
+    it('leaves entries without a string source untouched (reused across sample shapes)', () => {
+        const samples = [
+            { source: '{{host}}' },
+            { label: 'no source' },
+            { source: 42 },
+        ];
+        const result = applyEnvironments(samples, { values: { host: 'api.example.com' } });
+        expect(result[0].source).toBe('api.example.com');
+        expect(result[1]).toEqual({ label: 'no source' });
+        expect(result[2]).toEqual({ source: 42 });
+    });
+    it('does not mutate the original samples', () => {
+        const samples = [{ source: '{{host}}' }];
+        applyEnvironments(samples, { values: { host: 'api.example.com' } });
+        expect(samples[0].source).toBe('{{host}}');
+    });
+});
+//# sourceMappingURL=apply-environments.test.js.map

package/lib/services/code-samples/__tests__/build-code-samples.test.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/services/code-samples/__tests__/build-code-samples.test.js

@@ -0,0 +1,70 @@
+import { vi } from 'vitest';
+vi.mock('../generator.js', () => ({
+    getCodeSample: vi.fn(),
+}));
+import { buildCodeSamples } from '../build-code-samples.js';
+import { getCodeSample } from '../generator.js';
+const mockGetCodeSample = vi.mocked(getCodeSample);
+const translate = ((key) => key);
+const definition = {};
+function buildOptions(languages) {
+    return {
+        codeSamples: { languages, skipOptionalParameters: false, withOAuth2Call: false },
+        generatedSamplesMaxDepth: 1,
+    };
+}
+function buildOperation(partial) {
+    return { definitionSamples: [], isWebhook: false, ...partial };
+}
+describe('buildCodeSamples', () => {
+    beforeEach(() => {
+        mockGetCodeSample.mockReset();
+        mockGetCodeSample.mockImplementation((params) => `generated:${params.lang}`);
+    });
+    it('generates a sample for each configured language, in order', () => {
+        const result = buildCodeSamples(buildOperation({}), buildOptions([{ lang: 'curl' }, { lang: 'Python' }]), definition, {}, translate);
+        expect(result).toEqual([
+            { lang: 'curl', label: undefined, source: 'generated:curl' },
+            { lang: 'Python', label: undefined, source: 'generated:Python' },
+        ]);
+    });
+    it('prefers definition (x-codeSamples) samples over generating the same language', () => {
+        const result = buildCodeSamples(buildOperation({ definitionSamples: [{ lang: 'curl', source: 'curl from definition' }] }), buildOptions([{ lang: 'curl' }, { lang: 'Python' }]), definition, {}, translate);
+        expect(result).toEqual([
+            { lang: 'curl', source: 'curl from definition' },
+            { lang: 'Python', label: undefined, source: 'generated:Python' },
+        ]);
+        expect(mockGetCodeSample).toHaveBeenCalledTimes(1);
+        expect(mockGetCodeSample).toHaveBeenCalledWith(expect.objectContaining({ lang: 'Python' }));
+    });
+    it('skips the Payload language when generating samples', () => {
+        const result = buildCodeSamples(buildOperation({}), buildOptions([{ lang: 'curl' }, { lang: 'Payload' }]), definition, {}, translate);
+        expect(result.map((sample) => sample.lang)).toEqual(['curl']);
+    });
+    it('does not generate samples for webhooks', () => {
+        const result = buildCodeSamples(buildOperation({
+            isWebhook: true,
+            definitionSamples: [{ lang: 'curl', source: 'curl from definition' }],
+        }), buildOptions([{ lang: 'curl' }, { lang: 'Python' }]), definition, {}, translate);
+        expect(result).toEqual([{ lang: 'curl', source: 'curl from definition' }]);
+        expect(mockGetCodeSample).not.toHaveBeenCalled();
+    });
+    it('sorts the combined samples by the configured language order', () => {
+        const result = buildCodeSamples(buildOperation({ definitionSamples: [{ lang: 'Python', source: 'py from definition' }] }), buildOptions([{ lang: 'curl' }, { lang: 'Python' }, { lang: 'Go' }]), definition, {}, translate);
+        expect(result.map((sample) => sample.lang)).toEqual(['curl', 'Python', 'Go']);
+    });
+    it('filters out samples with an empty source', () => {
+        mockGetCodeSample.mockReturnValue('');
+        const result = buildCodeSamples(buildOperation({ definitionSamples: [{ lang: 'curl', source: 'curl from definition' }] }), buildOptions([{ lang: 'curl' }, { lang: 'Python' }]), definition, {}, translate);
+        // curl comes from the definition (non-empty); the generated Python sample is empty -> dropped
+        expect(result.map((sample) => sample.lang)).toEqual(['curl']);
+    });
+    it('applies environment variables to definition samples (reuses applyEnvironments)', () => {
+        const result = buildCodeSamples(buildOperation({
+            definitionSamples: [{ lang: 'curl', source: 'curl https://{{host}}/v1' }],
+            envVariables: { values: { host: 'api.example.com' } },
+        }), buildOptions([{ lang: 'curl' }]), definition, { environment: 'prod', environments: { prod: {} } }, translate);
+        expect(result[0].source).toBe('curl https://api.example.com/v1');
+    });
+});
+//# sourceMappingURL=build-code-samples.test.js.map

package/lib/services/code-samples/__tests__/convertSampleToString.test.d.ts

@@ -0,0 +1 @@
+export {};