@gitbook/react-openapi 1.4.3 → 1.5.1

package/src/resolveOpenAPIOperation.test.ts

@@ -1,177 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-
-import { parseOpenAPI, traverse } from '@gitbook/openapi-parser';
-import { resolveOpenAPIOperation } from './resolveOpenAPIOperation';
-
-async function fetchFilesystem(url: string) {
-    const response = await fetch(url);
-    const text = await response.text();
-    const { filesystem } = await parseOpenAPI({ value: text, rootURL: url });
-    const transformedFs = await traverse(filesystem, async (node) => {
-        if ('description' in node && typeof node.description === 'string' && node.description) {
-            node['x-gitbook-description-html'] = node.description;
-        }
-        return node;
-    });
-    return transformedFs;
-}
-
-describe('#resolveOpenAPIOperation', () => {
-    it('should resolve refs', async () => {
-        const filesystem = await fetchFilesystem(
-            'https://petstore3.swagger.io/api/v3/openapi.json'
-        );
-        const resolved = await resolveOpenAPIOperation(filesystem, { method: 'put', path: '/pet' });
-
-        expect(resolved).toMatchObject({
-            servers: [
-                {
-                    url: '/api/v3',
-                },
-            ],
-            operation: {
-                tags: ['pet'],
-                summary: 'Update an existing pet.',
-                description: 'Update an existing pet by Id.',
-                requestBody: {
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'object',
-                                required: ['name', 'photoUrls'],
-                            },
-                        },
-                    },
-                },
-            },
-        });
-    });
-
-    it('should support yaml', async () => {
-        const filesystem = await fetchFilesystem(
-            'https://petstore3.swagger.io/api/v3/openapi.yaml'
-        );
-        const resolved = await resolveOpenAPIOperation(filesystem, { method: 'put', path: '/pet' });
-
-        expect(resolved).toMatchObject({
-            servers: [
-                {
-                    url: '/api/v3',
-                },
-            ],
-            operation: {
-                tags: ['pet'],
-                summary: 'Update an existing pet.',
-                description: 'Update an existing pet by Id.',
-                requestBody: {
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'object',
-                                required: ['name', 'photoUrls'],
-                            },
-                        },
-                    },
-                },
-            },
-        });
-    });
-
-    it('should resolve circular refs', async () => {
-        const filesystem = await fetchFilesystem('https://api.gitbook.com/openapi.json');
-        const resolved = await resolveOpenAPIOperation(filesystem, {
-            method: 'get',
-            path: '/spaces/{spaceId}/content/page/{pageId}',
-        });
-
-        expect(resolved).toMatchObject({
-            servers: [
-                {
-                    url: '{host}/v1',
-                },
-            ],
-            operation: {
-                operationId: 'getPageById',
-            },
-        });
-    });
-
-    it('should resolve to null if the method is not supported', async () => {
-        const filesystem = await fetchFilesystem(
-            'https://petstore3.swagger.io/api/v3/openapi.json'
-        );
-        const resolved = await resolveOpenAPIOperation(filesystem, {
-            method: 'dontexist',
-            path: '/pet',
-        });
-
-        expect(resolved).toBe(null);
-    });
-
-    it('should parse Swagger 2.0', async () => {
-        const filesystem = await fetchFilesystem('https://petstore.swagger.io/v2/swagger.json');
-        const resolved = await resolveOpenAPIOperation(filesystem, {
-            method: 'put',
-            path: '/pet',
-        });
-
-        expect(resolved).toMatchObject({
-            servers: [
-                {
-                    url: 'https://petstore.swagger.io/v2',
-                },
-                {
-                    url: 'http://petstore.swagger.io/v2',
-                },
-            ],
-            operation: {
-                tags: ['pet'],
-                summary: 'Update an existing pet',
-                description: '',
-                requestBody: {
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'object',
-                                required: ['name', 'photoUrls'],
-                            },
-                        },
-                    },
-                },
-            },
-        });
-    });
-
-    it('should resolve a ref with whitespace', async () => {
-        const filesystem = await fetchFilesystem(
-            ' https://petstore3.swagger.io/api/v3/openapi.json'
-        );
-        const resolved = await resolveOpenAPIOperation(filesystem, {
-            method: 'put',
-            path: '/pet',
-        });
-
-        expect(resolved).toMatchObject({
-            servers: [
-                {
-                    url: '/api/v3',
-                },
-            ],
-            operation: {
-                tags: ['pet'],
-                summary: 'Update an existing pet.',
-                description: 'Update an existing pet by Id.',
-                requestBody: {
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'object',
-                                required: ['name', 'photoUrls'],
-                            },
-                        },
-                    },
-                },
-            },
-        });
-    });
-});

package/src/resolveOpenAPIOperation.ts

@@ -1,151 +0,0 @@
-import { fromJSON, toJSON } from 'flatted';
-
-import type {
-    Filesystem,
-    OpenAPIV3,
-    OpenAPIV3_1,
-    OpenAPIV3xDocument,
-} from '@gitbook/openapi-parser';
-import { dereferenceFilesystem } from './dereference';
-import type { OpenAPIOperationData } from './types';
-import { checkIsReference } from './utils';
-
-export { fromJSON, toJSON };
-
-/**
- * Resolve an OpenAPI operation in a file and compile it to a more usable format.
- */
-export async function resolveOpenAPIOperation(
-    filesystem: Filesystem<OpenAPIV3xDocument>,
-    operationDescriptor: {
-        path: string;
-        method: string;
-    }
-): Promise<OpenAPIOperationData | null> {
-    const { path, method } = operationDescriptor;
-    const schema = await dereferenceFilesystem(filesystem);
-    let operation = getOperationByPathAndMethod(schema, path, method);
-
-    if (!operation) {
-        return null;
-    }
-
-    // Resolve common parameters
-    const commonParameters = getPathObjectParameter(schema, path);
-    if (commonParameters) {
-        operation = {
-            ...operation,
-            parameters: [...commonParameters, ...(operation.parameters ?? [])],
-        };
-    }
-
-    const servers = 'servers' in schema ? (schema.servers ?? []) : [];
-    const schemaSecurity = Array.isArray(schema.security)
-        ? schema.security
-        : schema.security
-          ? [schema.security]
-          : [];
-    const security: OpenAPIV3_1.SecurityRequirementObject[] = operation.security ?? schemaSecurity;
-
-    // If security includes an empty object, it means that the security is optional
-    const isOptionalSecurity = security.some((entry) => Object.keys(entry).length === 0);
-    const flatSecurities = flattenSecurities(security);
-
-    // Resolve securities
-    const securities: OpenAPIOperationData['securities'] = [];
-    for (const entry of flatSecurities) {
-        const securityKey = Object.keys(entry)[0];
-        if (securityKey) {
-            const securityScheme = schema.components?.securitySchemes?.[securityKey];
-            if (securityScheme && !checkIsReference(securityScheme)) {
-                securities.push([
-                    securityKey,
-                    {
-                        ...securityScheme,
-                        required: !isOptionalSecurity,
-                    },
-                ]);
-            }
-        }
-    }
-
-    return {
-        servers,
-        operation,
-        method,
-        path,
-        securities,
-        'x-codeSamples':
-            typeof schema['x-codeSamples'] === 'boolean' ? schema['x-codeSamples'] : undefined,
-        'x-hideTryItPanel':
-            typeof schema['x-hideTryItPanel'] === 'boolean'
-                ? schema['x-hideTryItPanel']
-                : undefined,
-    };
-}
-
-/**
- * Get a path object from its path.
- */
-function getPathObject(
-    schema: OpenAPIV3.Document | OpenAPIV3_1.Document,
-    path: string
-): OpenAPIV3.PathItemObject | OpenAPIV3_1.PathItemObject | null {
-    if (schema.paths?.[path]) {
-        return schema.paths[path];
-    }
-    return null;
-}
-
-/**
- * Resolve parameters from a path in an OpenAPI schema.
- */
-function getPathObjectParameter(
-    schema: OpenAPIV3.Document | OpenAPIV3_1.Document,
-    path: string
-):
-    | (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[]
-    | (OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject)[]
-    | null {
-    const pathObject = getPathObject(schema, path);
-    if (pathObject?.parameters) {
-        return pathObject.parameters;
-    }
-    return null;
-}
-
-/**
- * Get an operation by its path and method.
- */
-function getOperationByPathAndMethod(
-    schema: OpenAPIV3.Document | OpenAPIV3_1.Document,
-    path: string,
-    method: string
-): OpenAPIV3.OperationObject | null {
-    // Types are buffy for OpenAPIV3_1.OperationObject, so we use v3
-    const pathObject = getPathObject(schema, path);
-    if (!pathObject) {
-        return null;
-    }
-    const normalizedMethod = method.toLowerCase();
-    if (!pathObject[normalizedMethod]) {
-        return null;
-    }
-    return pathObject[normalizedMethod];
-}
-
-/**
- * Flatten security objects in case they are nested.
- * @example [{bearerAuth:[], basicAuth:[]}] => [{ bearerAuth: [] }, { basicAuth: [] }]
- */
-function flattenSecurities(security: OpenAPIV3.SecurityRequirementObject[]) {
-    if (!Array.isArray(security) || security.length === 0) {
-        return [];
-    }
-
-    return security.flatMap((securityObject) => {
-        return Object.entries(securityObject).map(([authType, config]) => ({
-            [authType]: config,
-        }));
-    });
-}

package/src/resolveOpenAPIWebhook.ts

@@ -1,99 +0,0 @@
-import { fromJSON, toJSON } from 'flatted';
-
-import type {
-    Filesystem,
-    OpenAPIV3,
-    OpenAPIV3_1,
-    OpenAPIV3xDocument,
-} from '@gitbook/openapi-parser';
-import { dereferenceFilesystem } from './dereference';
-import type { OpenAPIWebhookData } from './types';
-
-export { fromJSON, toJSON };
-
-/**
- * Resolve an OpenAPI webhook in a file and compile it to a more usable format.
- */
-export async function resolveOpenAPIWebhook(
-    filesystem: Filesystem<OpenAPIV3xDocument>,
-    webhookDescriptor: {
-        name: string;
-        method: string;
-    }
-): Promise<OpenAPIWebhookData | null> {
-    const { name, method } = webhookDescriptor;
-    const schema = await dereferenceFilesystem(filesystem);
-    let operation = getWebhookByNameAndMethod(schema, name, method);
-
-    if (!operation) {
-        return null;
-    }
-
-    // Resolve common parameters
-    const commonParameters = getPathObjectParameter(schema, name);
-    if (commonParameters) {
-        operation = {
-            ...operation,
-            parameters: [...commonParameters, ...(operation.parameters ?? [])],
-        };
-    }
-
-    const servers = 'servers' in schema ? (schema.servers ?? []) : [];
-
-    return {
-        servers,
-        operation,
-        method,
-        name,
-    };
-}
-
-/**
- * Get a path object from its path.
- */
-function getPathObject(
-    schema: OpenAPIV3.Document | OpenAPIV3_1.Document,
-    name: string
-): OpenAPIV3.PathItemObject | OpenAPIV3_1.PathItemObject | null {
-    if (schema.webhooks?.[name]) {
-        return schema.webhooks[name];
-    }
-    return null;
-}
-
-/**
- * Resolve parameters from a path in an OpenAPI schema.
- */
-function getPathObjectParameter(
-    schema: OpenAPIV3.Document | OpenAPIV3_1.Document,
-    path: string
-):
-    | (OpenAPIV3.ReferenceObject | OpenAPIV3.ParameterObject)[]
-    | (OpenAPIV3.ParameterObject | OpenAPIV3_1.ReferenceObject)[]
-    | null {
-    const pathObject = getPathObject(schema, path);
-    if (pathObject?.parameters) {
-        return pathObject.parameters;
-    }
-    return null;
-}
-
-/**
- * Get an operation by its path and method.
- */
-function getWebhookByNameAndMethod(
-    schema: OpenAPIV3.Document | OpenAPIV3_1.Document,
-    name: string,
-    method: string
-): OpenAPIV3.OperationObject | null {
-    // Types are buffy for OpenAPIV3_1.OperationObject, so we use v3
-    const pathObject = getPathObject(schema, name);
-    if (!pathObject) {
-        return null;
-    }
-    const normalizedMethod = method.toLowerCase();
-    if (!pathObject[normalizedMethod]) {
-        return null;
-    }
-    return pathObject[normalizedMethod];
-}

package/src/schemas/OpenAPISchemaItem.tsx

@@ -1,34 +0,0 @@
-'use client';
-
-import { SectionBody } from '../StaticSection';
-
-import type { OpenAPIV3 } from '@gitbook/openapi-parser';
-import { OpenAPIDisclosure } from '../OpenAPIDisclosure';
-import { OpenAPIRootSchema } from '../OpenAPISchemaServer';
-import { Section } from '../StaticSection';
-import type { OpenAPIClientContext } from '../context';
-import { getDisclosureLabel } from '../getDisclosureLabel';
-
-export function OpenAPISchemaItem(props: {
-    name: string;
-    schema: OpenAPIV3.SchemaObject;
-    context: OpenAPIClientContext;
-}) {
-    const { schema, context, name } = props;
-
-    return (
-        <OpenAPIDisclosure
-            className="openapi-schemas-disclosure"
-            key={name}
-            icon={context.icons.plus}
-            header={name}
-            label={(isExpanded) => getDisclosureLabel({ schema, isExpanded, context })}
-        >
-            <Section className="openapi-section-schemas">
-                <SectionBody>
-                    <OpenAPIRootSchema schema={schema} context={context} />
-                </SectionBody>
-            </Section>
-        </OpenAPIDisclosure>
-    );
-}

package/src/schemas/OpenAPISchemas.tsx

@@ -1,98 +0,0 @@
-import type { OpenAPISchema } from '@gitbook/openapi-parser';
-import clsx from 'clsx';
-import { OpenAPIExample } from '../OpenAPIExample';
-import { OpenAPIRootSchema } from '../OpenAPISchemaServer';
-import { StaticSection } from '../StaticSection';
-import {
-    type OpenAPIContextInput,
-    getOpenAPIClientContext,
-    resolveOpenAPIContext,
-} from '../context';
-import { t } from '../translate';
-import { getExampleFromSchema } from '../util/example';
-import { OpenAPISchemaItem } from './OpenAPISchemaItem';
-
-/**
- * OpenAPI Schemas component.
- */
-export function OpenAPISchemas(props: {
-    className?: string;
-    schemas: OpenAPISchema[];
-    context: OpenAPIContextInput;
-    /**
-     * Whether to show the schema directly if there is only one.
-     */
-    grouped?: boolean;
-}) {
-    const { schemas, context: contextInput, grouped, className } = props;
-
-    const firstSchema = schemas[0];
-
-    if (!firstSchema) {
-        return null;
-    }
-
-    const context = resolveOpenAPIContext(contextInput);
-    const clientContext = getOpenAPIClientContext(context);
-
-    // If there is only one model and we are not grouping, we show it directly.
-    if (schemas.length === 1 && !grouped) {
-        const title = `The ${firstSchema.name} object`;
-        return (
-            <div className={clsx('openapi-schemas', className)}>
-                <div className="openapi-summary" id={context.id}>
-                    {context.renderHeading({
-                        title,
-                        deprecated: Boolean(firstSchema.schema.deprecated),
-                        stability: firstSchema.schema['x-stability'],
-                    })}
-                </div>
-                <div className="openapi-columns">
-                    <div className="openapi-column-spec">
-                        <StaticSection
-                            className="openapi-parameters"
-                            header={t(context.translation, 'attributes')}
-                        >
-                            <OpenAPIRootSchema
-                                schema={firstSchema.schema}
-                                context={clientContext}
-                            />
-                        </StaticSection>
-                    </div>
-                    <div className="openapi-column-preview">
-                        <div className="openapi-column-preview-body">
-                            <div className="openapi-panel">
-                                <h4 className="openapi-panel-heading">{title}</h4>
-                                <div className="openapi-panel-body">
-                                    <OpenAPIExample
-                                        example={getExampleFromSchema({
-                                            schema: firstSchema.schema,
-                                        })}
-                                        context={context}
-                                        syntax="json"
-                                    />
-                                </div>
-                            </div>
-                        </div>
-                    </div>
-                </div>
-            </div>
-        );
-    }
-
-    // If there are multiple schemas, we use a disclosure group to show them all.
-    return (
-        <div className={clsx('openapi-schemas', className)}>
-            {schemas.map(({ name, schema }) => {
-                return (
-                    <OpenAPISchemaItem
-                        key={name}
-                        name={name}
-                        context={clientContext}
-                        schema={schema}
-                    />
-                );
-            })}
-        </div>
-    );
-}

package/src/schemas/index.ts

@@ -1,2 +0,0 @@
-export * from './OpenAPISchemas';
-export * from './resolveOpenAPISchemas';