@gitbook/react-openapi 1.4.2 → 1.5.1

package/src/translations/pt-br.ts

@@ -1,43 +0,0 @@
-export const pt_br = {
-    required: 'Obrigatório',
-    deprecated: 'Obsoleto',
-    deprecated_and_sunset_on: 'Esta operação está obsoleta e será descontinuada em ${1}.',
-    stability_experimental: 'Experimental',
-    stability_alpha: 'Alfa',
-    stability_beta: 'Beta',
-    copy_to_clipboard: 'Copiar para a área de transferência',
-    copied: 'Copiado',
-    no_content: 'Sem conteúdo',
-    unresolved_reference: 'Referência não resolvida',
-    circular_reference: 'Referência circular',
-    read_only: 'Somente leitura',
-    write_only: 'Somente escrita',
-    optional: 'Opcional',
-    min: 'Mín',
-    max: 'Máx',
-    nullable: 'Nulo',
-    body: 'Corpo',
-    payload: 'Carga útil',
-    headers: 'Headers',
-    header: 'Header',
-    authorizations: 'Autorizações',
-    responses: 'Respostas',
-    response: 'Resposta',
-    path_parameters: 'Parâmetros de rota',
-    query_parameters: 'Parâmetros de consulta',
-    header_parameters: 'Parâmetros de cabeçalho',
-    attributes: 'Atributos',
-    test_it: 'Testar',
-    information: 'Informação',
-    success: 'Sucesso',
-    redirect: 'Redirecionamento',
-    error: 'Erro',
-    show: 'Mostrar ${1}',
-    hide: 'Ocultar ${1}',
-    available_items: 'Itens disponíveis',
-    available_scopes: 'Scopes disponíveis',
-    properties: 'Propriedades',
-    or: 'ou',
-    and: 'e',
-    possible_values: 'Valores possíveis',
-};

package/src/translations/types.ts

@@ -1,7 +0,0 @@
-import type { en } from './en';
-
-export type TranslationKey = keyof typeof en;
-
-export type Translation = {
-    [key in TranslationKey]: string;
-};

package/src/translations/zh.ts

@@ -1,43 +0,0 @@
-export const zh = {
-    required: '必填',
-    deprecated: '已弃用',
-    deprecated_and_sunset_on: '此操作已弃用，将于 ${1} 停止使用。',
-    stability_experimental: '实验性',
-    stability_alpha: 'Alpha',
-    stability_beta: 'Beta',
-    copy_to_clipboard: '复制到剪贴板',
-    copied: '已复制',
-    no_content: '无内容',
-    unresolved_reference: '未解析的引用',
-    circular_reference: '循环引用',
-    read_only: '只读',
-    write_only: '只写',
-    optional: '可选',
-    min: '最小值',
-    max: '最大值',
-    nullable: '可为 null',
-    body: '请求体',
-    payload: '有效载荷',
-    headers: '头字段',
-    header: '头部',
-    authorizations: '授权',
-    responses: '响应',
-    response: '响应',
-    path_parameters: '路径参数',
-    query_parameters: '查询参数',
-    header_parameters: '头参数',
-    attributes: '属性',
-    test_it: '测试一下',
-    information: '信息',
-    success: '成功',
-    redirect: '重定向',
-    error: '错误',
-    show: '显示${1}',
-    hide: '隐藏${1}',
-    available_items: '可用项',
-    available_scopes: '可用范围',
-    properties: '属性',
-    or: '或',
-    and: '和',
-    possible_values: '可能的值',
-};

package/src/types.ts

@@ -1,46 +0,0 @@
-import type {
-    OpenAPICustomOperationProperties,
-    OpenAPICustomPrefillProperties,
-    OpenAPICustomSpecProperties,
-    OpenAPIV3,
-} from '@gitbook/openapi-parser';
-
-export type OpenAPIServerVariableWithCustomProperties = OpenAPIV3.ServerVariableObject &
-    OpenAPICustomPrefillProperties;
-
-/**
- * OpenAPI ServerObject type extended to provide x-gitbook prefill custom properties at the variable level.
- */
-export type OpenAPIServerWithCustomProperties = Omit<OpenAPIV3.ServerObject, 'variables'> & {
-    variables?: {
-        [variable: string]: OpenAPIServerVariableWithCustomProperties;
-    };
-} & OpenAPICustomPrefillProperties;
-
-export type OpenAPISecurityWithRequired = OpenAPIV3.SecuritySchemeObject &
-    OpenAPICustomPrefillProperties & { required?: boolean };
-
-export interface OpenAPIOperationData extends OpenAPICustomSpecProperties {
-    path: string;
-    method: string;
-
-    /** Servers to be used for this operation */
-    servers: OpenAPIServerWithCustomProperties[];
-
-    /** Spec of the operation */
-    operation: OpenAPIV3.OperationObject<OpenAPICustomOperationProperties>;
-
-    /** Securities that should be used for this operation */
-    securities: [string, OpenAPISecurityWithRequired][];
-}
-
-export interface OpenAPIWebhookData extends OpenAPICustomSpecProperties {
-    name: string;
-    method: string;
-
-    /** Servers to be used for this operation */
-    servers: OpenAPIV3.ServerObject[];
-
-    /** Spec of the webhook */
-    operation: OpenAPIV3.OperationObject<OpenAPICustomOperationProperties>;
-}

package/src/util/example.tsx

@@ -1,129 +0,0 @@
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import { OpenAPIExample } from '../OpenAPIExample';
-import type { OpenAPIContext } from '../context';
-import { generateSchemaExample } from '../generateSchemaExample';
-import { tString } from '../translate';
-import { checkIsReference } from '../utils';
-
-/**
- * Generate an example from a reference object.
- */
-export function getExampleFromReference(
-    ref: OpenAPIV3.ReferenceObject,
-    context: OpenAPIContext
-): OpenAPIV3.ExampleObject {
-    return {
-        summary: tString(context.translation, 'unresolved_reference'),
-        value: { $ref: ref.$ref },
-    };
-}
-
-/**
- * Get examples from a media type object.
- */
-export function getExamplesFromMediaTypeObject(args: {
-    mediaType: string;
-    mediaTypeObject: OpenAPIV3.MediaTypeObject;
-    context: OpenAPIContext;
-}): { key: string; example: OpenAPIV3.ExampleObject }[] {
-    const { mediaTypeObject, mediaType, context } = args;
-    if (mediaTypeObject.examples) {
-        return Object.entries(mediaTypeObject.examples).map(([key, example]) => {
-            return {
-                key,
-                example: checkIsReference(example)
-                    ? getExampleFromReference(example, context)
-                    : example,
-            };
-        });
-    }
-
-    if (mediaTypeObject.example) {
-        return [{ key: 'default', example: { value: mediaTypeObject.example } }];
-    }
-
-    if (mediaTypeObject.schema) {
-        if (mediaType === 'application/xml') {
-            // @TODO normally we should use the name of the schema but we don't have it
-            // fix it when we got the reference name
-            const root = mediaTypeObject.schema.xml?.name ?? 'object';
-            return [
-                {
-                    key: 'default',
-                    example: {
-                        value: {
-                            [root]: generateSchemaExample(mediaTypeObject.schema, {
-                                xml: mediaType === 'application/xml',
-                                mode: 'read',
-                            }),
-                        },
-                    },
-                },
-            ];
-        }
-        return [
-            {
-                key: 'default',
-                example: {
-                    value: generateSchemaExample(mediaTypeObject.schema, {
-                        mode: 'read',
-                    }),
-                },
-            },
-        ];
-    }
-    return [];
-}
-
-/**
- * Get example from a schema object.
- */
-export function getExampleFromSchema(args: {
-    schema: OpenAPIV3.SchemaObject;
-}): OpenAPIV3.ExampleObject {
-    const { schema } = args;
-
-    if (schema.example) {
-        return { value: schema.example };
-    }
-
-    return { value: generateSchemaExample(schema, { mode: 'read' }) };
-}
-
-/**
- * Get the examples from a media type object.
- */
-export function getExamples(props: {
-    mediaTypeObject: OpenAPIV3.MediaTypeObject;
-    mediaType: string;
-    context: OpenAPIContext;
-}) {
-    const { mediaTypeObject, mediaType, context } = props;
-    const examples = getExamplesFromMediaTypeObject({ mediaTypeObject, mediaType, context });
-    const syntax = getSyntaxFromMediaType(mediaType);
-
-    return examples.map((example) => {
-        return {
-            key: example.key,
-            label: example.example.summary || example.key,
-            body: (
-                <OpenAPIExample example={example.example} context={props.context} syntax={syntax} />
-            ),
-        };
-    });
-}
-
-/**
- * Get the syntax from a media type.
- */
-function getSyntaxFromMediaType(mediaType: string): string {
-    if (mediaType.includes('json')) {
-        return 'json';
-    }
-
-    if (mediaType === 'application/xml') {
-        return 'xml';
-    }
-
-    return 'text';
-}

package/src/util/server.test.ts

@@ -1,58 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import { getDefaultServerURL, interpolateServerURL } from './server';
-
-describe('#interpolateServerURL', () => {
-    it('interpolates the server URL with the default values of the variables', () => {
-        const server: OpenAPIV3.ServerObject = {
-            url: 'https://{username}.example.com/{basePath}',
-            variables: {
-                username: { default: 'user' },
-                basePath: { default: 'v1' },
-            },
-        };
-        const result = interpolateServerURL(server);
-        expect(result).toBe('https://user.example.com/v1');
-    });
-
-    it('returns the URL with placeholders if no variables are provided', () => {
-        const server: OpenAPIV3.ServerObject = {
-            url: 'https://{username}.example.com/{basePath}',
-        };
-        const result = interpolateServerURL(server);
-        expect(result).toBe('https://{username}.example.com/{basePath}');
-    });
-
-    it('returns the URL with mixed placeholders and default values', () => {
-        const server: OpenAPIV3.ServerObject = {
-            url: 'https://{username}.example.com/{basePath}',
-            variables: {
-                basePath: { default: 'v1' },
-            },
-        };
-        const result = interpolateServerURL(server);
-        expect(result).toBe('https://{username}.example.com/v1');
-    });
-});
-
-describe('#getDefaultServerURL', () => {
-    it('returns the default server URL', () => {
-        const servers: OpenAPIV3.ServerObject[] = [
-            {
-                url: 'https://{username}.example.com/{basePath}',
-                variables: {
-                    username: { default: 'user' },
-                    basePath: { default: 'v1' },
-                },
-            },
-        ];
-        const result = getDefaultServerURL(servers);
-        expect(result).toBe('https://user.example.com/v1');
-    });
-
-    it('returns empty string if no servers are provided', () => {
-        const servers: OpenAPIV3.ServerObject[] = [];
-        const result = getDefaultServerURL(servers);
-        expect(result).toBe('');
-    });
-});

package/src/util/server.ts

@@ -1,47 +0,0 @@
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-
-/**
- * Get the default URL for the server.
- */
-export function getDefaultServerURL(servers: OpenAPIV3.ServerObject[]): string {
-    const server = servers[0];
-    if (!server) {
-        // Return empty string if no server is found to display nothing
-        return '';
-    }
-
-    return interpolateServerURL(server);
-}
-
-/**
- * Interpolate the server URL with the default values of the variables.
- */
-export function interpolateServerURL(server: OpenAPIV3.ServerObject) {
-    const parts = parseServerURL(server?.url ?? '');
-
-    return parts
-        .map((part) => {
-            if (part.kind === 'text') {
-                return part.text;
-            }
-            return server.variables?.[part.name]?.default ?? `{${part.name}}`;
-        })
-        .join('');
-}
-
-function parseServerURL(url: string) {
-    const parts = url.split(/{([^}]+)}/g);
-    const result: Array<{ kind: 'variable'; name: string } | { kind: 'text'; text: string }> = [];
-    for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        if (!part) {
-            continue;
-        }
-        if (i % 2 === 0) {
-            result.push({ kind: 'text', text: part });
-        } else {
-            result.push({ kind: 'variable', name: part });
-        }
-    }
-    return result;
-}

package/src/util/tryit-prefill.test.ts

@@ -1,311 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import type { PrefillInputContextData } from '../OpenAPIPrefillContextProvider';
-import type { OpenAPIOperationData } from '../types';
-import { resolveTryItPrefillForOperation } from './tryit-prefill';
-
-describe('resolveTryItPrefillForOperation', () => {
-    describe('prefill authentication info', () => {
-        it('should resolve prefill for bearer token scheme', () => {
-            const operation: OpenAPIOperationData = {
-                path: '/orgs/<orgId>/spaces/<spaceId>',
-                method: 'GET',
-                operation: { summary: 'Get space by ID' },
-                servers: [{ url: 'https://api.gitbook.com/v1/' }],
-                securities: [
-                    [
-                        'apiTokenScheme',
-                        {
-                            type: 'http',
-                            scheme: 'bearer',
-                            'x-gitbook-prefill': '{{ visitor.claims.apiToken }}',
-                        },
-                    ],
-                ],
-            };
-
-            const prefillInputContext: PrefillInputContextData = {
-                visitor: { claims: { apiToken: 'gb_api_testToken' } },
-            };
-
-            const result = resolveTryItPrefillForOperation({
-                operation,
-                prefillInputContext,
-            });
-
-            expect(result).toEqual({
-                authentication: {
-                    securitySchemes: {
-                        apiTokenScheme: { token: 'gb_api_testToken' },
-                    },
-                },
-            });
-        });
-
-        it('should resolve prefill for basic auth scheme', () => {
-            const operation: OpenAPIOperationData = {
-                path: '/orgs/<orgId>/spaces',
-                method: 'PUT',
-                operation: { summary: 'Create space in an org' },
-                servers: [{ url: 'https://api.gitbook.com/v1/' }],
-                securities: [
-                    [
-                        'basicAuthScheme',
-                        {
-                            type: 'http',
-                            scheme: 'basic',
-                            'x-gitbook-prefill': '{{ visitor.claims.basicAuth }}',
-                        },
-                    ],
-                ],
-            };
-
-            const prefillInputContext: PrefillInputContextData = {
-                visitor: { claims: { basicAuth: 'testuser:testpassword' } },
-            };
-
-            const result = resolveTryItPrefillForOperation({
-                operation,
-                prefillInputContext,
-            });
-
-            expect(result).toEqual({
-                authentication: {
-                    securitySchemes: {
-                        basicAuthScheme: { username: 'testuser', password: 'testpassword' },
-                    },
-                },
-            });
-        });
-
-        it('should resolve prefill for apiKey scheme', () => {
-            const operation: OpenAPIOperationData = {
-                path: '/orgs/<orgId>/spaces/<spaceId>',
-                method: 'POST',
-                operation: { summary: 'Update space by ID' },
-                servers: [{ url: 'https://api.gitbook.com/v1/' }],
-                securities: [
-                    [
-                        'apiKeyHeader',
-                        {
-                            type: 'apiKey',
-                            in: 'header',
-                            name: 'X-API-KEY',
-                            'x-gitbook-prefill': '{{ visitor.claims.apiKey }}',
-                        },
-                    ],
-                ],
-            };
-
-            const prefillInputContext: PrefillInputContextData = {
-                visitor: { claims: { apiKey: 'key-123' } },
-            };
-
-            const result = resolveTryItPrefillForOperation({
-                operation,
-                prefillInputContext,
-            });
-
-            expect(result).toEqual({
-                authentication: {
-                    securitySchemes: {
-                        apiKeyHeader: { name: 'X-API-KEY', in: 'header', value: 'key-123' },
-                    },
-                },
-            });
-        });
-
-        it('should return empty object if no visitor data matches prefill expression', () => {
-            const operation: OpenAPIOperationData = {
-                path: '/orgs/<orgId>/spaces',
-                method: 'GET',
-                operation: { summary: 'List all spaces in an org' },
-                servers: [{ url: 'https://api.gitbook.com/v1/' }],
-                securities: [
-                    [
-                        'bearer',
-                        {
-                            type: 'http',
-                            scheme: 'bearer',
-                            'x-gitbook-prefill': '{{ visitor.claims.missing }}',
-                        },
-                    ],
-                ],
-            };
-
-            const prefillInputContext: PrefillInputContextData = {
-                visitor: { claims: {} },
-            };
-
-            const result = resolveTryItPrefillForOperation({
-                operation,
-                prefillInputContext,
-            });
-
-            expect(result).toEqual({});
-        });
-    });
-
-    describe('prefill server info', () => {
-        it('should prefill server at url level', () => {
-            const operation: OpenAPIOperationData = {
-                path: '/orgs/<orgId>/spaces',
-                method: 'GET',
-                operation: { summary: 'List spaces in an org' },
-                servers: [
-                    {
-                        url: 'https://api.gitbook.com/v1/',
-                        description: 'GitBook API endpoint',
-                        'x-gitbook-prefill': '{{ visitor.claims.api.endpointUrl }}',
-                    },
-                ],
-                securities: [],
-            };
-
-            const prefillInputContext: PrefillInputContextData = {
-                visitor: {
-                    claims: { api: { endpointUrl: 'https://api.gitbook-staging.com/v1/' } },
-                },
-            };
-
-            const result = resolveTryItPrefillForOperation({
-                operation,
-                prefillInputContext,
-            });
-
-            expect(result).toEqual({
-                servers: [
-                    {
-                        url: 'https://api.gitbook-staging.com/v1/',
-                        description: 'GitBook API endpoint',
-                    },
-                ],
-            });
-        });
-
-        it('should prefill server at variables level', () => {
-            const operation: OpenAPIOperationData = {
-                path: '/orgs/<orgId>/spaces',
-                method: 'GET',
-                operation: { summary: 'List spaces in an org' },
-                servers: [
-                    {
-                        url: 'https://api.{domain}/{version}/',
-                        description: 'Versioned API endpoint by environment',
-                        variables: {
-                            domain: {
-                                default: 'gitbook.com',
-                                'x-gitbook-prefill':
-                                    '{{ visitor.claims.api.env === "staging" ?  "gitbook-staging.com" : "gitbook.com" }}',
-                            },
-                            version: {
-                                default: 'v1',
-                                'x-gitbook-prefill': '{{ visitor.claims.api.version }}',
-                            },
-                        },
-                    },
-                ],
-                securities: [],
-            };
-
-            // Override env
-            const overrideEnvResult = resolveTryItPrefillForOperation({
-                operation,
-                prefillInputContext: { visitor: { claims: { api: { env: 'staging' } } } },
-            });
-            expect(overrideEnvResult).toEqual({
-                servers: [
-                    {
-                        url: 'https://api.{domain}/{version}/',
-                        description: 'Versioned API endpoint by environment',
-                        variables: {
-                            domain: { default: 'gitbook-staging.com' },
-                            version: { default: 'v1' },
-                        },
-                    },
-                ],
-            });
-
-            // Override version
-            const overrideVersionResult = resolveTryItPrefillForOperation({
-                operation,
-                prefillInputContext: { visitor: { claims: { api: { version: 'v2' } } } },
-            });
-            expect(overrideVersionResult).toEqual({
-                servers: [
-                    {
-                        url: 'https://api.{domain}/{version}/',
-                        description: 'Versioned API endpoint by environment',
-                        variables: {
-                            domain: { default: 'gitbook.com' },
-                            version: { default: 'v2' },
-                        },
-                    },
-                ],
-            });
-
-            // Override both
-            const overrideBoth = resolveTryItPrefillForOperation({
-                operation,
-                prefillInputContext: {
-                    visitor: { claims: { api: { env: 'staging', version: 'v2' } } },
-                },
-            });
-            expect(overrideBoth).toEqual({
-                servers: [
-                    {
-                        url: 'https://api.{domain}/{version}/',
-                        description: 'Versioned API endpoint by environment',
-                        variables: {
-                            domain: { default: 'gitbook-staging.com' },
-                            version: { default: 'v2' },
-                        },
-                    },
-                ],
-            });
-        });
-
-        it('should ignore server prefill when no matching visitor data', () => {
-            const operation: OpenAPIOperationData = {
-                path: '/orgs/<orgId>/spaces',
-                method: 'GET',
-                operation: { summary: 'List spaces in an org' },
-                servers: [
-                    {
-                        url: 'https://api.{domain}/{version}/',
-                        description: 'Versioned API endpoint by environment',
-                        variables: {
-                            domain: {
-                                default: 'gitbook.com',
-                                'x-gitbook-prefill':
-                                    '{{ visitor.claims.api.env === "staging" ?  "gitbook-staging.com" : "gitbook.com" }}',
-                            },
-                            version: {
-                                default: 'v1',
-                                'x-gitbook-prefill': '{{ visitor.claims.api.version }}',
-                            },
-                        },
-                    },
-                ],
-                securities: [],
-            };
-
-            const result = resolveTryItPrefillForOperation({
-                operation,
-                prefillInputContext: { visitor: { claims: { isBetaUser: true } } },
-            });
-
-            expect(result).toEqual({
-                servers: [
-                    {
-                        url: 'https://api.{domain}/{version}/',
-                        description: 'Versioned API endpoint by environment',
-                        variables: {
-                            domain: { default: 'gitbook.com' },
-                            version: { default: 'v1' },
-                        },
-                    },
-                ],
-            });
-        });
-    });
-});