@redocly/openapi-core 1.0.0-beta.89 → 1.0.0-beta.92

package/__tests__/__snapshots__/bundle.test.ts.snap

@@ -144,10 +144,24 @@ paths:
           content:
             application/json:
               schema:
-                $ref: '#/components/schemas/vendor'
+                $ref: '#/components/schemas/vendor.schema'
 components:
   schemas:
     vendor:
+      $ref: '#/components/schemas/vendor.schema'
+    myvendor:
+      $ref: '#/components/schemas/vendor.schema'
+    simple:
+      type: string
+    A:
+      type: string
+    test:
+      $ref: '#/components/schemas/rename-2'
+    rename:
+      type: string
+    rename-2:
+      type: number
+    vendor.schema:
       title: vendor
       type: object
       description: Vendors
@@ -171,18 +185,6 @@ components:
           type: boolean
           description: One-time use
           default: false
-    myvendor:
-      $ref: '#/components/schemas/vendor'
-    simple:
-      type: string
-    A:
-      type: string
-    test:
-      $ref: '#/components/schemas/rename-2'
-    rename:
-      type: string
-    rename-2:
-      type: number
 
 `;
 

package/__tests__/ref-utils.test.ts

@@ -1,6 +1,6 @@
 import outdent from 'outdent';
 import { parseYamlToDocument } from './utils';
-import { parseRef } from '../src/ref-utils';
+import { parseRef, refBaseName } from '../src/ref-utils';
 import { lintDocument } from '../src/lint';
 import { LintConfig } from '../src/config/config';
 import { BaseResolver } from '../src/resolve';
@@ -95,4 +95,26 @@ describe('ref-utils', () => {
 
     expect(result).toMatchInlineSnapshot(`Array []`);
   });
+
+  describe('refBaseName', () => {
+    it("returns base name for file reference", () => {
+      expect(refBaseName("../testcase/Pet.yaml")).toStrictEqual("Pet");
+    });
+
+    it("returns base name for local file reference", () => {
+      expect(refBaseName("Cat.json")).toStrictEqual("Cat");
+    });
+
+    it("returns base name for url reference", () => {
+      expect(refBaseName("http://example.com/tests/crocodile.json")).toStrictEqual("crocodile");
+    });
+
+    it("returns base name for file with multiple dots in name", () => {
+      expect(refBaseName("feline.tiger.v1.yaml")).toStrictEqual("feline.tiger.v1");
+    });
+
+    it("returns base name for file without any dots in name", () => {
+      expect(refBaseName("abcdefg")).toStrictEqual("abcdefg");
+    });
+  });
 });

package/lib/config/all.js

@@ -19,6 +19,7 @@ exports.default = {
         'operation-description': 'error',
         'operation-2xx-response': 'error',
         'operation-4xx-response': 'error',
+        'assertions': 'error',
         'operation-operationId': 'error',
         'operation-summary': 'error',
         'operation-operationId-unique': 'error',

package/lib/config/config.js

@@ -444,17 +444,12 @@ function transformConfig(rawConfig) {
         throw new Error("Do not use 'referenceDocs' field. Use 'features.openapi' instead.\n");
     }
     const _a = rawConfig, { apiDefinitions, referenceDocs } = _a, rest = __rest(_a, ["apiDefinitions", "referenceDocs"]);
-    // TODO: put links to the changelog and uncomment this after successful release of ReferenceDocs/Redoc, Portal and Workflows
-    // if (apiDefinitions) {
-    //   process.stderr.write(
-    //     `The ${yellow('apiDefinitions')} field is deprecated. Use ${green('apis')} instead, see changelog: <link>\n`
-    //   );
-    // }
-    // if (referenceDocs) {
-    //   process.stderr.write(
-    //     `The ${yellow('referenceDocs')} field is deprecated. Use ${green('features.openapi')} instead, see changelog: <link>\n`
-    //   );
-    // }
+    if (apiDefinitions) {
+        process.stderr.write(`The ${colorette_1.yellow('apiDefinitions')} field is deprecated. Use ${colorette_1.green('apis')} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`);
+    }
+    if (referenceDocs) {
+        process.stderr.write(`The ${colorette_1.yellow('referenceDocs')} field is deprecated. Use ${colorette_1.green('features.openapi')} instead. Read more about this change: https://redocly.com/docs/api-registry/guides/migration-guide-config-file/#changed-properties\n`);
+    }
     return Object.assign({ 'features.openapi': referenceDocs, apis: transformApiDefinitionsToApis(apiDefinitions) }, rest);
 }
 exports.transformConfig = transformConfig;

package/lib/config/minimal.js

@@ -18,6 +18,7 @@ exports.default = {
         'operation-description': 'off',
         'operation-2xx-response': 'warn',
         'operation-4xx-response': 'off',
+        'assertions': 'warn',
         'operation-operationId': 'warn',
         'operation-summary': 'warn',
         'operation-operationId-unique': 'warn',

package/lib/config/recommended.js

@@ -17,6 +17,7 @@ exports.default = {
         'path-parameters-defined': 'error',
         'operation-description': 'off',
         'operation-2xx-response': 'warn',
+        'assertions': 'warn',
         'operation-4xx-response': 'warn',
         'operation-operationId': 'warn',
         'operation-summary': 'error',

package/lib/config/rules.d.ts

@@ -1,7 +1,7 @@
 import { RuleSet, OasVersion } from '../oas-types';
 import { LintConfig } from './config';
 export declare function initRules<T extends Function, P extends RuleSet<T>>(rules: P[], config: LintConfig, type: 'rules' | 'preprocessors' | 'decorators', oasVersion: OasVersion): {
-    severity: import("..").ProblemSeverity;
+    severity: import("..").ProblemSeverity | "off";
     ruleId: string;
     visitor: any;
 }[];

package/lib/config/rules.js

@@ -14,13 +14,21 @@ function initRules(rules, config, type, oasVersion) {
         if (ruleSettings.severity === 'off') {
             return undefined;
         }
-        const visitor = rule(ruleSettings);
+        const visitors = rule(ruleSettings);
+        if (Array.isArray(visitors)) {
+            return visitors.map((visitor) => ({
+                severity: ruleSettings.severity,
+                ruleId,
+                visitor: visitor,
+            }));
+        }
         return {
             severity: ruleSettings.severity,
             ruleId,
-            visitor,
+            visitor: visitors, // note: actually it is only one visitor object
         };
     }))
+        .flatMap(visitor => visitor)
         .filter(utils_1.notUndefined);
 }
 exports.initRules = initRules;

package/lib/redocly/index.d.ts

@@ -20,7 +20,10 @@ export declare class RedoclyClient {
     isAuthorizedWithRedoclyByRegion(): Promise<boolean>;
     isAuthorizedWithRedocly(): Promise<boolean>;
     readCredentialsFile(credentialsPath: string): any;
-    verifyToken(accessToken: string, region: Region, verbose?: boolean): Promise<boolean>;
+    verifyToken(accessToken: string, region: Region, verbose?: boolean): Promise<{
+        viewerId: string;
+        organizations: string[];
+    }>;
     login(accessToken: string, verbose?: boolean): Promise<void>;
     logout(): void;
 }

package/lib/redocly/index.js

@@ -24,9 +24,7 @@ class RedoclyClient {
         this.accessTokens = {};
         this.region = this.loadRegion(region);
         this.loadTokens();
-        this.domain = region
-            ? config_1.DOMAINS[region]
-            : process.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
+        this.domain = region ? config_1.DOMAINS[region] : process.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
         /*
          * We can't use process.env here because it is replaced by a const in some client-side bundles,
          * which breaks assignment.
@@ -73,8 +71,9 @@ class RedoclyClient {
         const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
         const credentials = this.readCredentialsFile(credentialsPath);
         if (utils_1.isNotEmptyObject(credentials)) {
-            this.setAccessTokens(Object.assign(Object.assign({}, credentials), (credentials.token && !credentials[this.region] && {
-                [this.region]: credentials.token
+            this.setAccessTokens(Object.assign(Object.assign({}, credentials), (credentials.token &&
+                !credentials[this.region] && {
+                [this.region]: credentials.token,
             })));
         }
         if (process.env.REDOCLY_AUTHORIZATION) {
@@ -82,17 +81,17 @@ class RedoclyClient {
         }
     }
     getAllTokens() {
-        return Object.entries(this.accessTokens).filter(([region]) => config_1.AVAILABLE_REGIONS.includes(region)).map(([region, token]) => ({ region, token }));
+        return Object.entries(this.accessTokens)
+            .filter(([region]) => config_1.AVAILABLE_REGIONS.includes(region))
+            .map(([region, token]) => ({ region, token }));
     }
     getValidTokens() {
         return __awaiter(this, void 0, void 0, function* () {
-            const validTokens = [];
-            for (const { token, region } of this.getAllTokens()) {
-                if (yield this.verifyToken(token, region)) {
-                    validTokens.push({ token, region, valid: true });
-                }
-            }
-            return validTokens;
+            const allTokens = this.getAllTokens();
+            const verifiedTokens = yield Promise.allSettled(allTokens.map(({ token, region }) => this.verifyToken(token, region)));
+            return allTokens
+                .filter((_, index) => verifiedTokens[index].status === 'fulfilled')
+                .map(({ token, region }) => ({ token, region, valid: true }));
         });
     }
     getTokens() {
@@ -102,10 +101,20 @@ class RedoclyClient {
     }
     isAuthorizedWithRedoclyByRegion() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!this.hasTokens())
+            if (!this.hasTokens()) {
                 return false;
+            }
             const accessToken = this.accessTokens[this.region];
-            return !!accessToken && (yield this.verifyToken(accessToken, this.region));
+            if (!accessToken) {
+                return false;
+            }
+            try {
+                yield this.verifyToken(accessToken, this.region);
+                return true;
+            }
+            catch (err) {
+                return false;
+            }
         });
     }
     isAuthorizedWithRedocly() {
@@ -118,8 +127,6 @@ class RedoclyClient {
     }
     verifyToken(accessToken, region, verbose = false) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!accessToken)
-                return false;
             return this.registryApi.authStatus(accessToken, region, verbose);
         });
     }
@@ -127,8 +134,10 @@ class RedoclyClient {
         return __awaiter(this, void 0, void 0, function* () {
             const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
             process.stdout.write(colorette_1.gray('\n  Logging in...\n'));
-            const authorized = yield this.verifyToken(accessToken, this.region, verbose);
-            if (!authorized) {
+            try {
+                yield this.verifyToken(accessToken, this.region, verbose);
+            }
+            catch (err) {
                 process.stdout.write(colorette_1.red('Authorization failed. Please check if you entered a valid API key.\n'));
                 process.exit(1);
             }

package/lib/redocly/registry-api.d.ts

@@ -8,7 +8,10 @@ export declare class RegistryApi {
     getBaseUrl(region?: Region): string;
     setAccessTokens(accessTokens: AccessTokens): this;
     private request;
-    authStatus(accessToken: string, region: Region, verbose?: boolean): Promise<boolean>;
+    authStatus(accessToken: string, region: Region, verbose?: boolean): Promise<{
+        viewerId: string;
+        organizations: string[];
+    }>;
     prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }: RegistryApiTypes.PrepareFileuploadParams): Promise<RegistryApiTypes.PrepareFileuploadOKResponse>;
     pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, }: RegistryApiTypes.PushApiParams): Promise<void>;
 }

package/lib/redocly/registry-api.js

@@ -50,13 +50,13 @@ class RegistryApi {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 const response = yield this.request('', { headers: { authorization: accessToken } }, region);
-                return response.ok;
+                return yield response.json();
             }
             catch (error) {
                 if (verbose) {
                     console.log(error);
                 }
-                return false;
+                throw error;
             }
         });
     }
@@ -86,7 +86,7 @@ class RegistryApi {
                 method: 'PUT',
                 headers: {
                     'content-type': 'application/json',
-                    authorization: this.accessToken
+                    authorization: this.accessToken,
                 },
                 body: JSON.stringify({
                     rootFilePath,

package/lib/ref-utils.js

@@ -56,7 +56,7 @@ function pointerBaseName(pointer) {
 exports.pointerBaseName = pointerBaseName;
 function refBaseName(ref) {
     const parts = ref.split(/[\/\\]/); // split by '\' and '/'
-    return parts[parts.length - 1].split('.')[0];
+    return parts[parts.length - 1].replace(/\.[^.]+$/, ''); // replace extension with empty string
 }
 exports.refBaseName = refBaseName;
 function isAbsoluteUrl(ref) {

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/openapi-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;

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

@@ -0,0 +1,20 @@
+import { ProblemSeverity, UserContext } from '../../../walk';
+export declare type OrderDirection = 'asc' | 'desc';
+export declare type OrderOptions = {
+    direction: OrderDirection;
+    property: string;
+};
+export declare type AssertToApply = {
+    name: string;
+    assertId?: string;
+    conditions: any;
+    message?: string;
+    severity?: ProblemSeverity;
+    suggest?: string[];
+    runsOnKeys: boolean;
+    runsOnValues: boolean;
+};
+export declare function buildVisitorObject(subject: string, context: Record<string, any>[], subjectVisitor: any): Record<string, any>;
+export declare function buildSubjectVisitor(properties: string | string[], asserts: AssertToApply[], context?: Record<string, any>[]): (node: any, { report, location, key, type }: UserContext) => void;
+export declare function getIntersectionLength(keys: string[], properties: string[]): number;
+export declare function isOrdered(value: any[], options: OrderOptions | OrderDirection): boolean;