@scalar/oas-utils 0.2.43 → 0.2.44

package/dist/entities/spec/request-examples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"request-examples.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/request-examples.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAA;AACzC,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAEtC,eAAO,MAAM,8BAA8B;;;;;;IAMzC,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAUlF,CAAA;AAEF,kFAAkF;AAClF,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAC3C,OAAO,8BAA8B,CACtC,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,uEAQ7B,CAAA;AAEV,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;YAhCnC,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAmDlF,CAAA;AAEF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAA;AAEzE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;gBAvD/B,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;YAAlF,kFAAkF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAuElF,CAAA;AAEF,qDAAqD;AACrD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AACjE,MAAM,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAA;AAKxE,6DAA6D;AAC7D,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB;;;;;;;;;;;;;;;EAoB1D;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,MAAM,EACZ,MAAM,CAAC,EAAE,MAAM,GACd,cAAc,CAiFhB"}

package/dist/entities/spec/request-examples.js

@@ -0,0 +1,168 @@
+import { z } from 'zod';
+import { getRequestBodyFromOperation } from '../../spec-getters/getRequestBodyFromOperation.js';
+import { getServerVariableExamples } from '../../spec-getters/getServerVariableExamples.js';
+import { nanoidSchema } from '../shared/utility.js';
+
+const requestExampleParametersSchema = z.object({
+    key: z.string().default(''),
+    value: z.coerce.string().default(''),
+    enabled: z.boolean().default(true),
+    file: z.any().optional(),
+    description: z.string().optional(),
+    /** Params are linked to parents such as path params and global headers/cookies */
+    refUid: nanoidSchema.optional(),
+    required: z.boolean().optional(),
+    enum: z.array(z.string()).optional(),
+    type: z.string().optional(),
+    format: z.string().optional(),
+    minimum: z.number().optional(),
+    maximum: z.number().optional(),
+    default: z.any().optional(),
+    nullable: z.boolean().optional(),
+});
+/**
+ * Possible encodings for example request bodies when using text formats
+ *
+ * TODO: This list may not be comprehensive enough
+ */
+const exampleRequestBodyEncoding = [
+    'json',
+    'text',
+    'html',
+    'javascript',
+    'xml',
+    'yaml',
+    'edn',
+];
+const exampleRequestBodySchema = z.object({
+    raw: z
+        .object({
+        encoding: z.enum(exampleRequestBodyEncoding).default('json'),
+        value: z.string().default(''),
+    })
+        .optional(),
+    formData: z
+        .object({
+        encoding: z
+            .union([z.literal('form-data'), z.literal('urlencoded')])
+            .default('form-data'),
+        value: requestExampleParametersSchema.array().default([]),
+    })
+        .optional(),
+    binary: z.instanceof(Blob).optional(),
+    activeBody: z
+        .union([z.literal('raw'), z.literal('formData'), z.literal('binary')])
+        .default('raw'),
+});
+const requestExampleSchema = z.object({
+    type: z.literal('requestExample').optional().default('requestExample'),
+    uid: nanoidSchema,
+    requestUid: nanoidSchema,
+    name: z.string().optional().default('Name'),
+    body: exampleRequestBodySchema.optional().default({}),
+    parameters: z
+        .object({
+        path: requestExampleParametersSchema.array().default([]),
+        query: requestExampleParametersSchema.array().default([]),
+        headers: requestExampleParametersSchema.array().default([]),
+        cookies: requestExampleParametersSchema.array().default([]),
+    })
+        .optional()
+        .default({}),
+    serverVariables: z.record(z.string(), z.array(z.string())).optional(),
+});
+// ---------------------------------------------------------------------------
+// Example Helpers
+/** Create new instance parameter from a request parameter */
+function createParamInstance(param) {
+    const schema = param.schema;
+    /**
+     * TODO:
+     * - Need better value defaulting here
+     * - Need to handle non-string parameters much better
+     * - Need to handle unions/array values for schema
+     */
+    const value = String(schema?.default ?? schema?.examples?.[0] ?? '');
+    return requestExampleParametersSchema.parse({
+        ...schema,
+        key: param.name,
+        value,
+        description: param.description,
+        required: param.required,
+        /** Initialized all required properties to enabled */
+        enabled: !!param.required,
+    });
+}
+/**
+ * Create new request example from a request
+ * Iterates the name of the example if provided
+ */
+function createExampleFromRequest(request, name, server) {
+    // ---------------------------------------------------------------------------
+    // Populate all parameters with an example value
+    const parameters = {
+        path: [],
+        query: [],
+        cookie: [],
+        header: [],
+    };
+    // Populated the separated params
+    request.parameters?.forEach((p) => parameters[p.in].push(createParamInstance(p)));
+    // ---------------------------------------------------------------------------
+    // Handle request body defaulting for various content type encodings
+    const body = {
+        activeBody: 'raw',
+        raw: {
+            encoding: 'json',
+            value: '',
+        },
+    };
+    if (request.requestBody) {
+        const requestBody = getRequestBodyFromOperation({
+            path: request.path,
+            information: {
+                requestBody: request.requestBody,
+            },
+        });
+        if (requestBody?.body?.mimeType === 'application/json') {
+            body.activeBody = 'raw';
+            body.raw = {
+                encoding: 'json',
+                value: requestBody.body.text ?? JSON.stringify({}),
+            };
+        }
+        if (requestBody?.body?.mimeType === 'application/xml') {
+            body.activeBody = 'raw';
+            body.raw = {
+                encoding: 'xml',
+                value: requestBody.body.text ?? '',
+            };
+        }
+        /**
+         *  TODO: Are we loading example files from somewhere based on the spec?
+         *  How are we handling the body values
+         */
+        if (requestBody?.body?.mimeType === 'application/octet-stream') {
+            body.activeBody = 'binary';
+            body.binary = undefined;
+        }
+        /**
+         * TODO: How are handling form data examples from the spec
+         */
+        if (requestBody?.body?.mimeType === 'application/x-www-form-urlencoded') {
+            body.activeBody = 'formData';
+            body.formData = undefined;
+        }
+    }
+    const serverVariables = server ? getServerVariableExamples(server) : {};
+    const example = requestExampleSchema.parse({
+        requestUid: request.uid,
+        parameters,
+        name,
+        body,
+        serverVariables,
+    });
+    return example;
+}
+
+export { createExampleFromRequest, createParamInstance, exampleRequestBodyEncoding, exampleRequestBodySchema, requestExampleParametersSchema, requestExampleSchema };

package/dist/entities/spec/requests.d.ts

@@ -0,0 +1,317 @@
+import { z } from 'zod';
+import type { RequestExample } from './request-examples.js';
+export declare const requestMethods: readonly ["connect", "delete", "get", "head", "options", "patch", "post", "put", "trace"];
+export type RequestMethod = (typeof requestMethods)[number];
+/** A single set of populated values for a sent request */
+export type ResponseInstance<ResponseDataType = unknown> = Omit<Response, 'headers'> & {
+    /** Store headers as an object to match what we had with axios */
+    headers: Record<string, string>;
+    /** Keys of headers which set cookies */
+    cookieHeaderKeys: string[];
+    /** Time in ms the request took */
+    duration: number;
+    /** The response data */
+    data: ResponseDataType;
+    /** The response status */
+    status: number;
+    /** The response method */
+    method: RequestMethod;
+    /** The request path */
+    path: string;
+};
+/** A single request/response set to save to the history stack */
+export type RequestEvent = {
+    request: RequestExample;
+    response: ResponseInstance;
+    timestamp: number;
+};
+/** Open API Compliant Request Validator */
+export declare const oasRequestSchema: z.ZodObject<{
+    /**
+     * A list of tags for API documentation control. Tags can be used for logical
+     * grouping of operations by resources or any other qualifier.
+     *
+     * These tags are the openapi spec tag names, not uids
+     */
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** A short summary of what the operation does. */
+    summary: z.ZodOptional<z.ZodString>;
+    /** A verbose explanation of the operation behavior. CommonMark syntax MAY be used for rich text representation. */
+    description: z.ZodOptional<z.ZodString>;
+    /**
+     * Unique string used to identify the operation. The id MUST be unique among all operations described in the API.
+     * The operationId value is case-sensitive. Tools and libraries MAY use the operationId to uniquely identify an
+     * operation, therefore, it is RECOMMENDED to follow bin common programming naming conventions./
+     */
+    operationId: z.ZodOptional<z.ZodString>;
+    /**
+     * A declaration of which security mechanisms can be used across the API. The list of
+     * values includes alternative security requirement objects that can be used. Only
+     * one of the security requirement objects need to be satisfied to authorize a request.
+     * Individual operations can override this definition. To make security optional, an empty
+     * security requirement ({}) can be included in the array.
+     */
+    security: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>>, "many">>;
+    /**
+     * The request body applicable for this operation. The requestBody is fully supported in HTTP methods where the
+     * HTTP 1.1 specification [RFC7231] has explicitly defined semantics for request bodies. In other cases where the
+     * HTTP spec is vague (such as GET, HEAD and DELETE), requestBody is permitted but does not have well-defined
+     * semantics and SHOULD be avoided if possible.
+     */
+    requestBody: z.ZodOptional<z.ZodAny>;
+    /**
+     * Request parameters
+     */
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        in: z.ZodEnum<["path", "query", "header", "cookie"]>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        deprecated: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        schema: z.ZodOptional<z.ZodUnknown>;
+        content: z.ZodOptional<z.ZodUnknown>;
+        style: z.ZodOptional<z.ZodEnum<["matrix", "simple", "form", "label", "spaceDelimited", "pipeDelimited", "deepObject"]>>;
+    }, "strip", z.ZodTypeAny, {
+        required: boolean;
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        deprecated: boolean;
+        description?: string | undefined;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+    }, {
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        required?: boolean | undefined;
+        description?: string | undefined;
+        deprecated?: boolean | undefined;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+    }>, "many">>;
+    /**
+     * External documentation object
+     */
+    externalDocs: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        url: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        description?: string | undefined;
+    }, {
+        description?: string | undefined;
+        url?: string | undefined;
+    }>>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    /** Response formats */
+    responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, "strip", z.ZodTypeAny, {
+    description?: string | undefined;
+    summary?: string | undefined;
+    externalDocs?: {
+        url: string;
+        description?: string | undefined;
+    } | undefined;
+    security?: Record<string, string[]>[] | undefined;
+    tags?: string[] | undefined;
+    deprecated?: boolean | undefined;
+    operationId?: string | undefined;
+    parameters?: {
+        required: boolean;
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        deprecated: boolean;
+        description?: string | undefined;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+    }[] | undefined;
+    requestBody?: any;
+    responses?: Record<string, any> | undefined;
+}, {
+    description?: string | undefined;
+    summary?: string | undefined;
+    externalDocs?: {
+        description?: string | undefined;
+        url?: string | undefined;
+    } | undefined;
+    security?: Record<string, string[] | undefined>[] | undefined;
+    tags?: string[] | undefined;
+    deprecated?: boolean | undefined;
+    operationId?: string | undefined;
+    parameters?: {
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        required?: boolean | undefined;
+        description?: string | undefined;
+        deprecated?: boolean | undefined;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+    }[] | undefined;
+    requestBody?: any;
+    responses?: Record<string, any> | undefined;
+}>;
+/** Unified request schema for client usage */
+export declare const requestSchema: z.ZodObject<z.objectUtil.extendShape<{
+    /**
+     * A list of tags for API documentation control. Tags can be used for logical
+     * grouping of operations by resources or any other qualifier.
+     *
+     * These tags are the openapi spec tag names, not uids
+     */
+    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    /** A short summary of what the operation does. */
+    summary: z.ZodOptional<z.ZodString>;
+    /** A verbose explanation of the operation behavior. CommonMark syntax MAY be used for rich text representation. */
+    description: z.ZodOptional<z.ZodString>;
+    /**
+     * Unique string used to identify the operation. The id MUST be unique among all operations described in the API.
+     * The operationId value is case-sensitive. Tools and libraries MAY use the operationId to uniquely identify an
+     * operation, therefore, it is RECOMMENDED to follow bin common programming naming conventions./
+     */
+    operationId: z.ZodOptional<z.ZodString>;
+    /**
+     * A declaration of which security mechanisms can be used across the API. The list of
+     * values includes alternative security requirement objects that can be used. Only
+     * one of the security requirement objects need to be satisfied to authorize a request.
+     * Individual operations can override this definition. To make security optional, an empty
+     * security requirement ({}) can be included in the array.
+     */
+    security: z.ZodOptional<z.ZodArray<z.ZodRecord<z.ZodString, z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>>, "many">>;
+    /**
+     * The request body applicable for this operation. The requestBody is fully supported in HTTP methods where the
+     * HTTP 1.1 specification [RFC7231] has explicitly defined semantics for request bodies. In other cases where the
+     * HTTP spec is vague (such as GET, HEAD and DELETE), requestBody is permitted but does not have well-defined
+     * semantics and SHOULD be avoided if possible.
+     */
+    requestBody: z.ZodOptional<z.ZodAny>;
+    /**
+     * Request parameters
+     */
+    parameters: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        in: z.ZodEnum<["path", "query", "header", "cookie"]>;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        required: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        deprecated: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        schema: z.ZodOptional<z.ZodUnknown>;
+        content: z.ZodOptional<z.ZodUnknown>;
+        style: z.ZodOptional<z.ZodEnum<["matrix", "simple", "form", "label", "spaceDelimited", "pipeDelimited", "deepObject"]>>;
+    }, "strip", z.ZodTypeAny, {
+        required: boolean;
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        deprecated: boolean;
+        description?: string | undefined;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+    }, {
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        required?: boolean | undefined;
+        description?: string | undefined;
+        deprecated?: boolean | undefined;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+    }>, "many">>;
+    /**
+     * External documentation object
+     */
+    externalDocs: z.ZodOptional<z.ZodObject<{
+        description: z.ZodOptional<z.ZodString>;
+        url: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        url: string;
+        description?: string | undefined;
+    }, {
+        description?: string | undefined;
+        url?: string | undefined;
+    }>>;
+    deprecated: z.ZodOptional<z.ZodBoolean>;
+    /** Response formats */
+    responses: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+}, {
+    type: z.ZodDefault<z.ZodOptional<z.ZodLiteral<"request">>>;
+    uid: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /** Path Key */
+    path: z.ZodDefault<z.ZodOptional<z.ZodString>>;
+    /** Request Method */
+    method: z.ZodDefault<z.ZodEnum<["connect", "delete", "get", "head", "options", "patch", "post", "put", "trace"]>>;
+    /** List of server UIDs specific to the request */
+    servers: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+    /** The currently selected server */
+    selectedServerUid: z.ZodDefault<z.ZodString>;
+    /** List of example UIDs associated with the request */
+    examples: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+    /** List of security scheme UIDs associated with the request */
+    selectedSecuritySchemeUids: z.ZodDefault<z.ZodArray<z.ZodDefault<z.ZodOptional<z.ZodString>>, "many">>;
+}>, "strip", z.ZodTypeAny, {
+    path: string;
+    type: "request";
+    uid: string;
+    selectedServerUid: string;
+    servers: string[];
+    examples: string[];
+    method: "options" | "delete" | "get" | "connect" | "head" | "patch" | "post" | "put" | "trace";
+    selectedSecuritySchemeUids: string[];
+    description?: string | undefined;
+    summary?: string | undefined;
+    externalDocs?: {
+        url: string;
+        description?: string | undefined;
+    } | undefined;
+    security?: Record<string, string[]>[] | undefined;
+    tags?: string[] | undefined;
+    deprecated?: boolean | undefined;
+    operationId?: string | undefined;
+    parameters?: {
+        required: boolean;
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        deprecated: boolean;
+        description?: string | undefined;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+    }[] | undefined;
+    requestBody?: any;
+    responses?: Record<string, any> | undefined;
+}, {
+    path?: string | undefined;
+    type?: "request" | undefined;
+    uid?: string | undefined;
+    description?: string | undefined;
+    summary?: string | undefined;
+    externalDocs?: {
+        description?: string | undefined;
+        url?: string | undefined;
+    } | undefined;
+    security?: Record<string, string[] | undefined>[] | undefined;
+    selectedServerUid?: string | undefined;
+    servers?: (string | undefined)[] | undefined;
+    tags?: string[] | undefined;
+    deprecated?: boolean | undefined;
+    examples?: (string | undefined)[] | undefined;
+    operationId?: string | undefined;
+    method?: "options" | "delete" | "get" | "connect" | "head" | "patch" | "post" | "put" | "trace" | undefined;
+    parameters?: {
+        name: string;
+        in: "path" | "query" | "header" | "cookie";
+        required?: boolean | undefined;
+        description?: string | undefined;
+        deprecated?: boolean | undefined;
+        schema?: unknown;
+        content?: unknown;
+        style?: "matrix" | "simple" | "form" | "label" | "spaceDelimited" | "pipeDelimited" | "deepObject" | undefined;
+    }[] | undefined;
+    requestBody?: any;
+    responses?: Record<string, any> | undefined;
+    selectedSecuritySchemeUids?: (string | undefined)[] | undefined;
+}>;
+export type Request = z.infer<typeof requestSchema>;
+export type RequestPayload = z.input<typeof requestSchema>;
+//# sourceMappingURL=requests.d.ts.map

package/dist/entities/spec/requests.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"requests.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/requests.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAIvC,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAA;AAIxD,eAAO,MAAM,cAAc,2FAUjB,CAAA;AAEV,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,cAAc,CAAC,CAAC,MAAM,CAAC,CAAA;AAE3D,0DAA0D;AAC1D,MAAM,MAAM,gBAAgB,CAAC,gBAAgB,GAAG,OAAO,IAAI,IAAI,CAC7D,QAAQ,EACR,SAAS,CACV,GAAG;IACF,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,wCAAwC;IACxC,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,kCAAkC;IAClC,QAAQ,EAAE,MAAM,CAAA;IAChB,wBAAwB;IACxB,IAAI,EAAE,gBAAgB,CAAA;IACtB,0BAA0B;IAC1B,MAAM,EAAE,MAAM,CAAA;IACd,0BAA0B;IAC1B,MAAM,EAAE,aAAa,CAAA;IACrB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,iEAAiE;AACjE,MAAM,MAAM,YAAY,GAAG;IACzB,OAAO,EAAE,cAAc,CAAA;IACvB,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAMD,2CAA2C;AAC3C,eAAO,MAAM,gBAAgB;IAC3B;;;;;OAKG;;IAEH,kDAAkD;;IAElD,mHAAmH;;IAEnH;;;;OAIG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;;;;;;;;;;;IAGH,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAE0B,CAAA;AA0BnD,8CAA8C;AAC9C,eAAO,MAAM,aAAa;IAtExB;;;;;OAKG;;IAEH,kDAAkD;;IAElD,mHAAmH;;IAEnH;;;;OAIG;;IAEH;;;;;;OAMG;;IAEH;;;;;OAKG;;IAEH;;OAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEH;;OAEG;;;;;;;;;;;;IAGH,uBAAuB;;;;;IAcvB,eAAe;;IAEf,qBAAqB;;IAErB,kDAAkD;;IAElD,oCAAoC;;IAEpC,uDAAuD;;IAEvD,+DAA+D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAKS,CAAA;AAC1E,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA;AACnD,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAA"}

package/dist/entities/{workspace/spec → spec}/requests.js

@@ -1,23 +1,28 @@
-import { deepMerge } from '@scalar/object-utils/merge';
 import { z } from 'zod';
-import { $refSchema } from './refs.js';
-import { REQUEST_METHODS } from '../../../helpers/httpMethods.js';
+import { oasParameterSchema } from './parameters.js';
+import { oasSecurityRequirementSchema } from './security.js';
+import { oasExternalDocumentationSchema } from './spec-objects.js';
 import { nanoidSchema } from '../shared/utility.js';
-import { securityRequirement } from '../security/security-requirement.js';
 
+const requestMethods = [
+    'connect',
+    'delete',
+    'get',
+    'head',
+    'options',
+    'patch',
+    'post',
+    'put',
+    'trace',
+];
 const requestBodySchema = z.any();
-const parametersSchema = z.record(z.string(), z.any());
-const requestSchema = z.object({
-    path: z.string().optional().default(''),
-    method: z
-        .enum(Object.keys(REQUEST_METHODS))
-        .optional()
-        .default('GET'),
-    uid: nanoidSchema,
-    ref: $refSchema.nullable().default(null),
+/** Open API Compliant Request Validator */
+const oasRequestSchema = z.object({
     /**
      * A list of tags for API documentation control. Tags can be used for logical
      * grouping of operations by resources or any other qualifier.
+     *
+     * These tags are the openapi spec tag names, not uids
      */
     tags: z.string().array().optional(),
     /** A short summary of what the operation does. */
@@ -30,14 +35,6 @@ const requestSchema = z.object({
      * operation, therefore, it is RECOMMENDED to follow bin common programming naming conventions./
      */
     operationId: z.string().optional(),
-    parameters: z
-        .object({
-        path: parametersSchema,
-        query: parametersSchema,
-        headers: parametersSchema,
-        cookies: parametersSchema,
-    })
-        .default({ path: {}, query: {}, headers: {}, cookies: {} }),
     /**
      * A declaration of which security mechanisms can be used across the API. The list of
      * values includes alternative security requirement objects that can be used. Only
@@ -45,11 +42,7 @@ const requestSchema = z.object({
      * Individual operations can override this definition. To make security optional, an empty
      * security requirement ({}) can be included in the array.
      */
-    security: z.array(securityRequirement).optional(),
-    /** Security schemes which have been created specifically for this request */
-    securitySchemeUids: z.array(nanoidSchema).optional().default([]),
-    /** The currently selected security schemes at the request level */
-    selectedSecuritySchemeUids: z.array(nanoidSchema).default([]),
+    security: z.array(oasSecurityRequirementSchema).optional(),
     /**
      * The request body applicable for this operation. The requestBody is fully supported in HTTP methods where the
      * HTTP 1.1 specification [RFC7231] has explicitly defined semantics for request bodies. In other cases where the
@@ -57,11 +50,42 @@ const requestSchema = z.object({
      * semantics and SHOULD be avoided if possible.
      */
     requestBody: requestBodySchema.optional(),
-    /** Ordered exampleUids for the sidenav */
-    childUids: nanoidSchema.array().default([]),
-    history: z.any().array().default([]),
+    /**
+     * Request parameters
+     */
+    parameters: oasParameterSchema.array().optional(),
+    /**
+     * External documentation object
+     */
+    externalDocs: oasExternalDocumentationSchema.optional(),
+    deprecated: z.boolean().optional(),
+    /** Response formats */
+    responses: z.record(z.string(), z.any()).optional(),
+});
+/**
+ * Extended properties added to the spec definition for client usage
+ *
+ * WARNING: DO NOT ADD PROPERTIES THAT SHARE A NAME WITH OAS OPERATION ENTITIES
+ *
+ * This object is directly converted to a spec operation during saving
+ */
+const extendedRequestSchema = z.object({
+    type: z.literal('request').optional().default('request'),
+    uid: nanoidSchema,
+    /** Path Key */
+    path: z.string().optional().default(''),
+    /** Request Method */
+    method: z.enum(requestMethods).default('get'),
+    /** List of server UIDs specific to the request */
+    servers: nanoidSchema.array().default([]),
+    /** The currently selected server */
+    selectedServerUid: z.string().default(''),
+    /** List of example UIDs associated with the request */
+    examples: nanoidSchema.array().default([]),
+    /** List of security scheme UIDs associated with the request */
+    selectedSecuritySchemeUids: nanoidSchema.array().default([]),
 });
-/** Create request helper */
-const createRequest = (payload) => deepMerge(requestSchema.parse({}), payload);
+/** Unified request schema for client usage */
+const requestSchema = oasRequestSchema.merge(extendedRequestSchema);
 
-export { createRequest };
+export { oasRequestSchema, requestMethods, requestSchema };