vovk 3.5.1 → 3.7.0

package/dist/openapi/openapi-to-vovk-schema/index.js

@@ -0,0 +1,179 @@
+import { applyComponentsSchemas } from './apply-components-schemas.js';
+import { inlineRefs } from './inline-refs.js';
+import { pruneComponentsSchemas } from './prune-components-schemas.js';
+import { VovkSchemaIdEnum } from '../../types/enums.js';
+import { schemaToTsType } from '../../samples/schema-to-ts-type.js';
+function getTsTypeString(contentType, schema) {
+    const tsTypes = new Set(contentType.flatMap((ct) => {
+        switch (ct) {
+            case 'application/json':
+                return [schemaToTsType(schema)];
+            case 'multipart/form-data':
+                return ['FormData', schemaToTsType(schema)];
+            case 'application/x-www-form-urlencoded':
+                return ['FormData', 'URLSearchParams', schemaToTsType(schema)];
+            case 'text/plain':
+                return ['string'];
+            default:
+                return ['Blob', 'ArrayBuffer', 'Uint8Array'];
+        }
+    }));
+    return [...tsTypes].join(' | ') || schemaToTsType(schema);
+}
+export function openAPIToVovkSchema({ apiRoot, source: { object: openAPIObject }, getModuleName, getMethodName, filterOperations, pruneComponents, errorMessageKey, segmentName, }) {
+    segmentName = segmentName ?? '';
+    const forceApiRoot = apiRoot ||
+        (openAPIObject.servers?.[0]?.url ??
+            ('host' in openAPIObject
+                ? `https://${openAPIObject.host}${'basePath' in openAPIObject ? openAPIObject.basePath : ''}`
+                : null));
+    if (!forceApiRoot) {
+        throw new Error('API root URL is required in OpenAPI configuration');
+    }
+    const { paths, ...noPathsOpenAPIObject } = openAPIObject;
+    const schema = {
+        $schema: VovkSchemaIdEnum.SCHEMA,
+        segments: {
+            [segmentName]: {
+                $schema: VovkSchemaIdEnum.SEGMENT,
+                emitSchema: true,
+                segmentName,
+                segmentType: 'mixin',
+                controllers: {},
+                forceApiRoot,
+                meta: {
+                    openAPIObject: noPathsOpenAPIObject,
+                },
+            },
+        },
+    };
+    const segment = schema.segments[segmentName];
+    Object.entries(paths ?? {}).forEach(([path, operations]) => {
+        Object.entries(operations ?? {})
+            .filter(([, operation]) => operation && typeof operation === 'object')
+            .forEach(([method, operation]) => {
+            if (filterOperations &&
+                !filterOperations({
+                    method: method.toUpperCase(),
+                    path,
+                    openAPIObject,
+                    operationObject: operation,
+                })) {
+                return;
+            }
+            const rpcModuleName = getModuleName({
+                method: method.toUpperCase(),
+                path,
+                openAPIObject,
+                operationObject: operation,
+            });
+            const handlerName = getMethodName({
+                method: method.toUpperCase(),
+                path,
+                openAPIObject,
+                operationObject: operation,
+            });
+            segment.controllers[rpcModuleName] ??= {
+                rpcModuleName,
+                handlers: {},
+            };
+            const parameters = inlineRefs(operation.parameters ?? [], openAPIObject);
+            const queryProperties = parameters?.filter((p) => p.in === 'query') ?? null;
+            const pathProperties = parameters?.filter((p) => p.in === 'path') ?? null;
+            const query = queryProperties?.length
+                ? {
+                    type: 'object',
+                    properties: Object.fromEntries(queryProperties.map((p) => [p.name, p.schema])),
+                    required: queryProperties.filter((p) => p.required).map((p) => p.name),
+                }
+                : null;
+            const params = pathProperties?.length
+                ? {
+                    type: 'object',
+                    properties: Object.fromEntries(pathProperties.map((p) => [p.name, p.schema])),
+                    required: pathProperties.filter((p) => p.required).map((p) => p.name),
+                }
+                : null;
+            const requestBodyContent = inlineRefs(operation.requestBody, openAPIObject)?.content ?? {};
+            const contentTypes = [
+                'application/json',
+                'multipart/form-data',
+                'application/x-www-form-urlencoded',
+                'text/plain',
+                'application/octet-stream',
+            ];
+            const bodySchemas = contentTypes
+                .map((contentType) => requestBodyContent[contentType]?.schema
+                ? { ...requestBodyContent[contentType].schema, 'x-contentType': [contentType] }
+                : null)
+                .filter(Boolean);
+            const body = !bodySchemas.length
+                ? null
+                : bodySchemas.length === 1
+                    ? {
+                        ...bodySchemas[0],
+                        'x-tsType': getTsTypeString(bodySchemas[0]['x-contentType'] ?? [], bodySchemas[0]),
+                    }
+                    : {
+                        anyOf: bodySchemas,
+                        'x-tsType': getTsTypeString(bodySchemas.flatMap((s) => s['x-contentType'] ?? []), { anyOf: bodySchemas }),
+                    };
+            const output = operation.responses?.['200']?.content?.['application/json']?.schema ??
+                operation.responses?.['201']?.content?.['application/json']?.schema ??
+                null;
+            const iteration = operation.responses?.['200']?.content?.['application/jsonl']?.schema ??
+                operation.responses?.['201']?.content?.['application/jsonl']?.schema ??
+                operation.responses?.['200']?.content?.['application/jsonlines']?.schema ??
+                operation.responses?.['201']?.content?.['application/jsonlines']?.schema ??
+                null;
+            if (errorMessageKey) {
+                operation['x-errorMessageKey'] = errorMessageKey;
+            }
+            const componentsSchemas = openAPIObject.components?.schemas ??
+                ('definitions' in openAPIObject ? openAPIObject.definitions : {});
+            segment.controllers[rpcModuleName].handlers[handlerName] = {
+                httpMethod: method.toUpperCase(),
+                path,
+                operationObject: operation,
+                misc: {
+                    isOpenAPIMixin: true,
+                    originalPath: path,
+                },
+                validation: {
+                    ...(query && {
+                        query: applyComponentsSchemas(query, componentsSchemas, segmentName),
+                    }),
+                    ...(params && {
+                        params: applyComponentsSchemas(params, componentsSchemas, segmentName),
+                    }),
+                    ...(body && {
+                        body: applyComponentsSchemas(body, componentsSchemas, segmentName),
+                    }),
+                    ...(output && {
+                        // Response slot: not validated + typed via x-tsType → skip $defs (dedup).
+                        output: applyComponentsSchemas(output, componentsSchemas, segmentName, false),
+                    }),
+                    ...(iteration && {
+                        iteration: applyComponentsSchemas(iteration, componentsSchemas, segmentName, false),
+                    }),
+                },
+            };
+        });
+    });
+    if (pruneComponents && noPathsOpenAPIObject.components?.schemas) {
+        // Reassign with fresh objects only — `noPathsOpenAPIObject` shares references with the
+        // caller's spec, so the original `components.schemas` must stay untouched. Walking the
+        // whole controllers tree (validation slots + raw operation objects) keeps every `$ref`
+        // a kept handler carries resolvable against the pruned meta.
+        segment.meta = {
+            openAPIObject: {
+                ...noPathsOpenAPIObject,
+                components: {
+                    ...noPathsOpenAPIObject.components,
+                    schemas: pruneComponentsSchemas(segment.controllers, noPathsOpenAPIObject.components.schemas),
+                },
+            },
+        };
+    }
+    return schema;
+}

package/dist/openapi/openapi-to-vovk-schema/inline-refs.d.ts

@@ -0,0 +1,9 @@
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+/**
+ * Resolves $ref references at the first level only (except for components/schemas references)
+ * For arrays, checks each item at the first level
+ * @param obj - The object to process (may contain $ref properties)
+ * @param openAPIObject - The complete OpenAPI document containing definitions
+ * @returns The object with resolved references (except components/schemas)
+ */
+export declare function inlineRefs<T extends object>(obj: unknown, openAPIObject: OpenAPIObject): T | null;

package/dist/openapi/openapi-to-vovk-schema/inline-refs.js

@@ -0,0 +1,99 @@
+/**
+ * Resolves $ref references at the first level only (except for components/schemas references)
+ * For arrays, checks each item at the first level
+ * @param obj - The object to process (may contain $ref properties)
+ * @param openAPIObject - The complete OpenAPI document containing definitions
+ * @returns The object with resolved references (except components/schemas)
+ */
+export function inlineRefs(obj, openAPIObject) {
+    // Handle null or undefined
+    if (obj === null || obj === undefined) {
+        return null;
+    }
+    // Handle arrays - check each item for $ref at first level only
+    if (Array.isArray(obj)) {
+        return obj.map((item) => {
+            // Only resolve if item is an object with $ref
+            if (item && typeof item === 'object' && '$ref' in item && typeof item.$ref === 'string') {
+                // Skip components/schemas references
+                if (item.$ref.startsWith('#/components/schemas/')) {
+                    return item;
+                }
+                // Resolve the reference
+                const resolved = resolveRef(item.$ref, openAPIObject);
+                // If resolution successful, return resolved value (with any additional properties merged)
+                if (resolved !== undefined) {
+                    // If there are additional properties besides $ref, merge them
+                    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                    const { $ref: _$ref, ...additionalProps } = item;
+                    if (Object.keys(additionalProps).length > 0) {
+                        return { ...resolved, ...additionalProps };
+                    }
+                    return resolved;
+                }
+            }
+            // Return item as-is if not a resolvable $ref
+            return item;
+        });
+    }
+    // Handle non-objects (primitives)
+    if (typeof obj !== 'object') {
+        return obj;
+    }
+    // Check if object has a $ref property at the first level
+    if ('$ref' in obj && typeof obj.$ref === 'string') {
+        // Check if the reference points to components/schemas
+        if (obj.$ref.startsWith('#/components/schemas/')) {
+            // Return as-is for schema references
+            return obj;
+        }
+        // Resolve the reference
+        const resolved = resolveRef(obj.$ref, openAPIObject);
+        // If resolution successful, return resolved value (with any additional properties merged)
+        if (resolved !== undefined) {
+            // If there are additional properties besides $ref, merge them
+            // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            const { $ref: _$ref, ...additionalProps } = obj;
+            if (Object.keys(additionalProps).length > 0) {
+                return { ...resolved, ...additionalProps };
+            }
+            return resolved;
+        }
+    }
+    // For regular objects without $ref, return as-is (no recursion)
+    return obj;
+}
+/**
+ * Resolves a JSON Reference ($ref) to its target value
+ * @param ref - The reference string (e.g., "#/components/parameters/id")
+ * @param openAPIObject - The complete OpenAPI document
+ * @returns The resolved value or undefined if not found
+ */
+function resolveRef(ref, openAPIObject) {
+    // Handle only local references (starting with #)
+    if (!ref.startsWith('#/')) {
+        // eslint-disable-next-line no-console
+        console.warn(`External references are not supported: ${ref}`);
+        return undefined;
+    }
+    // Remove the leading # and split the path
+    const path = ref
+        .substring(1)
+        .split('/')
+        .filter((p) => p !== '');
+    // Navigate through the object following the path
+    let current = openAPIObject;
+    for (const segment of path) {
+        // Decode the segment (handles encoded characters like ~0 for ~ and ~1 for /)
+        const decodedSegment = segment.replace(/~1/g, '/').replace(/~0/g, '~');
+        if (current && typeof current === 'object' && decodedSegment in current) {
+            current = current[decodedSegment];
+        }
+        else {
+            // eslint-disable-next-line no-console
+            console.warn(`Could not resolve reference: ${ref}`);
+            return undefined;
+        }
+    }
+    return current;
+}

package/dist/openapi/openapi-to-vovk-schema/prune-components-schemas.d.ts

@@ -0,0 +1,7 @@
+import type { ComponentsObject } from 'openapi3-ts/oas31';
+/**
+ * Shrinks a `components.schemas` dict to the transitive `$ref` closure of `roots`
+ * (BFS with a visited set — component graphs of large specs like Stripe are cyclic).
+ * Preserves the original key order for deterministic output.
+ */
+export declare function pruneComponentsSchemas(roots: unknown, componentsSchemas: NonNullable<ComponentsObject['schemas']>): NonNullable<ComponentsObject['schemas']>;

package/dist/openapi/openapi-to-vovk-schema/prune-components-schemas.js

@@ -0,0 +1,51 @@
+// Collect the trailing name of every `$ref` in the tree. Covers both pointer styles
+// the transform emits: `#/components/schemas/X` (response slots, raw operation objects)
+// and `#/$defs/X` (request slots embed components under their original names).
+function collectRefNames(node, into) {
+    if (!node || typeof node !== 'object')
+        return;
+    if (Array.isArray(node)) {
+        for (const item of node) {
+            collectRefNames(item, into);
+        }
+        return;
+    }
+    for (const [key, value] of Object.entries(node)) {
+        if (key === '$ref' && typeof value === 'string') {
+            const name = value.split('/').pop();
+            if (name)
+                into.add(name);
+        }
+        else {
+            collectRefNames(value, into);
+        }
+    }
+}
+/**
+ * Shrinks a `components.schemas` dict to the transitive `$ref` closure of `roots`
+ * (BFS with a visited set — component graphs of large specs like Stripe are cyclic).
+ * Preserves the original key order for deterministic output.
+ */
+export function pruneComponentsSchemas(roots, componentsSchemas) {
+    const required = new Set();
+    collectRefNames(roots, required);
+    const queue = [...required];
+    const visited = new Set();
+    while (queue.length) {
+        const name = queue.pop();
+        if (!name || visited.has(name))
+            continue;
+        visited.add(name);
+        const component = componentsSchemas[name];
+        if (!component)
+            continue;
+        const refs = new Set();
+        collectRefNames(component, refs);
+        for (const ref of refs) {
+            required.add(ref);
+            if (!visited.has(ref))
+                queue.push(ref);
+        }
+    }
+    return Object.fromEntries(Object.entries(componentsSchemas).filter(([name]) => required.has(name)));
+}

package/dist/openapi/operation.js

@@ -1,4 +1,4 @@
-import { createDecorator } from '../core/createDecorator.js';
+import { createDecorator } from '../core/create-decorator.js';
 import { error } from './error.js';
 import { tool } from './tool.js';
 export const operationDecorator = createDecorator(null, (openAPIOperationObject = {}) => {

package/dist/openapi/tool.js

@@ -1,4 +1,4 @@
-import { createDecorator } from '../core/createDecorator.js';
+import { createDecorator } from '../core/create-decorator.js';
 export const tool = createDecorator(null, (toolOptions) => {
     return (handlerSchema) => {
         return {

package/dist/openapi/vovk-schema-to-openapi.d.ts

@@ -0,0 +1,21 @@
+import type { OpenAPIObject } from 'openapi3-ts/oas31';
+import type { VovkOutputConfig, VovkStrictConfig, VovkReadmeConfig, VovkSamplesConfig, VovkPackageJson } from '../types/config.js';
+import type { VovkSchema } from '../types/core.js';
+export declare function vovkSchemaToOpenAPI({ config, rootEntry, schema: fullSchema, outputConfigs, forceOutputConfigs, isBundle, segmentName: givenSegmentName, projectPackageJson, }: {
+    config: VovkStrictConfig | undefined;
+    rootEntry?: string;
+    schema: VovkSchema;
+    outputConfigs: VovkOutputConfig[];
+    forceOutputConfigs?: VovkOutputConfig[];
+    isBundle: boolean;
+    segmentName: string | null;
+    projectPackageJson: VovkPackageJson | undefined;
+}): {
+    readme: VovkReadmeConfig;
+    openAPIObject: OpenAPIObject;
+    samples: VovkSamplesConfig;
+    origin: string;
+    package: VovkPackageJson;
+    imports: VovkOutputConfig['imports'];
+    reExports: VovkOutputConfig['reExports'];
+};

package/dist/openapi/vovk-schema-to-openapi.js

@@ -0,0 +1,250 @@
+import { createCodeSamples } from '../samples/create-code-samples.js';
+import { schemaToObject } from '../samples/schema-to-object.js';
+import { resolveGeneratorConfigValues } from '../core/resolve-generator-config-values.js';
+import { HttpStatus } from '../types/enums.js';
+function extractComponents(schema) {
+    if (!schema)
+        return [undefined, {}];
+    const components = {};
+    // Function to collect components and replace $refs recursively
+    const process = (obj, path = []) => {
+        if (!obj || typeof obj !== 'object')
+            return obj;
+        // Handle arrays
+        if (Array.isArray(obj)) {
+            return obj.map((item) => process(item, path));
+        }
+        // Create a copy to modify
+        const result = {};
+        Object.entries({ ...obj.definitions, ...obj.$defs }).forEach(([key, value]) => {
+            components[key] = process(value, [...path, key]);
+        });
+        // Process all properties
+        for (const [key, value] of Object.entries(obj ?? {})) {
+            // Skip already processed special properties
+            if (key === '$defs' || key === 'definitions')
+                continue;
+            if (key === '$ref' && typeof value === 'string') {
+                // Extract the component name from the reference
+                const refParts = value.split('/');
+                const refName = refParts[refParts.length - 1];
+                // Replace with component reference
+                result[key] = `#/components/schemas/${refName}`;
+            }
+            else {
+                // Recursively process other properties
+                result[key] = process(value, [...path, key]);
+            }
+        }
+        return result;
+    };
+    const processedSchema = process(schema);
+    return [processedSchema, components];
+}
+// returns OpenAPIObject along with resolved configs
+// TODO: Refactor and decompose
+export function vovkSchemaToOpenAPI({ config, rootEntry = 'api', schema: fullSchema, outputConfigs, forceOutputConfigs, isBundle, segmentName: givenSegmentName, projectPackageJson, }) {
+    const paths = {};
+    const components = {};
+    const { openAPIObject, samples: samplesConfig, package: packageJson, readme: readmeConfig, origin, imports, reExports, } = resolveGeneratorConfigValues({
+        config,
+        outputConfigs,
+        forceOutputConfigs,
+        isBundle,
+        segmentName: givenSegmentName ?? null,
+        projectPackageJson,
+    });
+    for (const [segmentName, segmentSchema] of givenSegmentName
+        ? [[givenSegmentName, fullSchema.segments[givenSegmentName]]]
+        : Object.entries(fullSchema.segments ?? {})) {
+        for (const c of Object.values(segmentSchema.controllers)) {
+            for (const [handlerName, h] of Object.entries(c.handlers ?? {})) {
+                if (h.operationObject && !h.misc?.isOpenAPIMixin) {
+                    const [queryValidation, queryComponents] = extractComponents(h?.validation?.query);
+                    const [bodyValidation, bodyComponents] = extractComponents(h?.validation?.body);
+                    const [paramsValidation, paramsComponents] = extractComponents(h?.validation?.params);
+                    const [outputValidation, outputComponents] = extractComponents(h?.validation?.output);
+                    const [iterationValidation, iterationComponents] = extractComponents(h?.validation?.iteration);
+                    // TODO: Handle name conflicts?
+                    Object.assign(components, queryComponents, bodyComponents, paramsComponents, outputComponents, iterationComponents);
+                    const { ts, rs, py } = createCodeSamples({
+                        package: packageJson,
+                        handlerName,
+                        handlerSchema: h,
+                        controllerSchema: c,
+                        config: samplesConfig,
+                    });
+                    const queryParameters = queryValidation && 'type' in queryValidation && 'properties' in queryValidation
+                        ? Object.entries(queryValidation.properties ?? {}).map(([propName, propSchema]) => ({
+                            name: propName,
+                            in: 'query',
+                            required: queryValidation.required ? queryValidation.required.includes(propName) : false,
+                            schema: propSchema,
+                        }))
+                        : null;
+                    const pathParameters = paramsValidation && 'type' in paramsValidation && 'properties' in paramsValidation
+                        ? Object.entries(paramsValidation.properties ?? {}).map(([propName, propSchema]) => ({
+                            name: propName,
+                            in: 'path',
+                            required: paramsValidation.required ? paramsValidation.required.includes(propName) : false,
+                            schema: propSchema,
+                        }))
+                        : null;
+                    const path = h.misc?.originalPath ??
+                        `/${[rootEntry.replace(/^\/+|\/+$/g, ''), segmentName, c.prefix, h.path].filter(Boolean).join('/')}`;
+                    paths[path] = paths[path] ?? {};
+                    const httpMethod = h.httpMethod.toLowerCase();
+                    paths[path][httpMethod] ??= {};
+                    paths[path][httpMethod] = {
+                        ...h.operationObject,
+                        ...paths[path][httpMethod],
+                        'x-codeSamples': [
+                            ...(paths[path][httpMethod]['x-codeSamples'] ?? []),
+                            ...(h.operationObject?.['x-codeSamples'] ?? []),
+                            {
+                                label: 'TypeScript RPC',
+                                lang: 'typescript',
+                                source: ts,
+                            },
+                            {
+                                label: 'Python RPC',
+                                lang: 'python',
+                                source: py,
+                            },
+                            {
+                                label: 'Rust RPC',
+                                lang: 'rust',
+                                source: rs,
+                            },
+                        ],
+                        ...(queryParameters || pathParameters
+                            ? {
+                                parameters: h.operationObject?.parameters ?? [...(queryParameters || []), ...(pathParameters || [])],
+                            }
+                            : {}),
+                        ...(paths[path][httpMethod].parameters
+                            ? {
+                                parameters: paths[path][httpMethod].parameters,
+                            }
+                            : {}),
+                        ...(outputValidation && 'type' in outputValidation
+                            ? {
+                                responses: {
+                                    200: {
+                                        description: 'description' in outputValidation ? outputValidation.description : 'Success',
+                                        content: {
+                                            'application/json': {
+                                                schema: outputValidation,
+                                            },
+                                        },
+                                    },
+                                    ...h.operationObject?.responses,
+                                },
+                            }
+                            : {}),
+                        ...(iterationValidation && 'type' in iterationValidation
+                            ? {
+                                responses: {
+                                    200: {
+                                        description: 'description' in iterationValidation ? iterationValidation.description : 'JSON Lines response',
+                                        content: {
+                                            'application/jsonl': {
+                                                schema: {
+                                                    ...iterationValidation,
+                                                    examples: iterationValidation.examples ?? [
+                                                        [
+                                                            JSON.stringify(schemaToObject(iterationValidation)),
+                                                            JSON.stringify(schemaToObject(iterationValidation)),
+                                                            JSON.stringify(schemaToObject(iterationValidation)),
+                                                        ].join('\n'),
+                                                    ],
+                                                },
+                                            },
+                                        },
+                                    },
+                                    ...h.operationObject?.responses,
+                                },
+                            }
+                            : {}),
+                        ...(paths[path][httpMethod].responses
+                            ? {
+                                responses: paths[path][httpMethod].responses,
+                            }
+                            : {}),
+                        ...(bodyValidation && 'type' in bodyValidation
+                            ? {
+                                requestBody: h.operationObject?.requestBody ?? {
+                                    description: 'description' in bodyValidation ? bodyValidation.description : 'Request body',
+                                    required: true,
+                                    content: bodyValidation['x-contentType']?.length
+                                        ? Object.fromEntries(bodyValidation['x-contentType'].map((ct) => [ct, { schema: bodyValidation }]))
+                                        : {
+                                            'application/json': {
+                                                schema: bodyValidation,
+                                            },
+                                        },
+                                },
+                            }
+                            : {}),
+                        ...(paths[path][httpMethod].requestBody
+                            ? {
+                                requestBody: paths[path][httpMethod].requestBody,
+                            }
+                            : {}),
+                        tags: paths[path][httpMethod].tags ?? h.operationObject?.tags,
+                    };
+                }
+            }
+        }
+    }
+    return {
+        readme: readmeConfig,
+        samples: samplesConfig,
+        package: packageJson,
+        imports,
+        reExports,
+        origin,
+        openAPIObject: {
+            ...openAPIObject,
+            components: {
+                ...openAPIObject?.components,
+                schemas: {
+                    ...(openAPIObject?.components?.schemas ?? components),
+                    HttpStatus: {
+                        type: 'integer',
+                        description: 'HTTP status code',
+                        enum: Object.keys(HttpStatus)
+                            .map((k) => HttpStatus[k])
+                            .filter(Boolean)
+                            .filter((v) => typeof v === 'number'),
+                    },
+                    VovkErrorResponse: {
+                        type: 'object',
+                        description: 'Vovk error response',
+                        properties: {
+                            cause: {
+                                description: 'Error cause of any shape',
+                            },
+                            statusCode: {
+                                $ref: '#/components/schemas/HttpStatus',
+                            },
+                            message: {
+                                type: 'string',
+                                description: 'Error message',
+                            },
+                            isError: {
+                                type: 'boolean',
+                                const: true,
+                                description: 'Indicates that this object represents an error',
+                            },
+                        },
+                        required: ['statusCode', 'message', 'isError'],
+                        additionalProperties: false,
+                    },
+                    ...openAPIObject?.components?.schemas,
+                },
+            },
+            paths,
+        },
+    };
+}

package/dist/req/buffer-body.d.ts

@@ -0,0 +1 @@
+export declare function bufferBody<T extends Request>(req: T): Promise<T>;

package/dist/req/buffer-body.js

@@ -0,0 +1,30 @@
+export async function bufferBody(req) {
+    const buffer = await req.arrayBuffer();
+    Object.defineProperty(req, 'bodyUsed', {
+        get: () => false,
+        configurable: true,
+    });
+    Object.defineProperty(req, 'body', {
+        get: () => new ReadableStream({
+            start(controller) {
+                controller.enqueue(new Uint8Array(buffer.slice(0)));
+                controller.close();
+            },
+        }),
+        configurable: true,
+    });
+    req.json = async () => JSON.parse(new TextDecoder().decode(buffer));
+    req.text = async () => new TextDecoder().decode(buffer);
+    req.blob = async () => new Blob([buffer.slice(0)]);
+    req.arrayBuffer = async () => buffer.slice(0);
+    req.bytes = async () => new Uint8Array(buffer.slice(0));
+    req.formData = async () => {
+        const r = new Request('http://localhost', {
+            method: req.method,
+            headers: req.headers,
+            body: buffer.slice(0),
+        });
+        return r.formData();
+    };
+    return req;
+}