@redocly/openapi-core 1.0.0-beta.68 → 1.0.0-beta.72

package/__tests__/lint.test.ts

@@ -2,7 +2,7 @@ import outdent from 'outdent';
 import { detectOpenAPI } from '../src/oas-types';
 import { parseYamlToDocument } from './utils';
 
-describe.only('lint', () => {
+describe('lint', () => {
 	it('detect OpenAPI should throw an error when version is not string', () => {
 
 	const testDocument = parseYamlToDocument(

package/__tests__/login.test.ts

@@ -0,0 +1,17 @@
+import { RedoclyClient } from '../src/redocly';
+
+describe('login', () => {
+  it('should call login with setAccessTokens function', async () => {
+    const client = new RedoclyClient();
+    Object.defineProperty(client, 'registryApi', {
+      value: {
+        setAccessTokens: jest.fn(),
+        authStatus: jest.fn(() => true)
+      },
+      writable: true,
+      configurable: true
+    });
+    await client.login('token');
+    expect(client.registryApi.setAccessTokens).toHaveBeenCalled();
+  });
+});

package/lib/bundle.d.ts

@@ -15,12 +15,14 @@ export declare function bundle(opts: {
     config: Config;
     dereference?: boolean;
     base?: string;
+    skipRedoclyRegistryRefs?: boolean;
 }): Promise<{
     bundle: Document;
     problems: import("./walk").NormalizedProblem[];
     fileDependencies: Set<string>;
     rootType: NormalizedNodeType;
     refTypes: Map<string, NormalizedNodeType> | undefined;
+    visitorsData: Record<string, Record<string, unknown>>;
 }>;
 export declare function bundleDocument(opts: {
     document: Document;
@@ -28,10 +30,12 @@ export declare function bundleDocument(opts: {
     customTypes?: Record<string, NodeType>;
     externalRefResolver: BaseResolver;
     dereference?: boolean;
+    skipRedoclyRegistryRefs?: boolean;
 }): Promise<{
     bundle: Document;
     problems: import("./walk").NormalizedProblem[];
     fileDependencies: Set<string>;
     rootType: NormalizedNodeType;
     refTypes: Map<string, NormalizedNodeType> | undefined;
+    visitorsData: Record<string, Record<string, unknown>>;
 }>;

package/lib/bundle.js

@@ -23,6 +23,7 @@ const ref_utils_1 = require("./ref-utils");
 const rules_1 = require("./config/rules");
 const no_unresolved_refs_1 = require("./rules/no-unresolved-refs");
 const utils_1 = require("./utils");
+const redocly_1 = require("./redocly");
 var OasVersion;
 (function (OasVersion) {
     OasVersion["Version2"] = "oas2";
@@ -45,7 +46,7 @@ function bundle(opts) {
 exports.bundle = bundle;
 function bundleDocument(opts) {
     return __awaiter(this, void 0, void 0, function* () {
-        const { document, config, customTypes, externalRefResolver, dereference = false } = opts;
+        const { document, config, customTypes, externalRefResolver, dereference = false, skipRedoclyRegistryRefs = false, } = opts;
         const oasVersion = oas_types_1.detectOpenAPI(document.parsed);
         const oasMajorVersion = oas_types_1.openAPIMajor(oasVersion);
         const rules = config.getRulesForOasVersion(oasMajorVersion);
@@ -60,13 +61,14 @@ function bundleDocument(opts) {
             problems: [],
             oasVersion: oasVersion,
             refTypes: new Map(),
+            visitorsData: {},
         };
         const bundleVisitor = visitors_1.normalizeVisitors([
             ...preprocessors,
             {
                 severity: 'error',
                 ruleId: 'bundler',
-                visitor: makeBundleVisitor(oasMajorVersion, dereference, document),
+                visitor: makeBundleVisitor(oasMajorVersion, dereference, skipRedoclyRegistryRefs, document),
             },
             ...decorators,
         ], types);
@@ -88,6 +90,7 @@ function bundleDocument(opts) {
             fileDependencies: externalRefResolver.getFiles(),
             rootType: types.DefinitionRoot,
             refTypes: ctx.refTypes,
+            visitorsData: ctx.visitorsData,
         };
     });
 }
@@ -131,7 +134,7 @@ function mapTypeToComponent(typeName, version) {
     }
 }
 // function oas3Move
-function makeBundleVisitor(version, dereference, rootDocument) {
+function makeBundleVisitor(version, dereference, skipRedoclyRegistryRefs, rootDocument) {
     let components;
     const visitor = {
         ref: {
@@ -146,6 +149,9 @@ function makeBundleVisitor(version, dereference, rootDocument) {
                     !dereference) {
                     return;
                 }
+                if (skipRedoclyRegistryRefs && redocly_1.isRedoclyRegistryURL(node.$ref)) {
+                    return;
+                }
                 const componentType = mapTypeToComponent(ctx.type.name, version);
                 if (!componentType) {
                     replaceRef(node, resolved, ctx);

package/lib/config/all.js

@@ -38,6 +38,8 @@ exports.default = {
         },
         'request-mime-type': 'error',
         spec: 'error',
+        'no-invalid-schema-examples': 'error',
+        'no-invalid-parameter-examples': 'error',
     },
     oas3_0Rules: {
         'no-invalid-media-type-examples': 'error',

package/lib/config/config.d.ts

@@ -70,11 +70,20 @@ export declare type HttpResolveConfig = {
 export declare type ResolveConfig = {
     http: HttpResolveConfig;
 };
+export declare const DEFAULT_REGION = "us";
+export declare type Region = 'us' | 'eu';
+export declare type AccessTokens = {
+    [region in Region]?: string;
+};
+export declare const DOMAINS: {
+    [region in Region]: string;
+};
 export declare type RawConfig = {
     referenceDocs?: any;
     apiDefinitions?: Record<string, string>;
     lint?: LintRawConfig;
     resolve?: RawResolveConfig;
+    region?: Region;
 };
 export declare class LintConfig {
     rawConfig: LintRawConfig;
@@ -126,5 +135,6 @@ export declare class Config {
     lint: LintConfig;
     resolve: ResolveConfig;
     licenseKey?: string;
+    region?: Region;
     constructor(rawConfig: RawConfig, configFile?: string | undefined);
 }

package/lib/config/config.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Config = exports.LintConfig = exports.IGNORE_FILE = void 0;
+exports.Config = exports.LintConfig = exports.DOMAINS = exports.DEFAULT_REGION = exports.IGNORE_FILE = void 0;
 const fs = require("fs");
 const path = require("path");
 const path_1 = require("path");
@@ -12,6 +12,11 @@ const recommended_1 = require("./recommended");
 exports.IGNORE_FILE = '.redocly.lint-ignore.yaml';
 const IGNORE_BANNER = `# This file instructs Redocly's linter to ignore the rules contained for specific parts of your API.\n` +
     `# See https://redoc.ly/docs/cli/ for more information.\n`;
+exports.DEFAULT_REGION = 'us';
+exports.DOMAINS = {
+    us: 'redoc.ly',
+    eu: 'eu.redocly.com',
+};
 class LintConfig {
     constructor(rawConfig, configFile) {
         this.rawConfig = rawConfig;
@@ -233,6 +238,7 @@ class Config {
                 customFetch: undefined,
             },
         };
+        this.region = rawConfig.region;
     }
 }
 exports.Config = Config;

package/lib/config/load.js

@@ -35,20 +35,29 @@ function loadConfig(configPath, customExtends) {
             rawConfig.lint.extends = customExtends;
         }
         const redoclyClient = new redocly_1.RedoclyClient();
-        if (redoclyClient.hasToken()) {
+        const tokens = yield redoclyClient.getTokens();
+        if (tokens.length) {
             if (!rawConfig.resolve)
                 rawConfig.resolve = {};
             if (!rawConfig.resolve.http)
                 rawConfig.resolve.http = {};
-            rawConfig.resolve.http.headers = [
-                {
-                    matches: `https://api.${process.env.REDOCLY_DOMAIN || 'redoc.ly'}/registry/**`,
+            rawConfig.resolve.http.headers = [...((_a = rawConfig.resolve.http.headers) !== null && _a !== void 0 ? _a : [])];
+            for (const item of tokens) {
+                const domain = config_1.DOMAINS[item.region];
+                rawConfig.resolve.http.headers.push({
+                    matches: `https://api.${domain}/registry/**`,
                     name: 'Authorization',
                     envVariable: undefined,
-                    value: (redoclyClient && (yield redoclyClient.getAuthorizationHeader())) || '',
-                },
-                ...((_a = rawConfig.resolve.http.headers) !== null && _a !== void 0 ? _a : []),
-            ];
+                    value: item.token,
+                }, 
+                //support redocly.com domain for future compatibility
+                ...(item.region === 'us' ? [{
+                        matches: `https://api.redocly.com/registry/**`,
+                        name: 'Authorization',
+                        envVariable: undefined,
+                        value: item.token,
+                    }] : []));
+            }
         }
         return new config_1.Config(Object.assign(Object.assign({}, rawConfig), { lint: Object.assign(Object.assign({}, rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.lint), { plugins: [...(((_b = rawConfig === null || rawConfig === void 0 ? void 0 : rawConfig.lint) === null || _b === void 0 ? void 0 : _b.plugins) || []), builtIn_1.defaultPlugin] }) }), configPath);
     });

package/lib/index.d.ts

@@ -8,7 +8,7 @@ export { Oas2Definition } from './typings/swagger';
 export { StatsAccumulator, StatsName } from './typings/common';
 export { normalizeTypes } from './types';
 export { Stats } from './rules/other/stats';
-export { Config, LintConfig, RawConfig, IGNORE_FILE } from './config/config';
+export { Config, LintConfig, RawConfig, IGNORE_FILE, Region } from './config/config';
 export { loadConfig } from './config/load';
 export { RedoclyClient } from './redocly';
 export { Source, BaseResolver, Document, resolveDocument, ResolveError, YamlParseError, makeDocumentFromString, } from './resolve';
@@ -19,5 +19,5 @@ export { normalizeVisitors } from './visitors';
 export { WalkContext, walkDocument, NormalizedProblem, ProblemSeverity, LineColLocationObject, LocationObject, Loc, } from './walk';
 export { getAstNodeByPointer, getLineColLocation } from './format/codeframes';
 export { formatProblems, OutputFormat, getTotals, Totals } from './format/format';
-export { lint, lint as validate, lintDocument, lintFromString, lintConfig, } from './lint';
+export { lint, lint as validate, lintDocument, lintFromString, lintConfig } from './lint';
 export { bundle, bundleDocument } from './bundle';

package/lib/lint.js

@@ -51,6 +51,7 @@ function lintDocument(opts) {
         const ctx = {
             problems: [],
             oasVersion: oasVersion,
+            visitorsData: {},
         };
         const preprocessors = rules_1.initRules(rules, config, 'preprocessors', oasVersion);
         const regularRules = rules_1.initRules(rules, config, 'rules', oasVersion);
@@ -77,6 +78,7 @@ function lintConfig(opts) {
         const ctx = {
             problems: [],
             oasVersion: oas_types_1.OasVersion.Version3_0,
+            visitorsData: {},
         };
         const config = new config_1.LintConfig({
             plugins: [builtIn_1.defaultPlugin],

package/lib/redocly/index.d.ts

@@ -1,25 +1,31 @@
+import { RegistryApi } from './registry-api';
+import { AccessTokens, Region } from '../config/config';
 export declare class RedoclyClient {
-    private accessToken;
-    constructor();
-    hasToken(): boolean;
-    loadToken(): void;
+    private accessTokens;
+    private region;
+    domain: string;
+    registryApi: RegistryApi;
+    constructor(region?: Region);
+    loadRegion(region?: Region): Region;
+    getRegion(): Region;
+    hasTokens(): boolean;
+    setAccessTokens(accessTokens: AccessTokens): void;
+    loadTokens(): void;
+    getValidTokens(): Promise<{
+        region: string;
+        token: string;
+        valid: boolean;
+    }[]>;
+    getTokens(): Promise<{
+        region: string;
+        token: string;
+        valid: boolean;
+    }[]>;
+    isAuthorizedWithRedoclyByRegion(): Promise<boolean>;
     isAuthorizedWithRedocly(): Promise<boolean>;
-    verifyToken(accessToken: string, verbose?: boolean): Promise<boolean>;
-    getAuthorizationHeader(): Promise<string | undefined>;
+    readCredentialsFile(credentialsPath: string): any;
+    verifyToken(accessToken: string, region: Region, verbose?: boolean): Promise<boolean>;
     login(accessToken: string, verbose?: boolean): Promise<void>;
     logout(): void;
-    query(queryString: string, parameters?: {}, headers?: {}): Promise<any>;
-    static authorize(accessToken: string, options: {
-        queryName?: string;
-        verbose?: boolean;
-    }): Promise<any>;
-    updateDependencies(dependencies: string[] | undefined): Promise<void>;
-    updateDefinitionVersion(definitionId: number, versionId: number, updatePatch: object): Promise<void>;
-    getOrganizationId(organizationId: string): Promise<any>;
-    getDefinitionByName(name: string, organizationId: string): Promise<any>;
-    createDefinition(organizationId: string, name: string): Promise<any>;
-    createDefinitionVersion(definitionId: string, name: string, sourceType: string, source: any): Promise<any>;
-    getSignedUrl(organizationId: string, filesHash: string, fileName: string): Promise<any>;
-    getDefinitionVersion(organizationId: string, definitionName: string, versionName: string): Promise<any>;
-    static isRegistryURL(link: string): boolean;
 }
+export declare function isRedoclyRegistryURL(link: string): boolean;

package/lib/redocly/index.js

@@ -9,69 +9,103 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RedoclyClient = void 0;
+exports.isRedoclyRegistryURL = exports.RedoclyClient = void 0;
 const fs_1 = require("fs");
 const path_1 = require("path");
 const os_1 = require("os");
 const colorette_1 = require("colorette");
-const query_1 = require("./query");
+const registry_api_1 = require("./registry-api");
+const config_1 = require("../config/config");
+const utils_1 = require("../utils");
 const TOKEN_FILENAME = '.redocly-config.json';
 class RedoclyClient {
-    constructor() {
-        this.loadToken();
+    constructor(region) {
+        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.registryApi = new registry_api_1.RegistryApi(this.accessTokens, this.region);
+    }
+    loadRegion(region) {
+        if (region && !config_1.DOMAINS[region]) {
+            process.stdout.write(colorette_1.red(`Invalid argument: region in config file.\nGiven: ${colorette_1.green(region)}, choices: "us", "eu".\n`));
+            process.exit(1);
+        }
+        if (process.env.REDOCLY_DOMAIN) {
+            return (Object.keys(config_1.DOMAINS).find((region) => config_1.DOMAINS[region] === process.env.REDOCLY_DOMAIN) || config_1.DEFAULT_REGION);
+        }
+        return region || config_1.DEFAULT_REGION;
     }
-    hasToken() {
-        return !!this.accessToken;
+    getRegion() {
+        return this.region;
     }
-    loadToken() {
-        if (process.env.REDOCLY_AUTHORIZATION) {
-            this.accessToken = process.env.REDOCLY_AUTHORIZATION;
-            return;
-        }
+    hasTokens() {
+        return utils_1.isNotEmptyObject(this.accessTokens);
+    }
+    setAccessTokens(accessTokens) {
+        this.accessTokens = accessTokens;
+    }
+    loadTokens() {
         const credentialsPath = path_1.resolve(os_1.homedir(), TOKEN_FILENAME);
-        if (fs_1.existsSync(credentialsPath)) {
-            const credentials = JSON.parse(fs_1.readFileSync(credentialsPath, 'utf-8'));
-            this.accessToken = credentials && credentials.token;
+        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
+            })));
+        }
+        if (process.env.REDOCLY_AUTHORIZATION) {
+            this.setAccessTokens(Object.assign(Object.assign({}, this.accessTokens), { [this.region]: process.env.REDOCLY_AUTHORIZATION }));
         }
     }
-    isAuthorizedWithRedocly() {
+    getValidTokens() {
         return __awaiter(this, void 0, void 0, function* () {
-            return this.hasToken() && !!(yield this.getAuthorizationHeader());
+            return (yield Promise.all(Object.entries(this.accessTokens).map(([key, value]) => __awaiter(this, void 0, void 0, function* () {
+                return { region: key, token: value, valid: yield this.verifyToken(value, key) };
+            })))).filter(item => Boolean(item.valid));
         });
     }
-    verifyToken(accessToken, verbose = false) {
+    getTokens() {
         return __awaiter(this, void 0, void 0, function* () {
-            if (!accessToken)
-                return false;
-            const authDetails = yield RedoclyClient.authorize(accessToken, { verbose });
-            if (!authDetails)
+            return this.hasTokens() ? yield this.getValidTokens() : [];
+        });
+    }
+    isAuthorizedWithRedoclyByRegion() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.hasTokens())
                 return false;
-            return true;
+            const accessToken = this.accessTokens[this.region];
+            return !!accessToken && (yield this.verifyToken(accessToken, this.region));
         });
     }
-    getAuthorizationHeader() {
+    isAuthorizedWithRedocly() {
         return __awaiter(this, void 0, void 0, function* () {
-            // print this only if there is token but invalid
-            if (this.accessToken && !(yield this.verifyToken(this.accessToken))) {
-                process.stderr.write(`${colorette_1.yellow('Warning:')} invalid Redocly API key. Use "npx @redocly/openapi-cli login" to provide your API key\n`);
-                return undefined;
-            }
-            return this.accessToken;
+            return this.hasTokens() && utils_1.isNotEmptyObject(yield this.getValidTokens());
+        });
+    }
+    readCredentialsFile(credentialsPath) {
+        return fs_1.existsSync(credentialsPath) ? JSON.parse(fs_1.readFileSync(credentialsPath, 'utf-8')) : {};
+    }
+    verifyToken(accessToken, region, verbose = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!accessToken)
+                return false;
+            return this.registryApi.authStatus(accessToken, region, verbose);
         });
     }
     login(accessToken, verbose = false) {
         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, verbose);
+            const authorized = yield this.verifyToken(accessToken, this.region, verbose);
             if (!authorized) {
                 process.stdout.write(colorette_1.red('Authorization failed. Please check if you entered a valid API key.\n'));
                 process.exit(1);
             }
-            this.accessToken = accessToken;
-            const credentials = {
-                token: accessToken,
-            };
+            const credentials = Object.assign(Object.assign({}, this.readCredentialsFile(credentialsPath)), { [this.region]: accessToken, token: accessToken });
+            this.accessTokens = credentials;
+            this.registryApi.setAccessTokens(credentials);
             fs_1.writeFileSync(credentialsPath, JSON.stringify(credentials, null, 2));
             process.stdout.write(colorette_1.green('  Authorization confirmed. ✅\n\n'));
         });
@@ -83,185 +117,20 @@ class RedoclyClient {
         }
         process.stdout.write('Logged out from the Redocly account. ✋\n');
     }
-    query(queryString, parameters = {}, headers = {}) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return query_1.query(queryString, parameters, Object.assign({ Authorization: this.accessToken }, headers));
-        });
-    }
-    static authorize(accessToken, options) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const { queryName = '', verbose = false } = options;
-            try {
-                const queryStr = `query ${queryName}{ viewer { id } }`;
-                return yield query_1.query(queryStr, {}, { Authorization: accessToken });
-            }
-            catch (e) {
-                if (verbose)
-                    console.log(e);
-                return null;
-            }
-        });
-    }
-    updateDependencies(dependencies) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const definitionId = process.env.DEFINITION;
-            const versionId = process.env.DEFINITION;
-            const branchId = process.env.BRANCH;
-            if (!definitionId || !versionId || !branchId)
-                return;
-            yield this.query(`
-    mutation UpdateBranchDependenciesFromURLs(
-      $urls: [String!]!
-      $definitionId: Int!
-      $versionId: Int!
-      $branchId: Int!
-    ) {
-      updateBranchDependenciesFromURLs(
-        definitionId: $definitionId
-        versionId: $versionId
-        branchId: $branchId
-        urls: $urls
-      ) {
-        branchName
-      }
-    }
-    `, {
-                urls: dependencies || [],
-                definitionId: parseInt(definitionId, 10),
-                versionId: parseInt(versionId, 10),
-                branchId: parseInt(branchId, 10),
-            });
-        });
-    }
-    updateDefinitionVersion(definitionId, versionId, updatePatch) {
-        return this.query(`
-      mutation UpdateDefinitionVersion($definitionId: Int!, $versionId: Int!, $updatePatch: DefinitionVersionPatch!) {
-        updateDefinitionVersionByDefinitionIdAndId(input: {definitionId: $definitionId, id: $versionId, patch: $updatePatch}) {
-          definitionVersion {
-            ...VersionDetails
-            __typename
-          }
-          __typename
-        }
-      }
-
-      fragment VersionDetails on DefinitionVersion {
-        id
-        nodeId
-        uuid
-        definitionId
-        name
-        description
-        sourceType
-        source
-        registryAccess
-        __typename
-      }
-    `, {
-            definitionId,
-            versionId,
-            updatePatch,
-        });
-    }
-    getOrganizationId(organizationId) {
-        return this.query(`
-      query ($organizationId: String!) {
-        organizationById(id: $organizationId) {
-          id
-        }
-      }
-    `, {
-            organizationId
-        });
-    }
-    getDefinitionByName(name, organizationId) {
-        return this.query(`
-      query ($name: String!, $organizationId: String!) {
-        definition: definitionByOrganizationIdAndName(name: $name, organizationId: $organizationId) {
-          id
-        }
-      }
-    `, {
-            name,
-            organizationId
-        });
-    }
-    createDefinition(organizationId, name) {
-        return this.query(`
-      mutation CreateDefinition($organizationId: String!, $name: String!) {
-        def: createDefinition(input: {organizationId: $organizationId, name: $name }) {
-          definition {
-            id
-            nodeId
-            name
-          }
-        }
-      }
-    `, {
-            organizationId,
-            name
-        });
-    }
-    createDefinitionVersion(definitionId, name, sourceType, source) {
-        return this.query(`
-      mutation CreateVersion($definitionId: Int!, $name: String!, $sourceType: DvSourceType!, $source: JSON) {
-        createDefinitionVersion(input: {definitionId: $definitionId, name: $name, sourceType: $sourceType, source: $source }) {
-          definitionVersion {
-            id
-          }
-        }
-      }
-    `, {
-            definitionId,
-            name,
-            sourceType,
-            source
-        });
-    }
-    getSignedUrl(organizationId, filesHash, fileName) {
-        return this.query(`
-      query ($organizationId: String!, $filesHash: String!, $fileName: String!) {
-        signFileUploadCLI(organizationId: $organizationId, filesHash: $filesHash, fileName: $fileName) {
-          signedFileUrl
-          uploadedFilePath
-        }
-      }
-    `, {
-            organizationId,
-            filesHash,
-            fileName
-        });
-    }
-    getDefinitionVersion(organizationId, definitionName, versionName) {
-        return this.query(`
-      query ($organizationId: String!, $definitionName: String!, $versionName: String!) {
-        version: definitionVersionByOrganizationDefinitionAndName(organizationId: $organizationId, definitionName: $definitionName, versionName: $versionName) {
-          id
-          definitionId
-          defaultBranch {
-            name
-          }
-        }
-      }
-    `, {
-            organizationId,
-            definitionName,
-            versionName
-        });
-    }
-    static isRegistryURL(link) {
-        const domain = process.env.REDOCLY_DOMAIN || 'redoc.ly';
-        if (!link.startsWith(`https://api.${domain}/registry/`))
-            return false;
-        const registryPath = link.replace(`https://api.${domain}/registry/`, '');
-        const pathParts = registryPath.split('/');
-        // we can be sure, that there is job UUID present
-        // (org, definition, version, bundle, branch, job, "openapi.yaml" 🤦‍♂️)
-        // so skip this link.
-        // FIXME
-        if (pathParts.length === 7)
-            return false;
-        return true;
-    }
 }
 exports.RedoclyClient = RedoclyClient;
+function isRedoclyRegistryURL(link) {
+    const domain = process.env.REDOCLY_DOMAIN || config_1.DOMAINS[config_1.DEFAULT_REGION];
+    if (!link.startsWith(`https://api.${domain}/registry/`))
+        return false;
+    const registryPath = link.replace(`https://api.${domain}/registry/`, '');
+    const pathParts = registryPath.split('/');
+    // we can be sure, that there is job UUID present
+    // (org, definition, version, bundle, branch, job, "openapi.yaml" 🤦‍♂️)
+    // so skip this link.
+    // FIXME
+    if (pathParts.length === 7)
+        return false;
+    return true;
+}
+exports.isRedoclyRegistryURL = isRedoclyRegistryURL;

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

@@ -0,0 +1,28 @@
+export declare namespace RegistryApiTypes {
+    interface VersionParams {
+        organizationId: string;
+        name: string;
+        version: string;
+    }
+    export interface PrepareFileuploadParams extends VersionParams {
+        filesHash: string;
+        filename: string;
+        isUpsert?: boolean;
+    }
+    export interface PushApiParams extends VersionParams {
+        rootFilePath: string;
+        filePaths: string[];
+        branch?: string;
+        isUpsert?: boolean;
+    }
+    export interface PrepareFileuploadOKResponse {
+        filePath: string;
+        signedUploadUrl: string;
+    }
+    export interface NotFoundProblemResponse {
+        status: 404;
+        title: 'Not Found';
+        code: 'ORGANIZATION_NOT_FOUND' | 'API_VERSION_NOT_FOUND';
+    }
+    export {};
+}