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

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/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,5 +1,7 @@
+import { RegistryApi } from './registry-api';
 export declare class RedoclyClient {
     private accessToken;
+    registryApi: RegistryApi;
     constructor();
     hasToken(): boolean;
     loadToken(): void;
@@ -8,18 +10,5 @@ export declare class RedoclyClient {
     getAuthorizationHeader(): Promise<string | undefined>;
     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,16 +9,17 @@ 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 TOKEN_FILENAME = '.redocly-config.json';
 class RedoclyClient {
     constructor() {
         this.loadToken();
+        this.registryApi = new registry_api_1.RegistryApi(this.accessToken);
     }
     hasToken() {
         return !!this.accessToken;
@@ -43,10 +44,7 @@ class RedoclyClient {
         return __awaiter(this, void 0, void 0, function* () {
             if (!accessToken)
                 return false;
-            const authDetails = yield RedoclyClient.authorize(accessToken, { verbose });
-            if (!authDetails)
-                return false;
-            return true;
+            return this.registryApi.setAccessToken(accessToken).authStatus(verbose);
         });
     }
     getAuthorizationHeader() {
@@ -83,185 +81,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 || '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.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 {};
+}

package/lib/redocly/registry-api-types.js

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

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

@@ -0,0 +1,11 @@
+import { RegistryApiTypes } from './registry-api-types';
+export declare class RegistryApi {
+    private accessToken?;
+    private readonly baseUrl;
+    constructor(accessToken?: string | undefined);
+    private request;
+    setAccessToken(accessToken: string): this;
+    authStatus(verbose?: boolean): Promise<boolean>;
+    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

@@ -0,0 +1,94 @@
+"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.RegistryApi = void 0;
+const node_fetch_1 = require("node-fetch");
+const version = require('../../package.json').version;
+class RegistryApi {
+    constructor(accessToken) {
+        this.accessToken = accessToken;
+        this.baseUrl = `https://api.${process.env.REDOCLY_DOMAIN || 'redoc.ly'}/registry`;
+    }
+    request(path = '', options = {}) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.accessToken) {
+                throw new Error('Unauthorized');
+            }
+            const headers = Object.assign({}, options.headers || {}, {
+                authorization: this.accessToken,
+                'x-redocly-cli-version': version,
+            });
+            const response = yield node_fetch_1.default(`${this.baseUrl}${path}`, Object.assign({}, options, { headers }));
+            if (response.status === 401) {
+                throw new Error('Unauthorized');
+            }
+            if (response.status === 404) {
+                const body = yield response.json();
+                throw new Error(body.code);
+            }
+            return response;
+        });
+    }
+    setAccessToken(accessToken) {
+        this.accessToken = accessToken;
+        return this;
+    }
+    authStatus(verbose = false) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const response = yield this.request();
+                return response.ok;
+            }
+            catch (error) {
+                if (verbose) {
+                    console.log(error);
+                }
+                return false;
+            }
+        });
+    }
+    prepareFileUpload({ organizationId, name, version, filesHash, filename, isUpsert, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request(`/${organizationId}/${name}/${version}/prepare-file-upload`, {
+                method: 'POST',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    filesHash,
+                    filename,
+                    isUpsert,
+                }),
+            });
+            if (response.ok) {
+                return response.json();
+            }
+            throw new Error('Could not prepare file upload');
+        });
+    }
+    pushApi({ organizationId, name, version, rootFilePath, filePaths, branch, isUpsert, }) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.request(`/${organizationId}/${name}/${version}`, {
+                method: 'PUT',
+                headers: { 'content-type': 'application/json' },
+                body: JSON.stringify({
+                    rootFilePath,
+                    filePaths,
+                    branch,
+                    isUpsert,
+                }),
+            });
+            if (response.ok) {
+                return;
+            }
+            throw new Error('Could not push api');
+        });
+    }
+}
+exports.RegistryApi = RegistryApi;

package/lib/rules/common/registry-dependencies.js

@@ -3,21 +3,18 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RegistryDependencies = void 0;
 const redocly_1 = require("../../redocly");
 const RegistryDependencies = () => {
-    let redoclyClient;
     let registryDependencies = new Set();
     return {
         DefinitionRoot: {
-            leave() {
-                redoclyClient = new redocly_1.RedoclyClient();
-                if (process.env.UPDATE_REGISTRY && redoclyClient.hasToken()) {
-                    redoclyClient.updateDependencies(Array.from(registryDependencies.keys()));
-                }
+            leave(_, ctx) {
+                const data = ctx.getVisitorData();
+                data.links = Array.from(registryDependencies);
             },
         },
         ref(node) {
             if (node.$ref) {
                 const link = node.$ref.split('#/')[0];
-                if (redocly_1.RedoclyClient.isRegistryURL(link)) {
+                if (redocly_1.isRedoclyRegistryURL(link)) {
                     registryDependencies.add(link);
                 }
             }

package/lib/walk.d.ts

@@ -36,6 +36,7 @@ export declare type UserContext = {
     key: string | number;
     parent: any;
     oasVersion: OasVersion;
+    getVisitorData: () => Record<string, unknown>;
 };
 export declare type Loc = {
     line: number;
@@ -72,6 +73,7 @@ export declare type NormalizedProblem = {
 export declare type WalkContext = {
     problems: NormalizedProblem[];
     oasVersion: OasVersion;
+    visitorsData: Record<string, Record<string, unknown>>;
     refTypes?: Map<string, NormalizedNodeType>;
 };
 export declare function walkDocument<T>(opts: {

package/lib/walk.js

@@ -50,6 +50,7 @@ function walkDocument(opts) {
                         key,
                         parentLocations: {},
                         oasVersion: ctx.oasVersion,
+                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId)
                     }, { node: resolvedNode, location: resolvedLocation, error });
                     if ((resolvedLocation === null || resolvedLocation === void 0 ? void 0 : resolvedLocation.source.absoluteRef) && ctx.refTypes) {
                         ctx.refTypes.set(resolvedLocation === null || resolvedLocation === void 0 ? void 0 : resolvedLocation.source.absoluteRef, type);
@@ -192,6 +193,7 @@ function walkDocument(opts) {
                         key,
                         parentLocations: {},
                         oasVersion: ctx.oasVersion,
+                        getVisitorData: getVisitorDataFn.bind(undefined, ruleId)
                     }, { node: resolvedNode, location: resolvedLocation, error });
                 }
             }
@@ -212,6 +214,7 @@ function walkDocument(opts) {
                 ignoreNextVisitorsOnNode: () => {
                     ignoreNextVisitorsOnNode = true;
                 },
+                getVisitorData: getVisitorDataFn.bind(undefined, ruleId),
             }, collectParents(context), context);
             return ignoreNextVisitorsOnNode;
         }
@@ -244,6 +247,10 @@ function walkDocument(opts) {
                     return Object.assign(Object.assign(Object.assign({}, currentLocation), { reportOnKey: false }), loc);
                 }) }));
         }
+        function getVisitorDataFn(ruleId) {
+            ctx.visitorsData[ruleId] = ctx.visitorsData[ruleId] || {};
+            return ctx.visitorsData[ruleId];
+        }
     }
 }
 exports.walkDocument = walkDocument;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@redocly/openapi-core",
-  "version": "1.0.0-beta.68",
+  "version": "1.0.0-beta.69",
   "description": "",
   "main": "lib/index.js",
   "engines": {
@@ -50,4 +50,4 @@
     "@types/pluralize": "^0.0.29",
     "typescript": "^4.0.5"
   }
-}
+}

package/src/bundle.ts

@@ -13,6 +13,7 @@ import { initRules } from './config/rules';
 import { reportUnresolvedRef } from './rules/no-unresolved-refs';
 import { isPlainObject } from './utils';
 import { OasRef } from './typings/openapi';
+import { isRedoclyRegistryURL } from './redocly';
 
 export type Oas3RuleSet = Record<string, Oas3Rule>;
 
@@ -29,6 +30,7 @@ export async function bundle(opts: {
   config: Config;
   dereference?: boolean;
   base?: string;
+  skipRedoclyRegistryRefs?: boolean;
 }) {
   const {
     ref,
@@ -63,8 +65,16 @@ export async function bundleDocument(opts: {
   customTypes?: Record<string, NodeType>;
   externalRefResolver: BaseResolver;
   dereference?: boolean;
+  skipRedoclyRegistryRefs?: boolean;
 }) {
-  const { document, config, customTypes, externalRefResolver, dereference = false } = opts;
+  const {
+    document,
+    config,
+    customTypes,
+    externalRefResolver,
+    dereference = false,
+    skipRedoclyRegistryRefs = false,
+  } = opts;
   const oasVersion = detectOpenAPI(document.parsed);
   const oasMajorVersion = openAPIMajor(oasVersion);
   const rules = config.getRulesForOasVersion(oasMajorVersion);
@@ -86,6 +96,7 @@ export async function bundleDocument(opts: {
     problems: [],
     oasVersion: oasVersion,
     refTypes: new Map<string, NormalizedNodeType>(),
+    visitorsData: {},
   };
 
   const bundleVisitor = normalizeVisitors(
@@ -94,7 +105,7 @@ export async function bundleDocument(opts: {
       {
         severity: 'error',
         ruleId: 'bundler',
-        visitor: makeBundleVisitor(oasMajorVersion, dereference, document),
+        visitor: makeBundleVisitor(oasMajorVersion, dereference, skipRedoclyRegistryRefs, document),
       },
       ...decorators,
     ],
@@ -121,6 +132,7 @@ export async function bundleDocument(opts: {
     fileDependencies: externalRefResolver.getFiles(),
     rootType: types.DefinitionRoot,
     refTypes: ctx.refTypes,
+    visitorsData: ctx.visitorsData,
   };
 }
 
@@ -165,7 +177,12 @@ function mapTypeToComponent(typeName: string, version: OasMajorVersion) {
 
 // function oas3Move
 
-function makeBundleVisitor(version: OasMajorVersion, dereference: boolean, rootDocument: Document) {
+function makeBundleVisitor(
+  version: OasMajorVersion,
+  dereference: boolean,
+  skipRedoclyRegistryRefs: boolean,
+  rootDocument: Document,
+) {
   let components: Record<string, Record<string, any>>;
 
   const visitor: Oas3Visitor | Oas2Visitor = {
@@ -183,6 +200,11 @@ function makeBundleVisitor(version: OasMajorVersion, dereference: boolean, rootD
         ) {
           return;
         }
+
+        if (skipRedoclyRegistryRefs && isRedoclyRegistryURL(node.$ref)) {
+          return;
+        }
+
         const componentType = mapTypeToComponent(ctx.type.name, version);
         if (!componentType) {
           replaceRef(node, resolved, ctx);