@gitbook/react-openapi 0.7.0 → 1.0.0

package/src/fetchOpenAPIOperation.ts

@@ -1,230 +0,0 @@
-import { toJSON, fromJSON } from 'flatted';
-import { OpenAPIV3 } from 'openapi-types';
-import YAML from 'yaml';
-import swagger2openapi, { ConvertOutputOptions } from 'swagger2openapi';
-
-import { resolveOpenAPIPath } from './resolveOpenAPIPath';
-import { OpenAPIFetcher } from './types';
-
-export interface OpenAPIOperationData extends OpenAPICustomSpecProperties {
-    path: string;
-    method: string;
-
-    /** Servers to be used for this operation */
-    servers: OpenAPIV3.ServerObject[];
-
-    /** Spec of the operation */
-    operation: OpenAPIV3.OperationObject & OpenAPICustomOperationProperties;
-
-    /** Securities that should be used for this operation */
-    securities: [string, OpenAPIV3.SecuritySchemeObject][];
-}
-
-/**
- * Custom properties that can be defined at the entire spec level.
- */
-export interface OpenAPICustomSpecProperties {
-    /**
-     * If `true`, code samples will not be displayed.
-     * This option can be used to hide code samples for the entire spec.
-     */
-    'x-codeSamples'?: boolean;
-
-    /**
-     * If `true`, the "Try it" button will not be displayed.
-     * This option can be used to hide code samples for the entire spec.
-     */
-    'x-hideTryItPanel'?: boolean;
-}
-
-/**
- * Custom properties that can be defined at the operation level.
- * These properties are not part of the OpenAPI spec.
- */
-export interface OpenAPICustomOperationProperties {
-    'x-code-samples'?: OpenAPICustomCodeSample[];
-    'x-codeSamples'?: OpenAPICustomCodeSample[] | false;
-    'x-custom-examples'?: OpenAPICustomCodeSample[];
-
-    /**
-     * If `true`, the "Try it" button will not be displayed.
-     * https://redocly.com/docs/api-reference-docs/specification-extensions/x-hidetryitpanel/
-     */
-    'x-hideTryItPanel'?: boolean;
-}
-
-/**
- * Custom code samples that can be defined at the operation level.
- * It follows the spec defined by Redocly.
- * https://redocly.com/docs/api-reference-docs/specification-extensions/x-code-samples/
- */
-export interface OpenAPICustomCodeSample {
-    lang: string;
-    label: string;
-    source: string;
-}
-
-export { toJSON, fromJSON };
-
-/**
- * Resolve an OpenAPI operation in a file and compile it to a more usable format.
- */
-export async function fetchOpenAPIOperation(
-    input: {
-        url: string;
-        path: string;
-        method: string;
-    },
-    rawFetcher: OpenAPIFetcher,
-): Promise<OpenAPIOperationData | null> {
-    const fetcher = cacheFetcher(rawFetcher);
-
-    let operation = await resolveOpenAPIPath<OpenAPIV3.OperationObject>(
-        input.url,
-        ['paths', input.path, input.method],
-        fetcher,
-    );
-
-    if (!operation) {
-        return null;
-    }
-
-    const specData = await fetcher.fetch(input.url);
-
-    // Resolve common parameters
-    const commonParameters = await resolveOpenAPIPath<OpenAPIV3.ParameterObject[]>(
-        input.url,
-        ['paths', input.path, 'parameters'],
-        fetcher,
-    );
-    if (commonParameters) {
-        operation = {
-            ...operation,
-            parameters: [...commonParameters, ...(operation.parameters ?? [])],
-        };
-    }
-
-    // Resolve servers
-    const servers = await resolveOpenAPIPath<OpenAPIV3.ServerObject[]>(
-        input.url,
-        ['servers'],
-        fetcher,
-    );
-
-    // Resolve securities
-    const securities: OpenAPIOperationData['securities'] = [];
-    for (const security of operation.security ?? []) {
-        const securityKey = Object.keys(security)[0];
-
-        const securityScheme = await resolveOpenAPIPath<OpenAPIV3.SecuritySchemeObject>(
-            input.url,
-            ['components', 'securitySchemes', securityKey],
-            fetcher,
-        );
-
-        if (securityScheme) {
-            securities.push([securityKey, securityScheme]);
-        }
-    }
-
-    return {
-        servers: servers ?? [],
-        operation,
-        method: input.method,
-        path: input.path,
-        securities,
-        'x-codeSamples':
-            typeof specData['x-codeSamples'] === 'boolean' ? specData['x-codeSamples'] : undefined,
-        'x-hideTryItPanel':
-            typeof specData['x-hideTryItPanel'] === 'boolean'
-                ? specData['x-hideTryItPanel']
-                : undefined,
-    };
-}
-
-function cacheFetcher(fetcher: OpenAPIFetcher): OpenAPIFetcher {
-    const cache = new Map<string, Promise<any>>();
-
-    return {
-        async fetch(url) {
-            if (cache.has(url)) {
-                return cache.get(url);
-            }
-
-            const promise = fetcher.fetch(url);
-            cache.set(url, promise);
-            return promise;
-        },
-        parseMarkdown: fetcher.parseMarkdown,
-    };
-}
-
-/**
- * Parse a raw string into an OpenAPI document.
- * It will also convert Swagger 2.0 to OpenAPI 3.0.
- * It can throw an `OpenAPIFetchError` if the document is invalid.
- */
-export async function parseOpenAPIV3(url: string, text: string): Promise<OpenAPIV3.Document> {
-    // Parse the JSON or YAML
-    let data: unknown;
-
-    // Try with JSON
-    try {
-        data = JSON.parse(text);
-    } catch (jsonError) {
-        try {
-            // Try with YAML
-            data = YAML.parse(text);
-        } catch (yamlError) {
-            if (yamlError instanceof Error && yamlError.name.startsWith('YAML')) {
-                throw new OpenAPIFetchError('Failed to parse YAML: ' + yamlError.message, url);
-            } else {
-                throw yamlError;
-            }
-        }
-    }
-
-    // Convert Swagger 2.0 to OpenAPI 3.0
-    // @ts-ignore
-    if (data && data.swagger) {
-        try {
-            // Convert Swagger 2.0 to OpenAPI 3.0
-            // @ts-ignore
-            const result = (await swagger2openapi.convertObj(data, {
-                resolve: false,
-                resolveInternal: false,
-                laxDefaults: true,
-                laxurls: true,
-                lint: false,
-                prevalidate: false,
-                anchors: true,
-                patch: true,
-            })) as ConvertOutputOptions;
-
-            data = result.openapi;
-        } catch (error) {
-            if ((error as Error).name === 'S2OError') {
-                throw new OpenAPIFetchError(
-                    'Failed to convert Swagger 2.0 to OpenAPI 3.0: ' + (error as Error).message,
-                    url,
-                );
-            } else {
-                throw error;
-            }
-        }
-    }
-
-    // @ts-ignore
-    return data;
-}
-
-export class OpenAPIFetchError extends Error {
-    public name = 'OpenAPIFetchError';
-
-    constructor(
-        message: string,
-        public readonly url: string,
-    ) {
-        super(message);
-    }
-}

package/src/resolveOpenAPIPath.test.ts

@@ -1,60 +0,0 @@
-import { it, expect } from 'bun:test';
-
-import { resolveOpenAPIPath } from './resolveOpenAPIPath';
-import { OpenAPIFetcher } from './types';
-
-const createFetcherForSchema = (schema: any): OpenAPIFetcher => {
-    return {
-        fetch: async (url) => {
-            return schema;
-        },
-    };
-};
-
-it('should resolve a simple path through objects', async () => {
-    const resolved = await resolveOpenAPIPath(
-        'https://test.com',
-        ['a', 'b', 'c'],
-        createFetcherForSchema({
-            a: {
-                b: {
-                    c: 'hello',
-                },
-            },
-        }),
-    );
-
-    expect(resolved).toBe('hello');
-});
-
-it('should return undefined if the last part of the path does not exists', async () => {
-    const resolved = await resolveOpenAPIPath(
-        'https://test.com',
-        ['a', 'b', 'c'],
-        createFetcherForSchema({
-            a: {
-                b: {
-                    d: 'hello',
-                },
-            },
-        }),
-    );
-
-    expect(resolved).toBe(undefined);
-});
-
-it('should return undefined if a middle part of the path does not exists', async () => {
-    const resolved = await resolveOpenAPIPath(
-        'https://test.com',
-        ['a', 'x', 'c'],
-        createFetcherForSchema({
-            a: {
-                b: {
-                    c: 'hello',
-                },
-            },
-        }),
-    );
-
-    expect(resolved).toBe(undefined);
-});

package/src/resolveOpenAPIPath.ts

@@ -1,145 +0,0 @@
-import { OpenAPIFetcher } from './types';
-
-const SYMBOL_MARKDOWN_PARSED = '__$markdownParsed';
-export const SYMBOL_REF_RESOLVED = '__$refResolved';
-
-/**
- * Resolve a path in a OpenAPI file.
- * It resolves any reference needed to resolve the path, ignoring other references outside the path.
- */
-export async function resolveOpenAPIPath<T>(
-    url: string,
-    dataPath: string[],
-    fetcher: OpenAPIFetcher,
-): Promise<T | undefined> {
-    const data = await fetcher.fetch(url);
-    let value: unknown = data;
-
-    if (!value) {
-        return undefined;
-    }
-
-    const lastKey = dataPath[dataPath.length - 1];
-    dataPath = dataPath.slice(0, -1);
-
-    for (const part of dataPath) {
-        // @ts-ignore
-        if (isRef(value[part])) {
-            await transformAll(url, value, part, fetcher);
-        }
-
-        // @ts-ignore
-        value = value[part];
-
-        // If any part along the path is undefined, return undefined.
-        if (typeof value !== 'object' || value === null) {
-            return undefined;
-        }
-    }
-
-    await transformAll(url, value, lastKey, fetcher);
-
-    // @ts-expect-error
-    return value[lastKey] as T;
-}
-
-/**
- * Recursively process a part of the OpenAPI spec to resolve all references.
- */
-async function transformAll(
-    url: string,
-    data: any,
-    key: string | number,
-    fetcher: OpenAPIFetcher,
-): Promise<void> {
-    const value = data[key];
-
-    if (
-        typeof value === 'string' &&
-        key === 'description' &&
-        fetcher.parseMarkdown &&
-        !data[SYMBOL_MARKDOWN_PARSED]
-    ) {
-        // Parse markdown
-        data[SYMBOL_MARKDOWN_PARSED] = true;
-        data[key] = await fetcher.parseMarkdown(value);
-    } else if (
-        typeof value === 'string' ||
-        typeof value === 'number' ||
-        typeof value === 'boolean' ||
-        value === null
-    ) {
-        // Primitives
-    } else if (typeof value === 'object' && value !== null && SYMBOL_REF_RESOLVED in value) {
-        // Ref was already resolved
-    } else if (isRef(value)) {
-        const ref = value.$ref;
-
-        // Delete the ref to avoid infinite loop with circular references
-        // @ts-ignore
-        delete value.$ref;
-
-        data[key] = await resolveReference(url, ref, fetcher);
-        if (data[key]) {
-            data[key][SYMBOL_REF_RESOLVED] = extractRefName(ref);
-        }
-    } else if (Array.isArray(value)) {
-        // Recursively resolve all references in the array
-        await Promise.all(value.map((item, index) => transformAll(url, value, index, fetcher)));
-    } else if (typeof value === 'object' && value !== null) {
-        // Recursively resolve all references in the object
-        const keys = Object.keys(value);
-        for (const key of keys) {
-            await transformAll(url, value, key, fetcher);
-        }
-    }
-}
-
-async function resolveReference(
-    origin: string,
-    ref: string,
-    fetcher: OpenAPIFetcher,
-): Promise<any> {
-    const parsed = parseReference(origin, ref);
-    return resolveOpenAPIPath(parsed.url, parsed.dataPath, fetcher);
-}
-
-function parseReference(origin: string, ref: string): { url: string; dataPath: string[] } {
-    if (!ref) {
-        return {
-            url: origin,
-            dataPath: [],
-        };
-    }
-
-    if (ref.startsWith('#')) {
-        // Local references
-        const dataPath = ref.split('/').filter(Boolean).slice(1);
-        return {
-            url: origin,
-            dataPath,
-        };
-    }
-
-    // Absolute references
-    const url = new URL(ref, origin);
-    if (url.hash) {
-        const hash = url.hash;
-        url.hash = '';
-        return parseReference(url.toString(), hash);
-    }
-
-    return {
-        url: url.toString(),
-        dataPath: [],
-    };
-}
-
-function extractRefName(ref: string): string {
-    const parts = ref.split('/');
-    return parts[parts.length - 1];
-}
-
-function isRef(ref: any): ref is { $ref: string } {
-    return typeof ref === 'object' && ref !== null && '$ref' in ref && ref.$ref;
-}