@redocly/openapi-core 1.9.0 → 1.10.0

package/src/__tests__/ref-utils.test.ts

@@ -96,6 +96,28 @@ describe('ref-utils', () => {
     expect(result).toMatchInlineSnapshot(`[]`);
   });
 
+  it('should parse a ref correctly', () => {
+    expect(parseRef('./info.yaml#/description')).toEqual({
+      uri: './info.yaml',
+      pointer: ['description'],
+    });
+  });
+
+  it('should parse a ref which contain a hash in the middle', () => {
+    // Here `info#description.md` is a file name
+    expect(parseRef('./info#description.md')).toEqual({
+      uri: './info#description.md',
+      pointer: [],
+    });
+  });
+
+  it('should parse a ref which ends with a hash', () => {
+    expect(parseRef('./info.yaml#')).toEqual({
+      uri: './info.yaml',
+      pointer: [],
+    });
+  });
+
   describe('refBaseName', () => {
     it('returns base name for file reference', () => {
       expect(refBaseName('../testcase/Pet.yaml')).toStrictEqual('Pet');

package/src/bundle.ts

@@ -14,7 +14,7 @@ import { isAbsoluteUrl, isRef, Location, refBaseName } from './ref-utils';
 import { initRules } from './config/rules';
 import { reportUnresolvedRef } from './rules/no-unresolved-refs';
 import { isPlainObject, isTruthy } from './utils';
-import { isRedoclyRegistryURL } from './redocly';
+import { isRedoclyRegistryURL } from './redocly/domains';
 import { RemoveUnusedComponents as RemoveUnusedComponentsOas2 } from './decorators/oas2/remove-unused-components';
 import { RemoveUnusedComponents as RemoveUnusedComponentsOas3 } from './decorators/oas3/remove-unused-components';
 import { ConfigTypes } from './types/redocly-yaml';

package/src/config/__tests__/load.test.ts

@@ -137,6 +137,19 @@ describe('getConfig', () => {
           "severity": "warn",
           "suggest": [],
         },
+        {
+          "location": [
+            {
+              "pointer": "#/theme",
+              "reportOnKey": false,
+              "source": "fixtures/resolve-refs-in-config/config-with-refs.yaml",
+            },
+          ],
+          "message": "Can't resolve $ref: ENOENT: no such file or directory 'fixtures/resolve-refs-in-config/wrong-ref.yaml'",
+          "ruleId": "configuration no-unresolved-refs",
+          "severity": "warn",
+          "suggest": [],
+        },
         {
           "from": {
             "pointer": "#/rules",
@@ -154,19 +167,6 @@ describe('getConfig', () => {
           "severity": "warn",
           "suggest": [],
         },
-        {
-          "location": [
-            {
-              "pointer": "#/theme",
-              "reportOnKey": false,
-              "source": "fixtures/resolve-refs-in-config/config-with-refs.yaml",
-            },
-          ],
-          "message": "Can't resolve $ref: ENOENT: no such file or directory 'fixtures/resolve-refs-in-config/wrong-ref.yaml'",
-          "ruleId": "configuration no-unresolved-refs",
-          "severity": "warn",
-          "suggest": [],
-        },
       ]
     `);
   });

package/src/config/config.ts

@@ -10,7 +10,7 @@ import {
   Oas3RuleSet,
   Async2RuleSet,
 } from '../oas-types';
-import { isBrowser, env } from '../env';
+import { isBrowser } from '../env';
 
 import type { NodeType } from '../types';
 import type {
@@ -35,25 +35,6 @@ 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`;
 
-export const DEFAULT_REGION = 'us';
-
-function getDomains() {
-  const domains: { [region in Region]: string } = {
-    us: 'redocly.com',
-    eu: 'eu.redocly.com',
-  };
-
-  // FIXME: temporary fix for our lab environments
-  const domain = env.REDOCLY_DOMAIN;
-  if (domain?.endsWith('.redocly.host')) {
-    domains[domain.split('.')[0] as Region] = domain;
-  }
-  if (domain === 'redoc.online') {
-    domains[domain as Region] = domain;
-  }
-  return domains;
-}
-
 function getIgnoreFilePath(configFile?: string): string | undefined {
   if (configFile) {
     return doesYamlFileExist(configFile)
@@ -64,9 +45,6 @@ function getIgnoreFilePath(configFile?: string): string | undefined {
   }
 }
 
-export const DOMAINS = getDomains();
-export const AVAILABLE_REGIONS = Object.keys(DOMAINS) as Region[];
-
 export class StyleguideConfig {
   plugins: Plugin[];
   ignore: Record<string, Record<string, Set<string>>> = {};

package/src/config/load.ts

@@ -3,7 +3,7 @@ import * as path from 'path';
 import { RedoclyClient } from '../redocly';
 import { isEmptyObject, doesYamlFileExist } from '../utils';
 import { parseYaml } from '../js-yaml';
-import { Config, DOMAINS } from './config';
+import { Config } from './config';
 import { ConfigValidationError, transformConfig } from './utils';
 import { resolveConfig, resolveConfigFileAndRefs } from './config-resolvers';
 import { bundleConfig } from '../bundle';
@@ -12,6 +12,7 @@ import type { Document } from '../resolve';
 import type { RegionalTokenWithValidity } from '../redocly/redocly-client-types';
 import type { RawConfig, RawUniversalConfig, Region } from './types';
 import type { BaseResolver, ResolvedRefMap } from '../resolve';
+import { DOMAINS } from '../redocly/domains';
 
 async function addConfigMetadata({
   rawConfig,

package/src/decorators/common/registry-dependencies.ts

@@ -1,5 +1,5 @@
 import { UserContext } from '../../walk';
-import { isRedoclyRegistryURL } from '../../redocly';
+import { isRedoclyRegistryURL } from '../../redocly/domains';
 
 import { Oas3Decorator, Oas2Decorator } from '../../visitors';
 

package/src/decorators/oas2/remove-unused-components.ts

@@ -1,8 +1,9 @@
-import type { Oas2Decorator } from '../../visitors';
 import { Location } from '../../ref-utils';
-import type { Oas2Components } from '../../typings/swagger';
 import { isEmptyObject } from '../../utils';
 
+import type { Oas2Decorator } from '../../visitors';
+import type { Oas2Components } from '../../typings/swagger';
+
 export const RemoveUnusedComponents: Oas2Decorator = () => {
   const components = new Map<
     string,

package/src/decorators/oas3/remove-unused-components.ts

@@ -1,8 +1,9 @@
-import type { Oas3Decorator } from '../../visitors';
 import { Location } from '../../ref-utils';
-import type { Oas3Components } from '../../typings/openapi';
 import { isEmptyObject } from '../../utils';
 
+import type { Oas3Decorator } from '../../visitors';
+import type { Oas3Components } from '../../typings/openapi';
+
 export const RemoveUnusedComponents: Oas3Decorator = () => {
   const components = new Map<
     string,

package/src/index.ts

@@ -1,4 +1,11 @@
-export { BundleOutputFormat, readFileFromUrl, slash, doesYamlFileExist, isTruthy } from './utils';
+export {
+  BundleOutputFormat,
+  readFileFromUrl,
+  slash,
+  doesYamlFileExist,
+  isTruthy,
+  getProxyAgent,
+} from './utils';
 export { Oas3_1Types } from './types/oas3_1';
 export { Oas3Types } from './types/oas3';
 export { Oas2Types } from './types/oas2';
@@ -41,7 +48,9 @@ export {
   ResolvedApi,
 } from './config';
 
-export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
+export { RedoclyClient } from './redocly';
+
+export * from './redocly/domains';
 
 export {
   Source,

package/src/lint.ts

@@ -112,6 +112,7 @@ export async function lintConfig(opts: {
   resolvedRefMap?: ResolvedRefMap;
   severity?: ProblemSeverity;
   externalRefResolver?: BaseResolver;
+  externalConfigTypes?: Record<string, NodeType>;
 }) {
   const { document, severity, externalRefResolver = new BaseResolver() } = opts;
 
@@ -126,7 +127,7 @@ export async function lintConfig(opts: {
     rules: { spec: 'error' },
   });
 
-  const types = normalizeTypes(ConfigTypes, config);
+  const types = normalizeTypes(opts.externalConfigTypes || ConfigTypes, config);
   const rules: (RuleInstanceConfig & {
     visitor: NestedVisitObject<unknown, Oas3Visitor | Oas3Visitor[]>;
   })[] = [

package/src/redocly/__tests__/domains.test.ts

@@ -0,0 +1,52 @@
+import { RedoclyClient } from '../../index';
+import { setRedoclyDomain, getRedoclyDomain, getDomains, AVAILABLE_REGIONS } from '../domains';
+
+describe('domains', () => {
+  const REDOCLY_DOMAIN_US = 'redocly.com';
+  const TEST_DOMAIN = 'redoclyDomain.com';
+  const TEST_LAB_DOMAIN = 'lab.redocly.host';
+  const TEST_REDOC_ONLINE_DOMAIN = 'redoc.online';
+
+  afterEach(() => {
+    delete process.env.REDOCLY_DOMAIN;
+    setRedoclyDomain('');
+  });
+
+  it('should resolve the US domain by default', () => {
+    expect(getRedoclyDomain()).toBe(REDOCLY_DOMAIN_US);
+  });
+
+  it('should resolve the US and EU regions by default', () => {
+    expect(AVAILABLE_REGIONS).toStrictEqual(['us', 'eu']);
+  });
+
+  it('should resolve the specified domain if used with setter', () => {
+    setRedoclyDomain(TEST_DOMAIN);
+    expect(getRedoclyDomain()).toBe(TEST_DOMAIN);
+  });
+
+  it('should resolve the specified domain provided in environmental variable, after initializing RedoclyClient', () => {
+    process.env.REDOCLY_DOMAIN = TEST_DOMAIN;
+    const client = new RedoclyClient();
+    expect(getRedoclyDomain()).toBe(TEST_DOMAIN);
+    expect(client.domain).toBe(TEST_DOMAIN);
+  });
+
+  it('should return correct object when redocly domain is set to lab env', () => {
+    setRedoclyDomain(TEST_LAB_DOMAIN);
+    const domains = getDomains();
+    expect(domains).toEqual({ us: 'redocly.com', eu: 'eu.redocly.com', lab: 'lab.redocly.host' });
+    expect(getRedoclyDomain()).toBe(TEST_LAB_DOMAIN);
+  });
+
+  it('should return correct object when redocly domain is set to redoc.online env', () => {
+    setRedoclyDomain(TEST_REDOC_ONLINE_DOMAIN);
+    const domains = getDomains();
+    expect(domains).toEqual({
+      us: 'redocly.com',
+      eu: 'eu.redocly.com',
+      'redoc.online': 'redoc.online',
+    });
+    expect(getRedoclyDomain()).toBe(TEST_REDOC_ONLINE_DOMAIN);
+  });
+});

package/src/redocly/__tests__/redocly-client.test.ts

@@ -1,3 +1,4 @@
+import { setRedoclyDomain } from '../domains';
 import { RedoclyClient } from '../index';
 
 jest.mock('node-fetch', () => ({
@@ -16,6 +17,7 @@ describe('RedoclyClient', () => {
 
   afterEach(() => {
     delete process.env.REDOCLY_DOMAIN;
+    setRedoclyDomain('');
   });
 
   it('should resolve the US domain by default', () => {
@@ -40,19 +42,19 @@ describe('RedoclyClient', () => {
   });
 
   it('should resolve domain by EU region prioritizing flag over env variable', () => {
-    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    setRedoclyDomain(testRedoclyDomain);
     const client = new RedoclyClient('eu');
     expect(client.domain).toBe(REDOCLY_DOMAIN_EU);
   });
 
   it('should resolve domain by US region prioritizing flag over env variable', () => {
-    process.env.REDOCLY_DOMAIN = testRedoclyDomain;
+    setRedoclyDomain(testRedoclyDomain);
     const client = new RedoclyClient('us');
     expect(client.domain).toBe(REDOCLY_DOMAIN_US);
   });
 
   it('should resolve domain by US region when REDOCLY_DOMAIN consists EU domain', () => {
-    process.env.REDOCLY_DOMAIN = REDOCLY_DOMAIN_EU;
+    setRedoclyDomain(REDOCLY_DOMAIN_EU);
     const client = new RedoclyClient();
     expect(client.getRegion()).toBe('eu');
   });

package/src/redocly/domains.ts

@@ -0,0 +1,48 @@
+import { Region } from '../config/types';
+
+let redoclyDomain = 'redocly.com';
+
+export const DEFAULT_REGION = 'us';
+
+export const DOMAINS = getDomains();
+export const AVAILABLE_REGIONS = Object.keys(DOMAINS) as Region[];
+
+export function getDomains() {
+  const domains: { [region in Region]: string } = {
+    us: 'redocly.com',
+    eu: 'eu.redocly.com',
+  };
+
+  // FIXME: temporary fix for our lab environments
+  const domain = redoclyDomain;
+  if (domain?.endsWith('.redocly.host')) {
+    domains[domain.split('.')[0] as Region] = domain;
+  }
+  if (domain === 'redoc.online') {
+    domains[domain as Region] = domain;
+  }
+  return domains;
+}
+
+export function setRedoclyDomain(domain: string) {
+  redoclyDomain = domain;
+}
+
+export function getRedoclyDomain(): string {
+  return redoclyDomain;
+}
+
+export function isRedoclyRegistryURL(link: string): boolean {
+  const domain = getRedoclyDomain() || DOMAINS[DEFAULT_REGION];
+
+  const legacyDomain = domain === 'redocly.com' ? 'redoc.ly' : domain;
+
+  if (
+    !link.startsWith(`https://api.${domain}/registry/`) &&
+    !link.startsWith(`https://api.${legacyDomain}/registry/`)
+  ) {
+    return false;
+  }
+
+  return true;
+}

package/src/redocly/index.ts

@@ -2,13 +2,19 @@ import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
 import { resolve } from 'path';
 import { homedir } from 'os';
 import { RegistryApi } from './registry-api';
-import { DEFAULT_REGION, DOMAINS, AVAILABLE_REGIONS } from '../config/config';
 import { env } from '../env';
 import { RegionalToken, RegionalTokenWithValidity } from './redocly-client-types';
 import { isNotEmptyObject } from '../utils';
 import { colorize } from '../logger';
 
 import type { AccessTokens, Region } from '../config/types';
+import {
+  AVAILABLE_REGIONS,
+  DEFAULT_REGION,
+  DOMAINS,
+  getRedoclyDomain,
+  setRedoclyDomain,
+} from './domains';
 
 export const TOKEN_FILENAME = '.redocly-config.json';
 
@@ -23,7 +29,7 @@ export class RedoclyClient {
     this.loadTokens();
     this.domain = region ? DOMAINS[region] : env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
 
-    env.REDOCLY_DOMAIN = this.domain; // isRedoclyRegistryURL depends on the value to be set
+    setRedoclyDomain(this.domain);
     this.registryApi = new RegistryApi(this.accessTokens, this.region);
   }
 
@@ -36,9 +42,9 @@ export class RedoclyClient {
       );
     }
 
-    if (env.REDOCLY_DOMAIN) {
+    if (getRedoclyDomain()) {
       return (AVAILABLE_REGIONS.find(
-        (region) => DOMAINS[region as Region] === env.REDOCLY_DOMAIN
+        (region) => DOMAINS[region as Region] === getRedoclyDomain()
       ) || DEFAULT_REGION) as Region;
     }
     return region || DEFAULT_REGION;
@@ -96,7 +102,7 @@ export class RedoclyClient {
     const allTokens = this.getAllTokens();
 
     const verifiedTokens = await Promise.allSettled(
-      allTokens.map(({ token, region }) => this.verifyToken(token, region))
+      allTokens.map(({ token }) => this.verifyToken(token))
     );
 
     return allTokens
@@ -120,7 +126,7 @@ export class RedoclyClient {
     }
 
     try {
-      await this.verifyToken(accessToken, this.region);
+      await this.verifyToken(accessToken);
 
       return true;
     } catch (err) {
@@ -138,17 +144,16 @@ export class RedoclyClient {
 
   async verifyToken(
     accessToken: string,
-    region: Region,
     verbose: boolean = false
   ): Promise<{ viewerId: string; organizations: string[] }> {
-    return this.registryApi.authStatus(accessToken, region, verbose);
+    return this.registryApi.authStatus(accessToken, verbose);
   }
 
   async login(accessToken: string, verbose: boolean = false) {
     const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
 
     try {
-      await this.verifyToken(accessToken, this.region, verbose);
+      await this.verifyToken(accessToken, verbose);
     } catch (err) {
       throw new Error('Authorization failed. Please check if you entered a valid API key.');
     }
@@ -170,18 +175,3 @@ export class RedoclyClient {
     }
   }
 }
-
-export function isRedoclyRegistryURL(link: string): boolean {
-  const domain = env.REDOCLY_DOMAIN || DOMAINS[DEFAULT_REGION];
-
-  const legacyDomain = domain === 'redocly.com' ? 'redoc.ly' : domain;
-
-  if (
-    !link.startsWith(`https://api.${domain}/registry/`) &&
-    !link.startsWith(`https://api.${legacyDomain}/registry/`)
-  ) {
-    return false;
-  }
-
-  return true;
-}

package/src/redocly/registry-api.ts

@@ -6,8 +6,8 @@ import type {
   PushApiParams,
 } from './registry-api-types';
 import type { AccessTokens, Region } from '../config/types';
-import { DEFAULT_REGION, DOMAINS } from '../config/config';
-import { isNotEmptyObject } from '../utils';
+import { getProxyAgent, isNotEmptyObject } from '../utils';
+import { getRedoclyDomain } from './domains';
 
 const version = require('../../package.json').version;
 
@@ -18,8 +18,8 @@ export class RegistryApi {
     return isNotEmptyObject(this.accessTokens) && this.accessTokens[this.region];
   }
 
-  getBaseUrl(region: Region = DEFAULT_REGION) {
-    return `https://api.${DOMAINS[region]}/registry`;
+  getBaseUrl() {
+    return `https://api.${getRedoclyDomain()}/registry`;
   }
 
   setAccessTokens(accessTokens: AccessTokens) {
@@ -27,7 +27,7 @@ export class RegistryApi {
     return this;
   }
 
-  private async request(path = '', options: RequestInit = {}, region?: Region) {
+  private async request(path = '', options: RequestInit = {}) {
     const currentCommand =
       typeof process !== 'undefined' ? process.env?.REDOCLY_CLI_COMMAND || '' : '';
     const redoclyEnv = typeof process !== 'undefined' ? process.env?.REDOCLY_ENVIRONMENT || '' : '';
@@ -42,8 +42,8 @@ export class RegistryApi {
     }
 
     const response = await fetch(
-      `${this.getBaseUrl(region)}${path}`,
-      Object.assign({}, options, { headers })
+      `${this.getBaseUrl()}${path}`,
+      Object.assign({}, options, { headers, agent: getProxyAgent() })
     );
 
     if (response.status === 401) {
@@ -60,11 +60,10 @@ export class RegistryApi {
 
   async authStatus(
     accessToken: string,
-    region: Region,
     verbose = false
   ): Promise<{ viewerId: string; organizations: string[] }> {
     try {
-      const response = await this.request('', { headers: { authorization: accessToken } }, region);
+      const response = await this.request('', { headers: { authorization: accessToken } });
 
       return await response.json();
     } catch (error) {
@@ -97,8 +96,7 @@ export class RegistryApi {
           filename,
           isUpsert,
         }),
-      },
-      this.region
+      }
     );
 
     if (response.ok) {
@@ -120,26 +118,22 @@ export class RegistryApi {
     batchId,
     batchSize,
   }: PushApiParams) {
-    const response = await this.request(
-      `/${organizationId}/${name}/${version}`,
-      {
-        method: 'PUT',
-        headers: {
-          'content-type': 'application/json',
-          authorization: this.accessToken,
-        } as HeadersInit,
-        body: JSON.stringify({
-          rootFilePath,
-          filePaths,
-          branch,
-          isUpsert,
-          isPublic,
-          batchId,
-          batchSize,
-        }),
-      },
-      this.region
-    );
+    const response = await this.request(`/${organizationId}/${name}/${version}`, {
+      method: 'PUT',
+      headers: {
+        'content-type': 'application/json',
+        authorization: this.accessToken,
+      } as HeadersInit,
+      body: JSON.stringify({
+        rootFilePath,
+        filePaths,
+        branch,
+        isUpsert,
+        isPublic,
+        batchId,
+        batchSize,
+      }),
+    });
 
     if (response.ok) {
       return;

package/src/ref-utils.ts

@@ -43,9 +43,9 @@ export function escapePointer<T extends string | number>(fragment: T): T {
 }
 
 export function parseRef(ref: string): { uri: string | null; pointer: string[] } {
-  const [uri, pointer = ''] = ref.split('#');
+  const [uri, pointer = ''] = ref.split('#/');
   return {
-    uri: uri || null,
+    uri: (uri.endsWith('#') ? uri.slice(0, -1) : uri) || null,
     pointer: parsePointer(pointer),
   };
 }

package/src/resolve.ts

@@ -269,8 +269,20 @@ export async function resolveDocument(opts: {
         if (itemsType === undefined && type !== unknownType && type !== SpecExtension) {
           return;
         }
+        const isTypeAFunction = typeof itemsType === 'function';
         for (let i = 0; i < node.length; i++) {
-          walk(node[i], itemsType || unknownType, joinPointer(nodeAbsoluteRef, i));
+          const itemType = isTypeAFunction
+            ? itemsType(node[i], joinPointer(nodeAbsoluteRef, i))
+            : itemsType;
+          // we continue resolving unknown types, but stop early on known scalars
+          if (itemType === undefined && type !== unknownType && type !== SpecExtension) {
+            continue;
+          }
+          walk(
+            node[i],
+            isNamedType(itemType) ? itemType : unknownType,
+            joinPointer(nodeAbsoluteRef, i)
+          );
         }
         return;
       }

package/src/types/index.ts

@@ -21,31 +21,28 @@ export type NormalizedScalarSchema = {
 export type NodeType = {
   properties: Record<string, PropType | ResolveTypeFn>;
   additionalProperties?: PropType | ResolveTypeFn;
-  items?: string;
+  items?: PropType | ResolveTypeFn;
   required?: string[] | ((value: any, key: string | number | undefined) => string[]);
   requiredOneOf?: string[];
   allowed?: (value: any) => string[] | undefined;
   extensionsPrefix?: string;
 };
-type PropType = string | NodeType | ScalarSchema | undefined | null;
-type ResolveTypeFn = (value: any, key: string) => string | PropType;
+export type PropType = string | NodeType | ScalarSchema | undefined | null;
+export type ResolveTypeFn = (value: any, key: string) => string | PropType;
 
 export type NormalizedNodeType = {
   name: string;
   properties: Record<string, NormalizedPropType | NormalizedResolveTypeFn>;
   additionalProperties?: NormalizedPropType | NormalizedResolveTypeFn;
-  items?: NormalizedNodeType;
+  items?: NormalizedPropType | NormalizedResolveTypeFn;
   required?: string[] | ((value: any, key: string | number | undefined) => string[]);
   requiredOneOf?: string[];
   allowed?: (value: any) => string[] | undefined;
   extensionsPrefix?: string;
 };
 
-type NormalizedPropType = NormalizedNodeType | NormalizedScalarSchema | undefined | null;
-type NormalizedResolveTypeFn = (
-  value: any,
-  key: string
-) => NormalizedNodeType | NormalizedScalarSchema | undefined | null;
+type NormalizedPropType = NormalizedNodeType | NormalizedScalarSchema | null | undefined;
+type NormalizedResolveTypeFn = (value: any, key: string) => NormalizedPropType;
 
 export function listOf(typeName: string) {
   return {
@@ -142,8 +139,6 @@ export function normalizeTypes(
   }
 }
 
-export function isNamedType(
-  t: NormalizedNodeType | NormalizedScalarSchema | null | undefined
-): t is NormalizedNodeType {
+export function isNamedType(t: NormalizedPropType): t is NormalizedNodeType {
   return typeof t?.name === 'string';
 }