@scalar/oas-utils 0.11.0 → 0.12.0

package/dist/entities/spec/collection.js

@@ -1,95 +0,0 @@
-import { oasSecurityRequirementSchema } from '@scalar/types/entities';
-import { nanoidSchema } from '@scalar/types/utils';
-import { z } from 'zod';
-import { selectedSecuritySchemeUidSchema } from '../../entities/shared/utility.js';
-import { xScalarEnvironmentsSchema } from '../../entities/spec/x-scalar-environments.js';
-import { xScalarSecretsSchema } from '../../entities/spec/x-scalar-secrets.js';
-import { oasExternalDocumentationSchema, oasInfoSchema } from './spec-objects.js';
-const oasCollectionSchema = z.object({
-    /**
-     * @deprecated
-     * Needs to be remove as it is not a spec property
-     */
-    'type': z.literal('collection').optional().default('collection'),
-    'openapi': z
-        .union([z.string(), z.literal('3.0.0'), z.literal('3.1.0'), z.literal('4.0.0')])
-        .optional()
-        .default('3.1.0'),
-    'jsonSchemaDialect': z.string().optional(),
-    'info': oasInfoSchema.catch({
-        title: 'API',
-        version: '1.0',
-    }),
-    /**
-     * 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.array(oasSecurityRequirementSchema).optional().default([]),
-    'externalDocs': oasExternalDocumentationSchema.optional().catch(undefined),
-    /** TODO: Type these */
-    'components': z.record(z.string(), z.unknown()).optional(),
-    /** TODO: Type these */
-    'webhooks': z.record(z.string(), z.unknown()).optional(),
-    /** A custom icon representing the collection */
-    'x-scalar-icon': z.string().optional().default('interface-content-folder'),
-    'x-scalar-active-environment': z.string().optional(),
-    'x-scalar-environments': xScalarEnvironmentsSchema.optional(),
-    'x-scalar-secrets': xScalarSecretsSchema.optional(),
-    // These properties will be stripped out and mapped back as id lists
-    // servers
-    // paths/**
-    // servers
-    // tags
-    // security
-});
-const extendedCollectionSchema = z.object({
-    uid: nanoidSchema.brand(),
-    /** A list of security schemes UIDs associated with the collection */
-    securitySchemes: z.string().array().default([]),
-    /** List of currently selected security scheme UIDs, these can be overridden per request */
-    selectedSecuritySchemeUids: selectedSecuritySchemeUidSchema,
-    /** The currently selected server */
-    selectedServerUid: z.string().brand().optional(),
-    /** UIDs which refer to servers on the workspace base */
-    servers: z.string().brand().array().default([]),
-    /** Request UIDs associated with a collection */
-    requests: z.string().brand().array().default([]),
-    /** Tag UIDs associated with the collection */
-    tags: z.string().brand().array().default([]),
-    /** List of requests without tags and top level tag "folders" */
-    children: z
-        .union([z.string().brand(), z.string().brand()])
-        .array()
-        .default([]),
-    /**
-     * A link to where this document is stored
-     *
-     * - Used for watch mode
-     * - Possibly useful for Git sync down the line
-     */
-    documentUrl: z.string().optional(),
-    /**
-     * Enables polling of OpenAPI document urls
-     *
-     * @remarks Only effective when `documentUrl` is set
-     */
-    watchMode: z.boolean().optional().default(false),
-    /** Keeps track of which integration is associated with the specific collection */
-    integration: z.string().nullable().optional(),
-    /**
-     * Selected authentication will be set at the collection level instead of the request level
-     *
-     * @default false
-     */
-    useCollectionSecurity: z.boolean().optional().default(false),
-    /**
-     * Status of the watcher from above
-     *
-     * @defaults to idle for all collections, doesn't mean that it can watch for changes
-     */
-    watchModeStatus: z.enum(['IDLE', 'WATCHING', 'ERROR']).optional().default('IDLE'),
-});
-export const collectionSchema = oasCollectionSchema.merge(extendedCollectionSchema);

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

@@ -1,12 +0,0 @@
-/** Re-exported here for ease of use but we should use the other ones directly */
-export { type Oauth2Flow, type Oauth2FlowPayload, type SecuritySchemaHttp, type SecuritySchemaOpenId, type SecurityScheme, type SecuritySchemeApiKey, type SecuritySchemeOauth2, type SecuritySchemeOauth2Payload, type SecuritySchemePayload, oasSecurityRequirementSchema, oasSecuritySchemeSchema, pkceOptions, securityApiKeySchema, securityHttpSchema, securityOauthSchema, securityOpenIdSchema, securitySchemeSchema, } from '@scalar/types/entities';
-export { type Collection, type CollectionPayload, collectionSchema } from './collection.js';
-export { type Operation, type OperationPayload, operationSchema, } from './operation.js';
-export { type RequestParameter, type RequestParameterPayload, oasParameterSchema } from './parameters.js';
-export { type RequestExample, type RequestExampleParameter, createExampleFromRequest, requestExampleParametersSchema, requestExampleSchema, } from './request-examples.js';
-export { type Request, type RequestEvent, type RequestMethod, type RequestPayload, type ResponseInstance, requestSchema, } from './requests.js';
-export type { PostResponseScript, PostResponseScripts, } from './requests.ts';
-export { type Server, type ServerPayload, serverSchema } from './server.js';
-export { type Tag, type TagPayload, oasContactSchema, oasExternalDocumentationSchema, oasInfoSchema, oasLicenseSchema, tagSchema, } from './spec-objects.js';
-export { type XScalarEnvironment, type XScalarEnvironments, xScalarEnvironmentsSchema, } from './x-scalar-environments.js';
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/index.ts"],"names":[],"mappings":"AAAA,iFAAiF;AACjF,OAAO,EACL,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,cAAc,EACnB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,KAAK,2BAA2B,EAChC,KAAK,qBAAqB,EAC1B,4BAA4B,EAC5B,uBAAuB,EACvB,WAAW,EACX,oBAAoB,EACpB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,GACrB,MAAM,wBAAwB,CAAA;AAE/B,OAAO,EAAE,KAAK,UAAU,EAAE,KAAK,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AACxF,OAAO,EACL,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,eAAe,GAChB,MAAM,aAAa,CAAA;AACpB,OAAO,EAAE,KAAK,gBAAgB,EAAE,KAAK,uBAAuB,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AACtG,OAAO,EACL,KAAK,cAAc,EACnB,KAAK,uBAAuB,EAC5B,wBAAwB,EACxB,8BAA8B,EAC9B,oBAAoB,GACrB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,aAAa,GACd,MAAM,YAAY,CAAA;AACnB,YAAY,EACV,kBAAkB,EAClB,mBAAmB,GACpB,MAAM,eAAe,CAAA;AACtB,OAAO,EAAE,KAAK,MAAM,EAAE,KAAK,aAAa,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AACxE,OAAO,EACL,KAAK,GAAG,EACR,KAAK,UAAU,EACf,gBAAgB,EAChB,8BAA8B,EAC9B,aAAa,EACb,gBAAgB,EAChB,SAAS,GACV,MAAM,gBAAgB,CAAA;AACvB,OAAO,EACL,KAAK,kBAAkB,EACvB,KAAK,mBAAmB,EACxB,yBAAyB,GAC1B,MAAM,yBAAyB,CAAA"}

package/dist/entities/spec/index.js

@@ -1,10 +0,0 @@
-/** Re-exported here for ease of use but we should use the other ones directly */
-export { oasSecurityRequirementSchema, oasSecuritySchemeSchema, pkceOptions, securityApiKeySchema, securityHttpSchema, securityOauthSchema, securityOpenIdSchema, securitySchemeSchema, } from '@scalar/types/entities';
-export { collectionSchema } from './collection.js';
-export { operationSchema, } from './operation.js';
-export { oasParameterSchema } from './parameters.js';
-export { createExampleFromRequest, requestExampleParametersSchema, requestExampleSchema, } from './request-examples.js';
-export { requestSchema, } from './requests.js';
-export { serverSchema } from './server.js';
-export { oasContactSchema, oasExternalDocumentationSchema, oasInfoSchema, oasLicenseSchema, tagSchema, } from './spec-objects.js';
-export { xScalarEnvironmentsSchema, } from './x-scalar-environments.js';

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

@@ -1,99 +0,0 @@
-/**
- * Aliases Request to Operation which is closer to the spec,
- * also will not conflict with the builtin Request class
- */
-import { type RequestPayload, type Request as RequestType } from './requests.js';
-export type Operation = RequestType;
-export type OperationPayload = RequestPayload;
-export declare const operationSchema: import("zod").ZodObject<{
-    description: import("zod").ZodOptional<import("zod").ZodString>;
-    summary: import("zod").ZodOptional<import("zod").ZodString>;
-    externalDocs: import("zod").ZodOptional<import("zod").ZodPipe<import("zod").ZodObject<{
-        description: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        url: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>, import("zod").ZodTransform<{
-        url: string;
-        description?: string | undefined;
-    }, {
-        url: string;
-        description?: string | undefined;
-    }>>>;
-    'x-internal': import("zod").ZodOptional<import("zod").ZodBoolean>;
-    'x-scalar-ignore': import("zod").ZodOptional<import("zod").ZodBoolean>;
-    security: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>>>>>;
-    tags: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
-    deprecated: import("zod").ZodOptional<import("zod").ZodBoolean>;
-    operationId: import("zod").ZodOptional<import("zod").ZodString>;
-    requestBody: import("zod").ZodOptional<import("zod").ZodAny>;
-    parameters: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-        in: import("zod").ZodEnum<{
-            cookie: "cookie";
-            path: "path";
-            query: "query";
-            header: "header";
-        }>;
-        name: import("zod").ZodString;
-        description: import("zod").ZodOptional<import("zod").ZodString>;
-        required: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
-        deprecated: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
-        schema: import("zod").ZodOptional<import("zod").ZodUnknown>;
-        content: import("zod").ZodOptional<import("zod").ZodUnknown>;
-        style: import("zod").ZodOptional<import("zod").ZodEnum<{
-            matrix: "matrix";
-            label: "label";
-            form: "form";
-            simple: "simple";
-            spaceDelimited: "spaceDelimited";
-            pipeDelimited: "pipeDelimited";
-            deepObject: "deepObject";
-        }>>;
-        explode: import("zod").ZodOptional<import("zod").ZodBoolean>;
-        example: import("zod").ZodOptional<import("zod").ZodUnknown>;
-        examples: import("zod").ZodOptional<import("zod").ZodUnion<readonly [import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodObject<{
-            value: import("zod").ZodOptional<import("zod").ZodUnknown>;
-            summary: import("zod").ZodOptional<import("zod").ZodString>;
-            externalValue: import("zod").ZodOptional<import("zod").ZodString>;
-        }, import("zod/v4/core").$strip>>, import("zod").ZodArray<import("zod").ZodUnknown>]>>;
-    }, import("zod/v4/core").$strip>>>;
-    responses: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>;
-    callbacks: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodAny>>>>;
-    'x-codeSamples': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-        lang: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        label: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        source: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>>>>;
-    'x-code-samples': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-        lang: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        label: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        source: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>>>>;
-    'x-custom-examples': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodObject<{
-        lang: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        label: import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodString>>;
-        source: import("zod").ZodString;
-    }, import("zod/v4/core").$strip>>>>;
-    'x-scalar-stability': import("zod").ZodCatch<import("zod").ZodOptional<import("zod").ZodEnum<{
-        deprecated: import("@scalar/types/legacy").XScalarStability.Deprecated;
-        experimental: import("@scalar/types/legacy").XScalarStability.Experimental;
-        stable: import("@scalar/types/legacy").XScalarStability.Stable;
-    }>>>;
-    type: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodLiteral<"request">>>;
-    uid: import("zod/v4/core").$ZodBranded<import("zod").ZodDefault<import("zod").ZodString>, "operation", "out">;
-    path: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodString>>;
-    method: import("zod").ZodDefault<import("zod").ZodEnum<{
-        delete: "delete";
-        get: "get";
-        head: "head";
-        options: "options";
-        patch: "patch";
-        post: "post";
-        put: "put";
-        trace: "trace";
-    }>>;
-    servers: import("zod").ZodDefault<import("zod").ZodArray<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "server", "out">>>;
-    selectedServerUid: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodOptional<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "server", "out">>>>;
-    examples: import("zod").ZodDefault<import("zod").ZodArray<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "example", "out">>>;
-    selectedSecuritySchemeUids: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodUnion<readonly [import("zod/v4/core").$ZodBranded<import("zod").ZodString, "securityScheme", "out">, import("zod").ZodArray<import("zod/v4/core").$ZodBranded<import("zod").ZodString, "securityScheme", "out">>]>>>;
-    'x-post-response': import("zod").ZodOptional<import("zod").ZodString>;
-}, import("zod/v4/core").$strip>;
-//# sourceMappingURL=operation.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"operation.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/operation.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,KAAK,cAAc,EAAE,KAAK,OAAO,IAAI,WAAW,EAAiB,MAAM,YAAY,CAAA;AAE5F,MAAM,MAAM,SAAS,GAAG,WAAW,CAAA;AACnC,MAAM,MAAM,gBAAgB,GAAG,cAAc,CAAA;AAC7C,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gCAAgB,CAAA"}

package/dist/entities/spec/operation.js

@@ -1,6 +0,0 @@
-/**
- * Aliases Request to Operation which is closer to the spec,
- * also will not conflict with the builtin Request class
- */
-import { requestSchema } from './requests.js';
-export const operationSchema = requestSchema;

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

@@ -1,44 +0,0 @@
-import type { OpenAPIV3_1 } from '@scalar/openapi-types';
-import { z } from 'zod';
-import type { RequestExampleParameter } from './request-examples.js';
-export type ParameterContent = Record<string, {
-    schema?: OpenAPIV3_1.Document;
-    examples?: Record<string, RequestExampleParameter>;
-    example?: RequestExampleParameter;
-}>;
-/**
- * OpenAPI compliant parameters object
- */
-export declare const oasParameterSchema: z.ZodObject<{
-    in: z.ZodEnum<{
-        cookie: "cookie";
-        path: "path";
-        query: "query";
-        header: "header";
-    }>;
-    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: "matrix";
-        label: "label";
-        form: "form";
-        simple: "simple";
-        spaceDelimited: "spaceDelimited";
-        pipeDelimited: "pipeDelimited";
-        deepObject: "deepObject";
-    }>>;
-    explode: z.ZodOptional<z.ZodBoolean>;
-    example: z.ZodOptional<z.ZodUnknown>;
-    examples: z.ZodOptional<z.ZodUnion<readonly [z.ZodRecord<z.ZodString, z.ZodObject<{
-        value: z.ZodOptional<z.ZodUnknown>;
-        summary: z.ZodOptional<z.ZodString>;
-        externalValue: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>, z.ZodArray<z.ZodUnknown>]>>;
-}, z.core.$strip>;
-export type RequestParameter = z.infer<typeof oasParameterSchema>;
-export type RequestParameterPayload = z.input<typeof oasParameterSchema>;
-//# sourceMappingURL=parameters.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"parameters.d.ts","sourceRoot":"","sources":["../../../src/entities/spec/parameters.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,WAAW,EAAE,MAAM,uBAAuB,CAAA;AACjE,OAAO,EAAkB,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvC,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oBAAoB,CAAA;AAkBjE,MAAM,MAAM,gBAAgB,GAAG,MAAM,CACnC,MAAM,EACN;IACE,MAAM,CAAC,EAAE,WAAW,CAAC,QAAQ,CAAA;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,CAAA;IAClD,OAAO,CAAC,EAAE,uBAAuB,CAAA;CAClC,CACF,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBA2BU,CAAA;AAEzC,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACjE,MAAM,MAAM,uBAAuB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/entities/spec/parameters.js

@@ -1,41 +0,0 @@
-import { z } from 'zod';
-const parameterTypeSchema = z.enum(['path', 'query', 'header', 'cookie']);
-// not used but kept for consistency
-// export type ParamType = z.infer<typeof parameterTypeSchema>
-const parameterStyleSchema = z.enum([
-    'matrix',
-    'simple',
-    'form',
-    'label',
-    'spaceDelimited',
-    'pipeDelimited',
-    'deepObject',
-]);
-/**
- * OpenAPI compliant parameters object
- */
-export const oasParameterSchema = z.object({
-    in: parameterTypeSchema,
-    name: z.string(),
-    description: z.string().optional(),
-    /** Defaulted to false */
-    required: z.boolean().optional().default(false),
-    /** Defaulted to false */
-    deprecated: z.boolean().optional().default(false),
-    schema: z.unknown().optional(),
-    content: z.unknown().optional(),
-    /** Defaulted according to @url https://spec.openapis.org/oas/v3.1.0#parameter-object */
-    style: parameterStyleSchema.optional(),
-    explode: z.boolean().optional(),
-    example: z.unknown().optional(),
-    examples: z
-        .union([
-        z.record(z.string(), z.object({
-            value: z.unknown().optional(),
-            summary: z.string().optional(),
-            externalValue: z.string().optional(),
-        })),
-        z.array(z.unknown()),
-    ])
-        .optional(),
-});