@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/typings/swagger.d.ts

@@ -0,0 +1,217 @@
+import type { Schema } from 'js-yaml';
+import type { Referenced } from './openapi';
+export interface Oas2Definition {
+    swagger: '2.0';
+    info?: Oas2Info;
+    paths?: Oas2Paths;
+    basePath?: string;
+    schemes?: string[];
+    consumes?: string[];
+    produces?: string[];
+    definitions?: Record<string, Oas2Schema>;
+    responses?: Record<string, Oas2Response>;
+    parameters?: Record<string, Oas2Parameter>;
+    securityDefinitions?: Record<string, Oas2SecurityScheme>;
+    security?: Oas2SecurityRequirement[];
+    tags?: Oas2Tag[];
+    externalDocs?: Oas2ExternalDocs;
+}
+export interface Oas2Components {
+    definitions?: {
+        [name: string]: Record<string, Oas2Schema>;
+    };
+    securityDefinitions?: {
+        [name: string]: Record<string, Oas2SecurityScheme>;
+    };
+    responses?: {
+        [name: string]: Record<string, Oas2Response>;
+    };
+    parameters?: {
+        [name: string]: Record<string, Oas2Parameter>;
+    };
+}
+export interface Oas2Info {
+    title: string;
+    version: string;
+    description?: string;
+    termsOfService?: string;
+    contact?: Oas2Contact;
+    license?: Oas2License;
+}
+export interface Oas2Paths {
+    [path: string]: Oas2PathItem;
+}
+export interface Oas2PathItem {
+    get?: Oas2Operation;
+    put?: Oas2Operation;
+    post?: Oas2Operation;
+    delete?: Oas2Operation;
+    options?: Oas2Operation;
+    head?: Oas2Operation;
+    patch?: Oas2Operation;
+    parameters?: Array<Referenced<Oas2Parameter>>;
+}
+export interface Oas2XCodeSample {
+    lang: string;
+    label?: string;
+    source: string;
+}
+export interface Oas2Operation {
+    tags?: string[];
+    consumes?: string[];
+    produces?: string[];
+    schemes?: string[];
+    summary?: string;
+    description?: string;
+    externalDocs?: Oas2ExternalDocs;
+    operationId?: string;
+    parameters?: Array<Referenced<Oas2Parameter>>;
+    responses: Oas2Responses;
+    deprecated?: boolean;
+    security?: Oas2SecurityRequirement[];
+    'x-codeSamples'?: Oas2XCodeSample[];
+    'x-code-samples'?: Oas2XCodeSample[];
+    'x-hideTryItPanel'?: boolean;
+}
+export type Oas2Parameter = Oas2BodyParameter | Oas2SimpleParameter;
+export interface Oas2BodyParameter {
+    name: string;
+    in: 'body';
+    schema: Oas2Schema;
+    description?: string;
+    required?: boolean;
+}
+export interface Oas2SimpleParameter {
+    name: string;
+    in: Oas2ParameterLocation;
+    description?: string;
+    required?: boolean;
+    type: 'string' | 'number' | 'integer' | 'boolean' | 'array' | 'file';
+    format?: string;
+    allowEmptyValue?: boolean;
+    items?: Oas2Items;
+    collectionFormat?: 'csv' | 'ssv' | 'tsv' | 'pipes' | 'multi';
+    default?: any;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    enum?: any[];
+    multipleOf?: number;
+}
+export interface Oas2Items {
+    type: 'string' | 'number' | 'integer' | 'boolean' | 'array';
+    format?: string;
+    allowEmptyValue?: boolean;
+    items?: Oas2Items;
+    collectionFormat?: 'csv' | 'ssv' | 'tsv' | 'pipes' | 'multi';
+    default?: any;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    enum?: any[];
+    multipleOf?: number;
+}
+export interface Oas2Xml {
+    name?: string;
+    namespace?: string;
+    prefix?: string;
+    attribute?: string;
+    wrapped?: string;
+}
+export interface Oas2Schema {
+    $ref?: string;
+    type?: string;
+    properties?: {
+        [name: string]: Oas2Schema;
+    };
+    additionalProperties?: boolean | Oas2Schema;
+    description?: string;
+    default?: any;
+    items?: Oas2Schema;
+    required?: string[];
+    readOnly?: boolean;
+    deprecated?: boolean;
+    format?: string;
+    externalDocs?: Oas2ExternalDocs;
+    discriminator?: string;
+    nullable?: boolean;
+    allOf?: Oas2Schema[];
+    title?: string;
+    multipleOf?: number;
+    maximum?: number;
+    exclusiveMaximum?: boolean;
+    minimum?: number;
+    exclusiveMinimum?: boolean;
+    maxLength?: number;
+    minLength?: number;
+    pattern?: string;
+    maxItems?: number;
+    minItems?: number;
+    uniqueItems?: boolean;
+    maxProperties?: number;
+    minProperties?: number;
+    enum?: any[];
+    example?: any;
+    xml?: Oas2Xml;
+    'x-tags'?: string[];
+}
+export type Oas2ParameterLocation = 'query' | 'header' | 'path' | 'formData';
+export interface Oas2Responses {
+    [code: string]: Oas2Response;
+}
+export type Oas2Header = Oas2Items & {
+    description?: 'string';
+};
+export interface Oas2Response {
+    description?: string;
+    schema: Referenced<Schema>;
+    examples?: Record<string, any>;
+    headers?: Record<string, Oas2Header>;
+}
+export interface Oas2SecurityRequirement {
+    [name: string]: string[];
+}
+export interface Oas2SecurityScheme {
+    type: 'basic' | 'apiKey' | 'oauth2';
+    description?: string;
+    name?: string;
+    in?: 'query' | 'header' | 'cookie';
+    scheme?: string;
+    flow: 'implicit' | 'password' | 'application' | 'accessCode';
+    authorizationUrl?: string;
+    tokenUrl?: string;
+    scopes?: Record<string, string>;
+}
+export interface Oas2Tag {
+    name: string;
+    description?: string;
+    externalDocs?: Oas2ExternalDocs;
+    'x-displayName'?: string;
+}
+export interface Oas2ExternalDocs {
+    description?: string;
+    url: string;
+}
+export interface Oas2Contact {
+    name?: string;
+    url?: string;
+    email?: string;
+}
+export interface Oas2License {
+    name: string;
+    url?: string;
+}

package/lib/typings/swagger.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/utils.d.ts

@@ -0,0 +1,70 @@
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import type { HttpResolveConfig } from './config';
+import type { UserContext } from './walk';
+export { parseYaml, stringifyYaml } from './js-yaml';
+export type StackFrame<T> = {
+    prev: StackFrame<T> | null;
+    value: T;
+};
+export type Stack<T> = StackFrame<T> | null;
+export type StackNonEmpty<T> = StackFrame<T>;
+export declare function pushStack<T, P extends Stack<T> = Stack<T>>(head: P, value: T): {
+    prev: P;
+    value: T;
+};
+export declare function pluralize(sentence: string, count?: number, inclusive?: boolean): string;
+export declare function popStack<T, P extends Stack<T>>(head: P): StackFrame<T> | null;
+export type BundleOutputFormat = 'json' | 'yml' | 'yaml';
+export declare function loadYaml<T>(filename: string): Promise<T>;
+export declare function isDefined<T>(x: T | undefined): x is T;
+export declare function isPlainObject(value: unknown): value is Record<string, unknown>;
+export declare function isEmptyObject(value: unknown): value is Record<string, unknown>;
+export declare function isNotEmptyObject(obj: unknown): boolean;
+export declare function isEmptyArray(value: unknown): boolean;
+export declare function isNotEmptyArray<T>(args?: T[]): boolean;
+export declare function readFileFromUrl(url: string, config: HttpResolveConfig): Promise<{
+    body: any;
+    mimeType: any;
+}>;
+export declare function pickObjectProps<T extends Record<string, unknown>>(object: T, keys: Array<string>): T;
+export declare function omitObjectProps<T extends Record<string, unknown>>(object: T, keys: Array<string>): T;
+export declare function splitCamelCaseIntoWords(str: string): Set<string>;
+export declare function validateMimeType({ type, value }: any, { report, location }: UserContext, allowedValues: string[]): void;
+export declare function validateMimeTypeOAS3({ type, value }: any, { report, location }: UserContext, allowedValues: string[]): void;
+export declare function readFileAsStringSync(filePath: string): string;
+export declare function yamlAndJsonSyncReader<T>(filePath: string): T;
+export declare function isPathParameter(pathSegment: string): boolean;
+/**
+ * Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
+ */
+export declare function slash(path: string): string;
+export declare function isString(value: unknown): value is string;
+export declare function isNotString<T>(value: string | T): value is T;
+export declare const assignConfig: <T extends string | {
+    severity?: string;
+}>(target: Record<string, T>, obj?: Record<string, T>) => void;
+export declare function assignOnlyExistingConfig<T extends string | {
+    severity?: string;
+}>(target: Record<string, T>, obj?: Record<string, T>): void;
+export declare function getMatchingStatusCodeRange(code: number | string): string;
+export declare function isCustomRuleId(id: string): boolean;
+export declare function doesYamlFileExist(filePath: string): boolean;
+export declare function showWarningForDeprecatedField(deprecatedField: string, updatedField?: string, updatedObject?: string, link?: string): void;
+export declare function showErrorForDeprecatedField(deprecatedField: string, updatedField?: string, updatedObject?: string): void;
+export type Falsy = undefined | null | false | '' | 0;
+export declare function isTruthy<Truthy>(value: Truthy | Falsy): value is Truthy;
+export declare function identity<T>(value: T): T;
+export declare function keysOf<T>(obj: T): (keyof T)[];
+export declare function pickDefined<T extends Record<string, unknown>>(obj?: T): Record<string, unknown> | undefined;
+export declare function nextTick(): Promise<unknown>;
+export declare function pause(ms: number): Promise<void>;
+export declare function getProxyAgent(): HttpsProxyAgent<string> | undefined;
+/**
+ * Checks if two objects are deeply equal.
+ * Borrowed the source code from https://github.com/lukeed/dequal.
+ */
+export declare function dequal(foo: any, bar: any): boolean;
+export type CollectFn = (value: unknown) => void;
+export type StrictObject<T extends object> = T & {
+    [key: string]: undefined;
+};

package/lib/utils.js

@@ -0,0 +1,301 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assignConfig = exports.stringifyYaml = exports.parseYaml = void 0;
+exports.pushStack = pushStack;
+exports.pluralize = pluralize;
+exports.popStack = popStack;
+exports.loadYaml = loadYaml;
+exports.isDefined = isDefined;
+exports.isPlainObject = isPlainObject;
+exports.isEmptyObject = isEmptyObject;
+exports.isNotEmptyObject = isNotEmptyObject;
+exports.isEmptyArray = isEmptyArray;
+exports.isNotEmptyArray = isNotEmptyArray;
+exports.readFileFromUrl = readFileFromUrl;
+exports.pickObjectProps = pickObjectProps;
+exports.omitObjectProps = omitObjectProps;
+exports.splitCamelCaseIntoWords = splitCamelCaseIntoWords;
+exports.validateMimeType = validateMimeType;
+exports.validateMimeTypeOAS3 = validateMimeTypeOAS3;
+exports.readFileAsStringSync = readFileAsStringSync;
+exports.yamlAndJsonSyncReader = yamlAndJsonSyncReader;
+exports.isPathParameter = isPathParameter;
+exports.slash = slash;
+exports.isString = isString;
+exports.isNotString = isNotString;
+exports.assignOnlyExistingConfig = assignOnlyExistingConfig;
+exports.getMatchingStatusCodeRange = getMatchingStatusCodeRange;
+exports.isCustomRuleId = isCustomRuleId;
+exports.doesYamlFileExist = doesYamlFileExist;
+exports.showWarningForDeprecatedField = showWarningForDeprecatedField;
+exports.showErrorForDeprecatedField = showErrorForDeprecatedField;
+exports.isTruthy = isTruthy;
+exports.identity = identity;
+exports.keysOf = keysOf;
+exports.pickDefined = pickDefined;
+exports.nextTick = nextTick;
+exports.pause = pause;
+exports.getProxyAgent = getProxyAgent;
+exports.dequal = dequal;
+const fs = require("fs");
+const path_1 = require("path");
+const minimatch = require("minimatch");
+const node_fetch_1 = require("node-fetch");
+const js_yaml_1 = require("./js-yaml");
+const env_1 = require("./env");
+const logger_1 = require("./logger");
+const https_proxy_agent_1 = require("https-proxy-agent");
+const pluralizeOne = require("pluralize");
+var js_yaml_2 = require("./js-yaml");
+Object.defineProperty(exports, "parseYaml", { enumerable: true, get: function () { return js_yaml_2.parseYaml; } });
+Object.defineProperty(exports, "stringifyYaml", { enumerable: true, get: function () { return js_yaml_2.stringifyYaml; } });
+function pushStack(head, value) {
+    return { prev: head, value };
+}
+function pluralize(sentence, count, inclusive) {
+    return sentence
+        .split(' ')
+        .map((word) => pluralizeOne(word, count, inclusive))
+        .join(' ');
+}
+function popStack(head) {
+    return head?.prev ?? null;
+}
+async function loadYaml(filename) {
+    const contents = await fs.promises.readFile(filename, 'utf-8');
+    return (0, js_yaml_1.parseYaml)(contents);
+}
+function isDefined(x) {
+    return x !== undefined;
+}
+function isPlainObject(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function isEmptyObject(value) {
+    return isPlainObject(value) && Object.keys(value).length === 0;
+}
+function isNotEmptyObject(obj) {
+    return isPlainObject(obj) && !isEmptyObject(obj);
+}
+function isEmptyArray(value) {
+    return Array.isArray(value) && value.length === 0;
+}
+function isNotEmptyArray(args) {
+    return !!args && Array.isArray(args) && !!args.length;
+}
+async function readFileFromUrl(url, config) {
+    const headers = {};
+    for (const header of config.headers) {
+        if (match(url, header.matches)) {
+            headers[header.name] =
+                header.envVariable !== undefined ? env_1.env[header.envVariable] || '' : header.value;
+        }
+    }
+    const req = await (config.customFetch || node_fetch_1.default)(url, {
+        headers: headers,
+    });
+    if (!req.ok) {
+        throw new Error(`Failed to load ${url}: ${req.status} ${req.statusText}`);
+    }
+    return { body: await req.text(), mimeType: req.headers.get('content-type') };
+}
+function match(url, pattern) {
+    if (!pattern.match(/^https?:\/\//)) {
+        // if pattern doesn't specify protocol directly, do not match against it
+        url = url.replace(/^https?:\/\//, '');
+    }
+    return minimatch(url, pattern);
+}
+function pickObjectProps(object, keys) {
+    return Object.fromEntries(keys.filter((key) => key in object).map((key) => [key, object[key]]));
+}
+function omitObjectProps(object, keys) {
+    return Object.fromEntries(Object.entries(object).filter(([key]) => !keys.includes(key)));
+}
+function splitCamelCaseIntoWords(str) {
+    const camel = str
+        .split(/(?:[-._])|([A-Z][a-z]+)/)
+        .filter(isTruthy)
+        .map((item) => item.toLocaleLowerCase());
+    const caps = str
+        .split(/([A-Z]{2,})/)
+        .filter((e) => e && e === e.toUpperCase())
+        .map((item) => item.toLocaleLowerCase());
+    return new Set([...camel, ...caps]);
+}
+function validateMimeType({ type, value }, { report, location }, allowedValues) {
+    const ruleType = type === 'consumes' ? 'request' : 'response';
+    if (!allowedValues)
+        throw new Error(`Parameter "allowedValues" is not provided for "${ruleType}-mime-type" rule`);
+    if (!value[type])
+        return;
+    for (const mime of value[type]) {
+        if (!allowedValues.includes(mime)) {
+            report({
+                message: `Mime type "${mime}" is not allowed`,
+                location: location.child(value[type].indexOf(mime)).key(),
+            });
+        }
+    }
+}
+function validateMimeTypeOAS3({ type, value }, { report, location }, allowedValues) {
+    const ruleType = type === 'consumes' ? 'request' : 'response';
+    if (!allowedValues)
+        throw new Error(`Parameter "allowedValues" is not provided for "${ruleType}-mime-type" rule`);
+    if (!value.content)
+        return;
+    for (const mime of Object.keys(value.content)) {
+        if (!allowedValues.includes(mime)) {
+            report({
+                message: `Mime type "${mime}" is not allowed`,
+                location: location.child('content').child(mime).key(),
+            });
+        }
+    }
+}
+function readFileAsStringSync(filePath) {
+    return fs.readFileSync(filePath, 'utf-8');
+}
+function yamlAndJsonSyncReader(filePath) {
+    const content = fs.readFileSync(filePath, 'utf-8');
+    return (0, js_yaml_1.parseYaml)(content);
+}
+function isPathParameter(pathSegment) {
+    return pathSegment.startsWith('{') && pathSegment.endsWith('}');
+}
+/**
+ * Convert Windows backslash paths to slash paths: foo\\bar ➔ foo/bar
+ */
+function slash(path) {
+    const isExtendedLengthPath = /^\\\\\?\\/.test(path);
+    if (isExtendedLengthPath) {
+        return path;
+    }
+    return path.replace(/\\/g, '/');
+}
+// TODO: use it everywhere
+function isString(value) {
+    return typeof value === 'string';
+}
+function isNotString(value) {
+    return !isString(value);
+}
+const assignConfig = (target, obj) => {
+    if (!obj)
+        return;
+    for (const k of Object.keys(obj)) {
+        if (isPlainObject(target[k]) && typeof obj[k] === 'string') {
+            target[k].severity = obj[k];
+        }
+        else {
+            target[k] = obj[k];
+        }
+    }
+};
+exports.assignConfig = assignConfig;
+function assignOnlyExistingConfig(target, obj) {
+    if (!obj)
+        return;
+    for (const k of Object.keys(obj)) {
+        if (!target.hasOwnProperty(k))
+            continue;
+        if (isPlainObject(target[k]) && typeof obj[k] === 'string') {
+            target[k].severity = obj[k];
+        }
+        else {
+            target[k] = obj[k];
+        }
+    }
+}
+function getMatchingStatusCodeRange(code) {
+    return `${code}`.replace(/^(\d)\d\d$/, (_, firstDigit) => `${firstDigit}XX`);
+}
+function isCustomRuleId(id) {
+    return id.includes('/');
+}
+function doesYamlFileExist(filePath) {
+    return (((0, path_1.extname)(filePath) === '.yaml' || (0, path_1.extname)(filePath) === '.yml') &&
+        fs?.hasOwnProperty?.('existsSync') &&
+        fs.existsSync(filePath));
+}
+function showWarningForDeprecatedField(deprecatedField, updatedField, updatedObject, link) {
+    const readMoreText = link ? `Read more about this change: ${link}` : '';
+    logger_1.logger.warn(`The '${logger_1.colorize.red(deprecatedField)}' field is deprecated. ${updatedField
+        ? `Use ${logger_1.colorize.green(getUpdatedFieldName(updatedField, updatedObject))} instead. `
+        : ''}${readMoreText}\n`);
+}
+function showErrorForDeprecatedField(deprecatedField, updatedField, updatedObject) {
+    throw new Error(`Do not use '${deprecatedField}' field. ${updatedField ? `Use '${getUpdatedFieldName(updatedField, updatedObject)}' instead. ` : ''}\n`);
+}
+function isTruthy(value) {
+    return !!value;
+}
+function identity(value) {
+    return value;
+}
+function keysOf(obj) {
+    if (!obj)
+        return [];
+    return Object.keys(obj);
+}
+function pickDefined(obj) {
+    if (!obj)
+        return undefined;
+    const res = {};
+    for (const key in obj) {
+        if (obj[key] !== undefined) {
+            res[key] = obj[key];
+        }
+    }
+    return res;
+}
+function nextTick() {
+    return new Promise((resolve) => {
+        setTimeout(resolve);
+    });
+}
+async function pause(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function getUpdatedFieldName(updatedField, updatedObject) {
+    return `${typeof updatedObject !== 'undefined' ? `${updatedObject}.` : ''}${updatedField}`;
+}
+function getProxyAgent() {
+    const proxy = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
+    return proxy ? new https_proxy_agent_1.HttpsProxyAgent(proxy) : undefined;
+}
+/**
+ * Checks if two objects are deeply equal.
+ * Borrowed the source code from https://github.com/lukeed/dequal.
+ */
+function dequal(foo, bar) {
+    let ctor, len;
+    if (foo === bar)
+        return true;
+    if (foo && bar && (ctor = foo.constructor) === bar.constructor) {
+        if (ctor === Date)
+            return foo.getTime() === bar.getTime();
+        if (ctor === RegExp)
+            return foo.toString() === bar.toString();
+        if (ctor === Array) {
+            if ((len = foo.length) === bar.length) {
+                while (len-- && dequal(foo[len], bar[len]))
+                    ;
+            }
+            return len === -1;
+        }
+        if (!ctor || typeof foo === 'object') {
+            len = 0;
+            for (ctor in foo) {
+                if (Object.prototype.hasOwnProperty.call(foo, ctor) &&
+                    ++len &&
+                    !Object.prototype.hasOwnProperty.call(bar, ctor))
+                    return false;
+                if (!(ctor in bar) || !dequal(foo[ctor], bar[ctor]))
+                    return false;
+            }
+            return Object.keys(bar).length === len;
+        }
+    }
+    return foo !== foo && bar !== bar;
+}