@redocly/openapi-core 0.0.0-snapshot.1737554067

package/lib/resolve.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseResolver = exports.YamlParseError = exports.ResolveError = exports.Source = void 0;
+exports.makeRefId = makeRefId;
+exports.makeDocumentFromString = makeDocumentFromString;
+exports.resolveDocument = resolveDocument;
+const fs = require("fs");
+const path = require("path");
+const ref_utils_1 = require("./ref-utils");
+const types_1 = require("./types");
+const utils_1 = require("./utils");
+class Source {
+    constructor(absoluteRef, body, mimeType) {
+        this.absoluteRef = absoluteRef;
+        this.body = body;
+        this.mimeType = mimeType;
+    }
+    // pass safeLoad as argument to separate it from browser bundle
+    getAst(safeLoad) {
+        if (this._ast === undefined) {
+            this._ast = safeLoad(this.body, { filename: this.absoluteRef }) ?? undefined;
+            // fix ast representation of file with newlines only
+            if (this._ast &&
+                this._ast.kind === 0 && // KIND.scalar = 0
+                this._ast.value === '' &&
+                this._ast.startPosition !== 1) {
+                this._ast.startPosition = 1;
+                this._ast.endPosition = 1;
+            }
+        }
+        return this._ast;
+    }
+    getLines() {
+        if (this._lines === undefined) {
+            this._lines = this.body.split(/\r\n|[\n\r]/g);
+        }
+        return this._lines;
+    }
+}
+exports.Source = Source;
+class ResolveError extends Error {
+    constructor(originalError) {
+        super(originalError.message);
+        this.originalError = originalError;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, ResolveError.prototype);
+    }
+}
+exports.ResolveError = ResolveError;
+const jsYamlErrorLineColRegexp = /\((\d+):(\d+)\)$/;
+class YamlParseError extends Error {
+    constructor(originalError, source) {
+        super(originalError.message.split('\n')[0]);
+        this.originalError = originalError;
+        this.source = source;
+        // Set the prototype explicitly.
+        Object.setPrototypeOf(this, YamlParseError.prototype);
+        const [, line, col] = this.message.match(jsYamlErrorLineColRegexp) || [];
+        this.line = parseInt(line, 10);
+        this.col = parseInt(col, 10);
+    }
+}
+exports.YamlParseError = YamlParseError;
+function makeRefId(absoluteRef, pointer) {
+    return absoluteRef + '::' + pointer;
+}
+function makeDocumentFromString(sourceString, absoluteRef) {
+    const source = new Source(absoluteRef, sourceString);
+    try {
+        return {
+            source,
+            parsed: (0, utils_1.parseYaml)(sourceString, { filename: absoluteRef }),
+        };
+    }
+    catch (e) {
+        throw new YamlParseError(e, source);
+    }
+}
+class BaseResolver {
+    constructor(config = { http: { headers: [] } }) {
+        this.config = config;
+        this.cache = new Map();
+    }
+    getFiles() {
+        return new Set(Array.from(this.cache.keys()));
+    }
+    resolveExternalRef(base, ref) {
+        if ((0, ref_utils_1.isAbsoluteUrl)(ref)) {
+            return ref;
+        }
+        if (base && (0, ref_utils_1.isAbsoluteUrl)(base)) {
+            return new URL(ref, base).href;
+        }
+        return path.resolve(base ? path.dirname(base) : process.cwd(), ref);
+    }
+    async loadExternalRef(absoluteRef) {
+        try {
+            if ((0, ref_utils_1.isAbsoluteUrl)(absoluteRef)) {
+                const { body, mimeType } = await (0, utils_1.readFileFromUrl)(absoluteRef, this.config.http);
+                return new Source(absoluteRef, body, mimeType);
+            }
+            else {
+                if (fs.lstatSync(absoluteRef).isDirectory()) {
+                    throw new Error(`Expected a file but received a folder at ${absoluteRef}.`);
+                }
+                const content = await fs.promises.readFile(absoluteRef, 'utf-8');
+                // In some cases file have \r\n line delimeters like on windows, we should skip it.
+                return new Source(absoluteRef, content.replace(/\r\n/g, '\n'));
+            }
+        }
+        catch (error) {
+            error.message = error.message.replace(', lstat', '');
+            throw new ResolveError(error);
+        }
+    }
+    parseDocument(source, isRoot = false) {
+        const ext = source.absoluteRef.substr(source.absoluteRef.lastIndexOf('.'));
+        if (!['.json', '.json', '.yml', '.yaml'].includes(ext) &&
+            !source.mimeType?.match(/(json|yaml|openapi)/) &&
+            !isRoot // always parse root
+        ) {
+            return { source, parsed: source.body };
+        }
+        try {
+            return {
+                source,
+                parsed: (0, utils_1.parseYaml)(source.body, { filename: source.absoluteRef }),
+            };
+        }
+        catch (e) {
+            throw new YamlParseError(e, source);
+        }
+    }
+    async resolveDocument(base, ref, isRoot = false) {
+        const absoluteRef = this.resolveExternalRef(base, ref);
+        const cachedDocument = this.cache.get(absoluteRef);
+        if (cachedDocument) {
+            return cachedDocument;
+        }
+        const doc = this.loadExternalRef(absoluteRef).then((source) => {
+            return this.parseDocument(source, isRoot);
+        });
+        this.cache.set(absoluteRef, doc);
+        return doc;
+    }
+}
+exports.BaseResolver = BaseResolver;
+function pushRef(head, node) {
+    return {
+        prev: head,
+        node,
+    };
+}
+function hasRef(head, node) {
+    while (head) {
+        if (head.node === node) {
+            return true;
+        }
+        head = head.prev;
+    }
+    return false;
+}
+const unknownType = { name: 'unknown', properties: {} };
+const resolvableScalarType = { name: 'scalar', properties: {} };
+async function resolveDocument(opts) {
+    const { rootDocument, externalRefResolver, rootType } = opts;
+    const resolvedRefMap = new Map();
+    const seenNodes = new Set(); // format "${type}::${absoluteRef}${pointer}"
+    const resolvePromises = [];
+    resolveRefsInParallel(rootDocument.parsed, rootDocument, '#/', rootType);
+    let resolved;
+    do {
+        resolved = await Promise.all(resolvePromises);
+    } while (resolvePromises.length !== resolved.length);
+    return resolvedRefMap;
+    function resolveRefsInParallel(rootNode, rootNodeDocument, rootNodePointer, type) {
+        const rootNodeDocAbsoluteRef = rootNodeDocument.source.absoluteRef;
+        const anchorRefsMap = new Map();
+        walk(rootNode, type, rootNodeDocAbsoluteRef + rootNodePointer);
+        function walk(node, type, nodeAbsoluteRef) {
+            if (typeof node !== 'object' || node === null) {
+                return;
+            }
+            const nodeId = `${type.name}::${nodeAbsoluteRef}`;
+            if (seenNodes.has(nodeId)) {
+                return;
+            }
+            seenNodes.add(nodeId);
+            const [_, anchor] = Object.entries(node).find(([key]) => key === '$anchor') || [];
+            if (anchor) {
+                anchorRefsMap.set(`#${anchor}`, node);
+            }
+            if (Array.isArray(node)) {
+                const itemsType = type.items;
+                // we continue resolving unknown types, but stop early on known scalars
+                if (itemsType === undefined && type !== unknownType && type !== types_1.SpecExtension) {
+                    return;
+                }
+                const isTypeAFunction = typeof itemsType === 'function';
+                for (let i = 0; i < node.length; i++) {
+                    const itemType = isTypeAFunction
+                        ? itemsType(node[i], (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, i))
+                        : itemsType;
+                    // we continue resolving unknown types, but stop early on known scalars
+                    if (itemType === undefined && type !== unknownType && type !== types_1.SpecExtension) {
+                        continue;
+                    }
+                    walk(node[i], (0, types_1.isNamedType)(itemType) ? itemType : unknownType, (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, i));
+                }
+                return;
+            }
+            for (const propName of Object.keys(node)) {
+                let propValue = node[propName];
+                let propType = type.properties[propName];
+                if (propType === undefined)
+                    propType = type.additionalProperties;
+                if (typeof propType === 'function')
+                    propType = propType(propValue, propName);
+                if (propType === undefined)
+                    propType = unknownType;
+                if (type.extensionsPrefix &&
+                    propName.startsWith(type.extensionsPrefix) &&
+                    propType === unknownType) {
+                    propType = types_1.SpecExtension;
+                }
+                if (!(0, types_1.isNamedType)(propType) && propType?.directResolveAs) {
+                    propType = propType.directResolveAs;
+                    propValue = { $ref: propValue };
+                }
+                if (propType && propType.name === undefined && propType.resolvable !== false) {
+                    propType = resolvableScalarType;
+                }
+                if (!(0, types_1.isNamedType)(propType) || typeof propValue !== 'object') {
+                    continue;
+                }
+                walk(propValue, propType, (0, ref_utils_1.joinPointer)(nodeAbsoluteRef, (0, ref_utils_1.escapePointer)(propName)));
+            }
+            if ((0, ref_utils_1.isRef)(node)) {
+                const promise = followRef(rootNodeDocument, node, {
+                    prev: null,
+                    node,
+                }).then((resolvedRef) => {
+                    if (resolvedRef.resolved) {
+                        resolveRefsInParallel(resolvedRef.node, resolvedRef.document, resolvedRef.nodePointer, type);
+                    }
+                });
+                resolvePromises.push(promise);
+            }
+            // handle example.externalValue as reference
+            if ((0, ref_utils_1.isExternalValue)(node)) {
+                const promise = followRef(rootNodeDocument, { $ref: node.externalValue }, {
+                    prev: null,
+                    node,
+                }).then((resolvedRef) => {
+                    if (resolvedRef.resolved) {
+                        resolveRefsInParallel(resolvedRef.node, resolvedRef.document, resolvedRef.nodePointer, type);
+                    }
+                });
+                resolvePromises.push(promise);
+            }
+        }
+        async function followRef(document, ref, refStack) {
+            if (hasRef(refStack.prev, ref)) {
+                throw new Error('Self-referencing circular pointer');
+            }
+            if ((0, ref_utils_1.isAnchor)(ref.$ref)) {
+                // Wait for all anchors in the document to be collected firstly.
+                await (0, utils_1.nextTick)();
+                const resolvedRef = {
+                    resolved: true,
+                    isRemote: false,
+                    node: anchorRefsMap.get(ref.$ref),
+                    document,
+                    nodePointer: ref.$ref,
+                };
+                const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+                resolvedRefMap.set(refId, resolvedRef);
+                return resolvedRef;
+            }
+            const { uri, pointer } = (0, ref_utils_1.parseRef)(ref.$ref);
+            const isRemote = uri !== null;
+            let targetDoc;
+            try {
+                targetDoc = isRemote
+                    ? (await externalRefResolver.resolveDocument(document.source.absoluteRef, uri))
+                    : document;
+            }
+            catch (error) {
+                const resolvedRef = {
+                    resolved: false,
+                    isRemote,
+                    document: undefined,
+                    error: error,
+                };
+                const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+                resolvedRefMap.set(refId, resolvedRef);
+                return resolvedRef;
+            }
+            let resolvedRef = {
+                resolved: true,
+                document: targetDoc,
+                isRemote,
+                node: document.parsed,
+                nodePointer: '#/',
+            };
+            let target = targetDoc.parsed;
+            const segments = pointer;
+            for (const segment of segments) {
+                if (typeof target !== 'object') {
+                    target = undefined;
+                    break;
+                }
+                else if (target[segment] !== undefined) {
+                    target = target[segment];
+                    resolvedRef.nodePointer = (0, ref_utils_1.joinPointer)(resolvedRef.nodePointer, (0, ref_utils_1.escapePointer)(segment));
+                }
+                else if ((0, ref_utils_1.isRef)(target)) {
+                    resolvedRef = await followRef(targetDoc, target, pushRef(refStack, target));
+                    targetDoc = resolvedRef.document || targetDoc;
+                    if (typeof resolvedRef.node !== 'object') {
+                        target = undefined;
+                        break;
+                    }
+                    target = resolvedRef.node[segment];
+                    resolvedRef.nodePointer = (0, ref_utils_1.joinPointer)(resolvedRef.nodePointer, (0, ref_utils_1.escapePointer)(segment));
+                }
+                else {
+                    target = undefined;
+                    break;
+                }
+            }
+            resolvedRef.node = target;
+            resolvedRef.document = targetDoc;
+            const refId = makeRefId(document.source.absoluteRef, ref.$ref);
+            if (resolvedRef.document && (0, ref_utils_1.isRef)(target)) {
+                resolvedRef = await followRef(resolvedRef.document, target, pushRef(refStack, target));
+            }
+            resolvedRefMap.set(refId, resolvedRef);
+            return { ...resolvedRef };
+        }
+    }
+}

package/lib/rules/ajv.d.ts

@@ -0,0 +1,10 @@
+import type { Location } from '../ref-utils';
+import type { ErrorObject } from '@redocly/ajv/dist/2020';
+import type { ResolveFn } from '../walk';
+export declare function releaseAjvInstance(): void;
+export declare function validateJsonSchema(data: any, schema: any, schemaLoc: Location, instancePath: string, resolve: ResolveFn, allowAdditionalProperties: boolean): {
+    valid: boolean;
+    errors: (ErrorObject & {
+        suggest?: string[];
+    })[];
+};

package/lib/rules/ajv.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releaseAjvInstance = releaseAjvInstance;
+exports.validateJsonSchema = validateJsonSchema;
+const _2020_1 = require("@redocly/ajv/dist/2020");
+const ref_utils_1 = require("../ref-utils");
+let ajvInstance = null;
+function releaseAjvInstance() {
+    ajvInstance = null;
+}
+function getAjv(resolve, allowAdditionalProperties) {
+    if (!ajvInstance) {
+        ajvInstance = new _2020_1.default({
+            schemaId: '$id',
+            meta: true,
+            allErrors: true,
+            strictSchema: false,
+            inlineRefs: false,
+            validateSchema: false,
+            discriminator: true,
+            allowUnionTypes: true,
+            validateFormats: false, // TODO: fix it
+            defaultUnevaluatedProperties: allowAdditionalProperties,
+            loadSchemaSync(base, $ref, $id) {
+                const resolvedRef = resolve({ $ref }, base.split('#')[0]);
+                if (!resolvedRef || !resolvedRef.location)
+                    return false;
+                return { $id: resolvedRef.location.source.absoluteRef + '#' + $id, ...resolvedRef.node };
+            },
+            logger: false,
+        });
+    }
+    return ajvInstance;
+}
+function getAjvValidator(schema, loc, resolve, allowAdditionalProperties) {
+    const ajv = getAjv(resolve, allowAdditionalProperties);
+    if (!ajv.getSchema(loc.absolutePointer)) {
+        ajv.addSchema({ $id: loc.absolutePointer, ...schema }, loc.absolutePointer);
+    }
+    return ajv.getSchema(loc.absolutePointer);
+}
+function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, allowAdditionalProperties) {
+    const validate = getAjvValidator(schema, schemaLoc, resolve, allowAdditionalProperties);
+    if (!validate)
+        return { valid: true, errors: [] }; // unresolved refs are reported
+    const valid = validate(data, {
+        instancePath,
+        parentData: { fake: {} },
+        parentDataProperty: 'fake',
+        rootData: {},
+        dynamicAnchors: {},
+    });
+    return {
+        valid: !!valid,
+        errors: (validate.errors || []).map(beatifyErrorMessage),
+    };
+    function beatifyErrorMessage(error) {
+        let message = error.message;
+        const suggest = error.keyword === 'enum' ? error.params.allowedValues : undefined;
+        if (suggest) {
+            message += ` ${suggest.map((e) => `"${e}"`).join(', ')}`;
+        }
+        if (error.keyword === 'type') {
+            message = `type ${message}`;
+        }
+        const relativePath = error.instancePath.substring(instancePath.length + 1);
+        const propName = relativePath.substring(relativePath.lastIndexOf('/') + 1);
+        if (propName) {
+            message = `\`${propName}\` property ${message}`;
+        }
+        if (error.keyword === 'additionalProperties' || error.keyword === 'unevaluatedProperties') {
+            const property = error.params.additionalProperty || error.params.unevaluatedProperty;
+            message = `${message} \`${property}\``;
+            error.instancePath += '/' + (0, ref_utils_1.escapePointer)(property);
+        }
+        return {
+            ...error,
+            message,
+            suggest,
+        };
+    }
+}

package/lib/rules/arazzo/criteria-unique.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const CriteriaUnique: Arazzo1Rule;

package/lib/rules/arazzo/criteria-unique.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CriteriaUnique = void 0;
+const CriteriaUnique = () => {
+    return {
+        FailureActionObject: {
+            enter(action, { report, location }) {
+                const criterias = action?.criteria;
+                if (!Array.isArray(criterias)) {
+                    return;
+                }
+                const seen = new Set();
+                for (const criteria of criterias) {
+                    const key = JSON.stringify(criteria);
+                    if (seen.has(key)) {
+                        report({
+                            message: 'The FailureAction criteria items must be unique.',
+                            location: location.child(['criteria', criterias.indexOf(criteria)]),
+                        });
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+            },
+        },
+        SuccessActionObject: {
+            enter(action, { report, location }) {
+                const criterias = action?.criteria;
+                if (!Array.isArray(criterias)) {
+                    return;
+                }
+                const seen = new Set();
+                for (const criteria of criterias) {
+                    const key = JSON.stringify(criteria);
+                    if (seen.has(key)) {
+                        report({
+                            message: 'The SuccessAction criteria items must be unique.',
+                            location: location.child(['criteria', criterias.indexOf(criteria)]),
+                        });
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+            },
+        },
+        Step: {
+            enter(step, { report, location }) {
+                const successCriterias = step?.successCriteria;
+                if (!Array.isArray(successCriterias)) {
+                    return;
+                }
+                const seen = new Set();
+                for (const criteria of successCriterias) {
+                    const key = JSON.stringify(criteria);
+                    if (seen.has(key)) {
+                        report({
+                            message: 'The Step SuccessCriteria items must be unique.',
+                            location: location.child(['successCriteria', successCriterias.indexOf(criteria)]),
+                        });
+                    }
+                    else {
+                        seen.add(key);
+                    }
+                }
+            },
+        },
+    };
+};
+exports.CriteriaUnique = CriteriaUnique;

package/lib/rules/arazzo/index.d.ts

@@ -0,0 +1,3 @@
+import type { Arazzo1RuleSet } from '../../oas-types';
+export declare const rules: Arazzo1RuleSet<'built-in'>;
+export declare const preprocessors: {};

package/lib/rules/arazzo/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.preprocessors = exports.rules = void 0;
+const struct_1 = require("../common/struct");
+const assertions_1 = require("../common/assertions");
+const sourceDescription_type_1 = require("../arazzo/sourceDescription-type");
+const sourceDescriptions_not_empty_1 = require("./sourceDescriptions-not-empty");
+const spot_supported_versions_1 = require("../spot/spot-supported-versions");
+const workflowId_unique_1 = require("./workflowId-unique");
+const stepId_unique_1 = require("./stepId-unique");
+const sourceDescriptions_name_unique_1 = require("./sourceDescriptions-name-unique");
+const workflow_dependsOn_1 = require("./workflow-dependsOn");
+const parameters_unique_1 = require("./parameters-unique");
+const step_onSuccess_unique_1 = require("./step-onSuccess-unique");
+const step_onFailure_unique_1 = require("./step-onFailure-unique");
+const requestBody_replacements_unique_1 = require("./requestBody-replacements-unique");
+const no_criteria_xpath_1 = require("../spot/no-criteria-xpath");
+const criteria_unique_1 = require("./criteria-unique");
+exports.rules = {
+    struct: struct_1.Struct,
+    assertions: assertions_1.Assertions,
+    'sourceDescription-type': sourceDescription_type_1.SourceDescriptionType,
+    'spot-supported-versions': spot_supported_versions_1.SpotSupportedVersions,
+    'workflowId-unique': workflowId_unique_1.WorkflowIdUnique,
+    'stepId-unique': stepId_unique_1.StepIdUnique,
+    'sourceDescription-name-unique': sourceDescriptions_name_unique_1.SourceDescriptionsNameUnique,
+    'sourceDescriptions-not-empty': sourceDescriptions_not_empty_1.SourceDescriptionsNotEmpty,
+    'workflow-dependsOn': workflow_dependsOn_1.WorkflowDependsOn,
+    'parameters-unique': parameters_unique_1.ParametersUnique,
+    'step-onSuccess-unique': step_onSuccess_unique_1.StepOnSuccessUnique,
+    'step-onFailure-unique': step_onFailure_unique_1.StepOnFailureUnique,
+    'requestBody-replacements-unique': requestBody_replacements_unique_1.RequestBodyReplacementsUnique,
+    'no-criteria-xpath': no_criteria_xpath_1.NoCriteriaXpath,
+    'criteria-unique': criteria_unique_1.CriteriaUnique,
+};
+exports.preprocessors = {};

package/lib/rules/arazzo/parameters-unique.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const ParametersUnique: Arazzo1Rule;

package/lib/rules/arazzo/parameters-unique.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParametersUnique = void 0;
+const ParametersUnique = () => {
+    return {
+        Parameters: {
+            enter(parameters, { report, location }) {
+                if (!parameters)
+                    return;
+                const seenParameters = new Set();
+                for (const parameter of parameters) {
+                    if (seenParameters.has(parameter?.name)) {
+                        report({
+                            message: 'The parameter `name` must be unique amongst listed parameters.',
+                            location: location.child([parameters.indexOf(parameter)]),
+                        });
+                    }
+                    if (seenParameters.has(parameter?.reference)) {
+                        report({
+                            message: 'The parameter `reference` must be unique amongst listed parameters.',
+                            location: location.child([parameters.indexOf(parameter)]),
+                        });
+                    }
+                    parameter?.name
+                        ? seenParameters.add(parameter.name)
+                        : seenParameters.add(parameter.reference);
+                }
+            },
+        },
+    };
+};
+exports.ParametersUnique = ParametersUnique;

package/lib/rules/arazzo/requestBody-replacements-unique.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const RequestBodyReplacementsUnique: Arazzo1Rule;

package/lib/rules/arazzo/requestBody-replacements-unique.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RequestBodyReplacementsUnique = void 0;
+const RequestBodyReplacementsUnique = () => {
+    const seenReplacements = new Set();
+    return {
+        RequestBody: {
+            enter(requestBody, { report, location }) {
+                if (!requestBody.replacements)
+                    return;
+                for (const replacement of requestBody.replacements) {
+                    if (seenReplacements.has(replacement.target)) {
+                        report({
+                            message: 'Every `replacement` in `requestBody` must be unique.',
+                            location: location.child([
+                                'replacements',
+                                requestBody.replacements.indexOf(replacement),
+                                `target`,
+                            ]),
+                        });
+                    }
+                    seenReplacements.add(replacement.target);
+                }
+            },
+        },
+    };
+};
+exports.RequestBodyReplacementsUnique = RequestBodyReplacementsUnique;

package/lib/rules/arazzo/sourceDescription-type.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const SourceDescriptionType: Arazzo1Rule;

package/lib/rules/arazzo/sourceDescription-type.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SourceDescriptionType = void 0;
+const SourceDescriptionType = () => {
+    return {
+        SourceDescriptions: {
+            enter(sourceDescriptions, { report, location }) {
+                if (!sourceDescriptions.length)
+                    return;
+                for (const sourceDescription of sourceDescriptions) {
+                    if (!['openapi', 'arazzo'].includes(sourceDescription?.type)) {
+                        report({
+                            message: 'The `type` property of the `sourceDescription` object must be either `openapi` or `arazzo`.',
+                            location: location.child([sourceDescriptions.indexOf(sourceDescription)]),
+                        });
+                    }
+                }
+            },
+        },
+    };
+};
+exports.SourceDescriptionType = SourceDescriptionType;

package/lib/rules/arazzo/sourceDescriptions-name-unique.d.ts

@@ -0,0 +1,2 @@
+import type { Arazzo1Rule } from '../../visitors';
+export declare const SourceDescriptionsNameUnique: Arazzo1Rule;