@redocly/openapi-core 1.0.0-beta.100

package/lib/resolve.d.ts

@@ -0,0 +1,66 @@
+import type { YAMLNode, LoadOptions } from 'yaml-ast-parser';
+import { NormalizedNodeType } from './types';
+import { ResolveConfig } from './config/types';
+export declare type CollectedRefs = Map<string, Document>;
+export declare class Source {
+    absoluteRef: string;
+    body: string;
+    mimeType?: string | undefined;
+    constructor(absoluteRef: string, body: string, mimeType?: string | undefined);
+    private _ast;
+    private _lines;
+    getAst(safeLoad: (input: string, options?: LoadOptions | undefined) => YAMLNode): YAMLNode;
+    getLines(): string[];
+}
+export declare class ResolveError extends Error {
+    originalError: Error;
+    constructor(originalError: Error);
+}
+export declare class YamlParseError extends Error {
+    originalError: Error;
+    source: Source;
+    col: number;
+    line: number;
+    constructor(originalError: Error, source: Source);
+}
+export declare type Document = {
+    source: Source;
+    parsed: any;
+};
+export declare function makeRefId(absoluteRef: string, pointer: string): string;
+export declare function makeDocumentFromString(sourceString: string, absoluteRef: string): {
+    source: Source;
+    parsed: unknown;
+};
+export declare class BaseResolver {
+    private config;
+    cache: Map<string, Promise<Document | ResolveError>>;
+    constructor(config?: ResolveConfig);
+    getFiles(): Set<string>;
+    resolveExternalRef(base: string | null, ref: string): string;
+    loadExternalRef(absoluteRef: string): Promise<Source>;
+    parseDocument(source: Source, isRoot?: boolean): Document;
+    resolveDocument(base: string | null, ref: string, isRoot?: boolean): Promise<Document | ResolveError | YamlParseError>;
+}
+export declare type ResolvedRef = {
+    resolved: false;
+    isRemote: boolean;
+    nodePointer?: string;
+    document?: Document;
+    source?: Source;
+    error?: ResolveError | YamlParseError;
+    node?: any;
+} | {
+    resolved: true;
+    node: any;
+    document: Document;
+    nodePointer: string;
+    isRemote: boolean;
+    error?: undefined;
+};
+export declare type ResolvedRefMap = Map<string, ResolvedRef>;
+export declare function resolveDocument(opts: {
+    rootDocument: Document;
+    externalRefResolver: BaseResolver;
+    rootType: NormalizedNodeType;
+}): Promise<ResolvedRefMap>;

package/lib/resolve.js

@@ -0,0 +1,311 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDocument = exports.BaseResolver = exports.makeDocumentFromString = exports.makeRefId = exports.YamlParseError = exports.ResolveError = exports.Source = void 0;
+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) {
+        var _a;
+        if (this._ast === undefined) {
+            this._ast = (_a = safeLoad(this.body, { filename: this.absoluteRef })) !== null && _a !== void 0 ? _a : 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;
+}
+exports.makeRefId = makeRefId;
+function makeDocumentFromString(sourceString, absoluteRef) {
+    const source = new Source(absoluteRef, sourceString);
+    try {
+        return {
+            source,
+            parsed: utils_1.parseYaml(sourceString, { filename: absoluteRef }),
+        };
+    }
+    catch (e) {
+        throw new YamlParseError(e, source);
+    }
+}
+exports.makeDocumentFromString = makeDocumentFromString;
+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 (ref_utils_1.isAbsoluteUrl(ref)) {
+            return ref;
+        }
+        if (base && ref_utils_1.isAbsoluteUrl(base)) {
+            return new URL(ref, base).href;
+        }
+        return path.resolve(base ? path.dirname(base) : process.cwd(), ref);
+    }
+    loadExternalRef(absoluteRef) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                if (ref_utils_1.isAbsoluteUrl(absoluteRef)) {
+                    const { body, mimeType } = yield utils_1.readFileFromUrl(absoluteRef, this.config.http);
+                    return new Source(absoluteRef, body, mimeType);
+                }
+                else {
+                    return new Source(absoluteRef, yield fs.promises.readFile(absoluteRef, 'utf-8'));
+                }
+            }
+            catch (error) {
+                throw new ResolveError(error);
+            }
+        });
+    }
+    parseDocument(source, isRoot = false) {
+        var _a;
+        const ext = source.absoluteRef.substr(source.absoluteRef.lastIndexOf('.'));
+        if (!['.json', '.json', '.yml', '.yaml'].includes(ext) &&
+            !((_a = source.mimeType) === null || _a === void 0 ? void 0 : _a.match(/(json|yaml|openapi)/)) &&
+            !isRoot // always parse root
+        ) {
+            return { source, parsed: source.body };
+        }
+        try {
+            return {
+                source,
+                parsed: utils_1.parseYaml(source.body, { filename: source.absoluteRef }),
+            };
+        }
+        catch (e) {
+            throw new YamlParseError(e, source);
+        }
+    }
+    resolveDocument(base, ref, isRoot = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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: {} };
+function resolveDocument(opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const { rootDocument, externalRefResolver, rootType } = opts;
+        const resolvedRefMap = new Map();
+        const seedNodes = new Set(); // format "${type}::${absoluteRef}${pointer}"
+        const resolvePromises = [];
+        resolveRefsInParallel(rootDocument.parsed, rootDocument, '#/', rootType);
+        let resolved;
+        do {
+            resolved = yield Promise.all(resolvePromises);
+        } while (resolvePromises.length !== resolved.length);
+        return resolvedRefMap;
+        function resolveRefsInParallel(rootNode, rootNodeDocument, rootNodePointer, type) {
+            const rootNodeDocAbsoluteRef = rootNodeDocument.source.absoluteRef;
+            walk(rootNode, type, rootNodeDocAbsoluteRef + rootNodePointer);
+            function walk(node, type, nodeAbsoluteRef) {
+                if (typeof node !== 'object' || node === null) {
+                    return;
+                }
+                const nodeId = `${type.name}::${nodeAbsoluteRef}`;
+                if (seedNodes.has(nodeId)) {
+                    return;
+                }
+                seedNodes.add(nodeId);
+                if (Array.isArray(node)) {
+                    const itemsType = type.items;
+                    // we continue resolving unknown types, but stop early on known scalars
+                    if (type !== unknownType && itemsType === undefined) {
+                        return;
+                    }
+                    for (let i = 0; i < node.length; i++) {
+                        walk(node[i], itemsType || unknownType, 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 (!types_1.isNamedType(propType) && (propType === null || propType === void 0 ? void 0 : propType.directResolveAs)) {
+                        propType = propType.directResolveAs;
+                        propValue = { $ref: propValue };
+                    }
+                    if (propType && propType.name === undefined && propType.resolvable !== false) {
+                        propType = resolvableScalarType;
+                    }
+                    if (!types_1.isNamedType(propType) || typeof propValue !== 'object') {
+                        continue;
+                    }
+                    walk(propValue, propType, ref_utils_1.joinPointer(nodeAbsoluteRef, ref_utils_1.escapePointer(propName)));
+                }
+                if (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);
+                }
+            }
+            function followRef(document, ref, refStack) {
+                return __awaiter(this, void 0, void 0, function* () {
+                    if (hasRef(refStack.prev, ref)) {
+                        throw new Error('Self-referencing circular pointer');
+                    }
+                    const { uri, pointer } = ref_utils_1.parseRef(ref.$ref);
+                    const isRemote = uri !== null;
+                    let targetDoc;
+                    try {
+                        targetDoc = isRemote
+                            ? (yield 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 (let segment of segments) {
+                        if (typeof target !== 'object') {
+                            target = undefined;
+                            break;
+                        }
+                        else if (target[segment] !== undefined) {
+                            target = target[segment];
+                            resolvedRef.nodePointer = ref_utils_1.joinPointer(resolvedRef.nodePointer, ref_utils_1.escapePointer(segment));
+                        }
+                        else if (ref_utils_1.isRef(target)) {
+                            resolvedRef = yield followRef(targetDoc, target, pushRef(refStack, target));
+                            targetDoc = resolvedRef.document || targetDoc;
+                            if (typeof resolvedRef.node !== 'object') {
+                                target = undefined;
+                                break;
+                            }
+                            target = resolvedRef.node[segment];
+                            resolvedRef.nodePointer = ref_utils_1.joinPointer(resolvedRef.nodePointer, 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 && ref_utils_1.isRef(target)) {
+                        resolvedRef = yield followRef(resolvedRef.document, target, pushRef(refStack, target));
+                    }
+                    resolvedRefMap.set(refId, resolvedRef);
+                    return Object.assign({}, resolvedRef);
+                });
+            }
+        }
+    });
+}
+exports.resolveDocument = resolveDocument;

package/lib/rules/ajv.d.ts

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

package/lib/rules/ajv.js

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateJsonSchema = exports.releaseAjvInstance = void 0;
+const ajv_1 = require("@redocly/ajv");
+const ref_utils_1 = require("../ref-utils");
+let ajvInstance = null;
+function releaseAjvInstance() {
+    ajvInstance = null;
+}
+exports.releaseAjvInstance = releaseAjvInstance;
+function getAjv(resolve, disallowAdditionalProperties) {
+    if (!ajvInstance) {
+        ajvInstance = new ajv_1.default({
+            schemaId: '$id',
+            meta: true,
+            allErrors: true,
+            strictSchema: false,
+            inlineRefs: false,
+            validateSchema: false,
+            discriminator: true,
+            allowUnionTypes: true,
+            validateFormats: false,
+            defaultAdditionalProperties: !disallowAdditionalProperties,
+            loadSchemaSync(base, $ref) {
+                const resolvedRef = resolve({ $ref }, base.split('#')[0]);
+                if (!resolvedRef || !resolvedRef.location)
+                    return undefined;
+                return Object.assign({ $id: resolvedRef.location.absolutePointer }, resolvedRef.node);
+            },
+            logger: false,
+        });
+    }
+    return ajvInstance;
+}
+function getAjvValidator(schema, loc, resolve, disallowAdditionalProperties) {
+    const ajv = getAjv(resolve, disallowAdditionalProperties);
+    if (!ajv.getSchema(loc.absolutePointer)) {
+        ajv.addSchema(Object.assign({ $id: loc.absolutePointer }, schema), loc.absolutePointer);
+    }
+    return ajv.getSchema(loc.absolutePointer);
+}
+function validateJsonSchema(data, schema, schemaLoc, instancePath, resolve, disallowAdditionalProperties) {
+    const validate = getAjvValidator(schema, schemaLoc, resolve, disallowAdditionalProperties);
+    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;
+        let 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') {
+            const property = error.params.additionalProperty;
+            message = `${message} \`${property}\``;
+            error.instancePath += '/' + ref_utils_1.escapePointer(property);
+        }
+        return Object.assign(Object.assign({}, error), { message,
+            suggest });
+    }
+}
+exports.validateJsonSchema = validateJsonSchema;

package/lib/rules/common/assertions/asserts.d.ts

@@ -0,0 +1,5 @@
+declare type Asserts = Record<string, (value: any, condition: any) => boolean>;
+export declare const runOnKeysSet: Set<string>;
+export declare const runOnValuesSet: Set<string>;
+export declare const asserts: Asserts;
+export {};

package/lib/rules/common/assertions/asserts.js

@@ -0,0 +1,143 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asserts = exports.runOnValuesSet = exports.runOnKeysSet = void 0;
+const utils_1 = require("./utils");
+exports.runOnKeysSet = new Set([
+    'mutuallyExclusive',
+    'mutuallyRequired',
+    'enum',
+    'pattern',
+    'minLength',
+    'maxLength',
+    'casing',
+    'sortOrder',
+    'disallowed',
+    'required',
+]);
+exports.runOnValuesSet = new Set([
+    'pattern',
+    'enum',
+    'defined',
+    'undefined',
+    'nonEmpty',
+    'minLength',
+    'maxLength',
+    'casing',
+    'sortOrder',
+]);
+exports.asserts = {
+    pattern: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        const values = typeof value === 'string' ? [value] : value;
+        const regexOptions = condition.match(/(\b\/\b)(.+)/g) || ['/'];
+        condition = condition.slice(1).replace(regexOptions[0], '');
+        const regx = new RegExp(condition, regexOptions[0].slice(1));
+        for (let _val of values) {
+            if (!_val.match(regx)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    enum: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        const values = typeof value === 'string' ? [value] : value;
+        for (let _val of values) {
+            if (!condition.includes(_val)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    defined: (value, condition = true) => {
+        const isDefined = typeof value !== 'undefined';
+        return condition ? isDefined : !isDefined;
+    },
+    required: (value, keys) => {
+        for (const requiredKey of keys) {
+            if (!value.includes(requiredKey)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    disallowed: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        const values = typeof value === 'string' ? [value] : value;
+        for (let _val of values) {
+            if (condition.includes(_val)) {
+                return false;
+            }
+        }
+        return true;
+    },
+    undefined: (value, condition = true) => {
+        const isUndefined = typeof value === 'undefined';
+        return condition ? isUndefined : !isUndefined;
+    },
+    nonEmpty: (value, condition = true) => {
+        const isEmpty = typeof value === 'undefined' || value === null || value === '';
+        return condition ? !isEmpty : isEmpty;
+    },
+    minLength: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        return value.length >= condition;
+    },
+    maxLength: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        return value.length <= condition;
+    },
+    casing: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true; // property doesn't exist, no need to lint it with this assert
+        const values = typeof value === 'string' ? [value] : value;
+        for (let _val of values) {
+            let matchCase = false;
+            switch (condition) {
+                case 'camelCase':
+                    matchCase = !!_val.match(/^[a-z][a-zA-Z0-9]+$/g);
+                    break;
+                case 'kebab-case':
+                    matchCase = !!_val.match(/^([a-z][a-z0-9]*)(-[a-z0-9]+)*$/g);
+                    break;
+                case 'snake_case':
+                    matchCase = !!_val.match(/^([a-z][a-z0-9]*)(_[a-z0-9]+)*$/g);
+                    break;
+                case 'PascalCase':
+                    matchCase = !!_val.match(/^[A-Z][a-zA-Z0-9]+$/g);
+                    break;
+                case 'MACRO_CASE':
+                    matchCase = !!_val.match(/^([A-Z][A-Z0-9]*)(_[A-Z0-9]+)*$/g);
+                    break;
+                case 'COBOL-CASE':
+                    matchCase = !!_val.match(/^([A-Z][A-Z0-9]*)(-[A-Z0-9]+)*$/g);
+                    break;
+                case 'flatcase':
+                    matchCase = !!_val.match(/^[a-z][a-z0-9]+$/g);
+                    break;
+            }
+            if (!matchCase) {
+                return false;
+            }
+        }
+        return true;
+    },
+    sortOrder: (value, condition) => {
+        if (typeof value === 'undefined')
+            return true;
+        return utils_1.isOrdered(value, condition);
+    },
+    mutuallyExclusive: (value, condition) => {
+        return utils_1.getIntersectionLength(value, condition) < 2;
+    },
+    mutuallyRequired: (value, condition) => {
+        return utils_1.getIntersectionLength(value, condition) > 0
+            ? utils_1.getIntersectionLength(value, condition) === condition.length
+            : true;
+    },
+};

package/lib/rules/common/assertions/index.d.ts

@@ -0,0 +1,2 @@
+import { Oas2Rule, Oas3Rule } from '../../../visitors';
+export declare const Assertions: Oas3Rule | Oas2Rule;

package/lib/rules/common/assertions/index.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Assertions = void 0;
+const asserts_1 = require("./asserts");
+const utils_1 = require("./utils");
+const Assertions = (opts) => {
+    let visitors = [];
+    // As 'Assertions' has an array of asserts,
+    // that array spreads into an 'opts' object on init rules phase here
+    // https://github.com/Redocly/redocly-cli/blob/master/packages/core/src/config/config.ts#L311
+    // that is why we need to iterate through 'opts' values;
+    // before - filter only object 'opts' values
+    const assertions = Object.values(opts).filter((opt) => typeof opt === 'object' && opt !== null);
+    for (const [index, assertion] of assertions.entries()) {
+        const assertId = (assertion.assertionId && `${assertion.assertionId} assertion`) || `assertion #${index + 1}`;
+        if (!assertion.subject) {
+            throw new Error(`${assertId}: 'subject' is required`);
+        }
+        const subjects = Array.isArray(assertion.subject)
+            ? assertion.subject
+            : [assertion.subject];
+        const assertsToApply = Object.keys(asserts_1.asserts)
+            .filter((assertName) => assertion[assertName] !== undefined)
+            .map((assertName) => {
+            return {
+                assertId,
+                name: assertName,
+                conditions: assertion[assertName],
+                message: assertion.message,
+                severity: assertion.severity || 'error',
+                suggest: assertion.suggest || [],
+                runsOnKeys: asserts_1.runOnKeysSet.has(assertName),
+                runsOnValues: asserts_1.runOnValuesSet.has(assertName),
+            };
+        });
+        const shouldRunOnKeys = assertsToApply.find((assert) => assert.runsOnKeys && !assert.runsOnValues);
+        const shouldRunOnValues = assertsToApply.find((assert) => assert.runsOnValues && !assert.runsOnKeys);
+        if (shouldRunOnValues && !assertion.property) {
+            throw new Error(`${shouldRunOnValues.name} can't be used on all keys. Please provide a single property.`);
+        }
+        if (shouldRunOnKeys && assertion.property) {
+            throw new Error(`${shouldRunOnKeys.name} can't be used on a single property. Please use 'property'.`);
+        }
+        for (const subject of subjects) {
+            const subjectVisitor = utils_1.buildSubjectVisitor(assertion.property, assertsToApply, assertion.context);
+            const visitorObject = utils_1.buildVisitorObject(subject, assertion.context, subjectVisitor);
+            visitors.push(visitorObject);
+        }
+    }
+    return visitors;
+};
+exports.Assertions = Assertions;