@redocly/openapi-core 1.15.0 → 1.17.0

package/src/index.ts

@@ -4,6 +4,7 @@ export {
   slash,
   doesYamlFileExist,
   isTruthy,
+  getProxyAgent,
   pause,
 } from './utils';
 export { Oas3_1Types } from './types/oas3_1';
@@ -48,7 +49,9 @@ export {
   ResolvedApi,
 } from './config';
 
-export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
+export { RedoclyClient } from './redocly';
+
+export * from './redocly/domains';
 
 export {
   Source,

package/src/lint.ts

@@ -1,11 +1,11 @@
 import { BaseResolver, resolveDocument, makeDocumentFromString } from './resolve';
 import { normalizeVisitors } from './visitors';
 import { walkDocument } from './walk';
-import { StyleguideConfig, Config, initRules, defaultPlugin, resolvePlugins } from './config';
+import { StyleguideConfig, Config, initRules } from './config';
 import { normalizeTypes } from './types';
 import { releaseAjvInstance } from './rules/ajv';
 import { SpecVersion, getMajorSpecVersion, detectSpec, getTypes } from './oas-types';
-import { ConfigTypes } from './types/redocly-yaml';
+import { createConfigTypes } from './types/redocly-yaml';
 import { Spec } from './rules/common/spec';
 import { NoUnresolvedRefs } from './rules/no-unresolved-refs';
 
@@ -13,6 +13,7 @@ import type { Document, ResolvedRefMap } from './resolve';
 import type { ProblemSeverity, WalkContext } from './walk';
 import type { NodeType } from './types';
 import type { NestedVisitObject, Oas3Visitor, RuleInstanceConfig } from './visitors';
+import { rootRedoclyConfigSchema } from '@redocly/config';
 
 export async function lint(opts: {
   ref: string;
@@ -109,25 +110,25 @@ export async function lintDocument(opts: {
 
 export async function lintConfig(opts: {
   document: Document;
+  config: Config;
   resolvedRefMap?: ResolvedRefMap;
   severity?: ProblemSeverity;
   externalRefResolver?: BaseResolver;
   externalConfigTypes?: Record<string, NodeType>;
 }) {
-  const { document, severity, externalRefResolver = new BaseResolver() } = opts;
+  const { document, severity, externalRefResolver = new BaseResolver(), config } = opts;
 
   const ctx: WalkContext = {
     problems: [],
     oasVersion: SpecVersion.OAS3_0,
     visitorsData: {},
   };
-  const plugins = resolvePlugins([defaultPlugin]);
-  const config = new StyleguideConfig({
-    plugins,
-    rules: { spec: 'error' },
-  });
 
-  const types = normalizeTypes(opts.externalConfigTypes || ConfigTypes, config);
+  const types = normalizeTypes(
+    opts.externalConfigTypes || createConfigTypes(rootRedoclyConfigSchema, config),
+    { doNotResolveExamples: config.styleguide.doNotResolveExamples }
+  );
+
   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/types/oas3_1.ts

@@ -170,6 +170,7 @@ const Schema: NodeType = {
     format: { type: 'string' },
     contentEncoding: { type: 'string' },
     contentMediaType: { type: 'string' },
+    contentSchema: 'Schema',
     default: null,
     readOnly: { type: 'boolean' },
     writeOnly: { type: 'boolean' },

package/src/types/redocly-yaml.ts

@@ -5,6 +5,8 @@ import { getNodeTypesFromJSONSchema } from './json-schema-adapter';
 
 import type { NodeType } from '.';
 import type { JSONSchema } from 'json-schema-to-ts';
+import { SpecVersion, getTypes } from '../oas-types';
+import { Config } from '../config';
 
 const builtInCommonRules = [
   'spec',
@@ -222,8 +224,6 @@ const oas3_1NodeTypesList = [
 
 export type Oas3_1NodeType = typeof oas3_1NodeTypesList[number];
 
-const asyncNodeTypesList = ['Message'] as const;
-
 const ConfigStyleguide: NodeType = {
   properties: {
     extends: {
@@ -350,35 +350,28 @@ const Schema: NodeType = {
   additionalProperties: {},
 };
 
-const AssertionDefinitionSubject: NodeType = {
-  properties: {
-    type: {
-      enum: [
-        ...new Set([
-          'any',
-          ...oas2NodeTypesList,
-          ...oas3NodeTypesList,
-          ...oas3_1NodeTypesList,
-          ...asyncNodeTypesList,
-          'SpecExtension',
-        ]),
-      ],
-    },
-    property: (value: unknown) => {
-      if (Array.isArray(value)) {
-        return { type: 'array', items: { type: 'string' } };
-      } else if (value === null) {
-        return null;
-      } else {
-        return { type: 'string' };
-      }
+function createAssertionDefinitionSubject(nodeNames: string[]): NodeType {
+  return {
+    properties: {
+      type: {
+        enum: [...new Set(['any', ...nodeNames, 'SpecExtension'])],
+      },
+      property: (value: unknown) => {
+        if (Array.isArray(value)) {
+          return { type: 'array', items: { type: 'string' } };
+        } else if (value === null) {
+          return null;
+        } else {
+          return { type: 'string' };
+        }
+      },
+      filterInParentKeys: { type: 'array', items: { type: 'string' } },
+      filterOutParentKeys: { type: 'array', items: { type: 'string' } },
+      matchParentKeys: { type: 'string' },
     },
-    filterInParentKeys: { type: 'array', items: { type: 'string' } },
-    filterOutParentKeys: { type: 'array', items: { type: 'string' } },
-    matchParentKeys: { type: 'string' },
-  },
-  required: ['type'],
-};
+    required: ['type'],
+  };
+}
 
 const AssertionDefinitionAssertions: NodeType = {
   properties: {
@@ -1057,7 +1050,13 @@ const ConfigMockServer: NodeType = {
   },
 };
 
-export const createConfigTypes = (extraSchemas: JSONSchema) => {
+export function createConfigTypes(extraSchemas: JSONSchema, config?: Config) {
+  const nodeNames = Object.values(SpecVersion).flatMap((version) => {
+    const types = config?.styleguide
+      ? config.styleguide.extendTypes(getTypes(version), version)
+      : getTypes(version);
+    return Object.keys(types);
+  });
   // Create types based on external schemas
   const nodeTypes = getNodeTypesFromJSONSchema('rootRedoclyConfigSchema', extraSchemas);
 
@@ -1065,9 +1064,10 @@ export const createConfigTypes = (extraSchemas: JSONSchema) => {
     ...CoreConfigTypes,
     ConfigRoot: createConfigRoot(nodeTypes), // This is the REAL config root type
     ConfigApisProperties: createConfigApisProperties(nodeTypes),
+    AssertionDefinitionSubject: createAssertionDefinitionSubject(nodeNames),
     ...nodeTypes,
   };
-};
+}
 
 const CoreConfigTypes: Record<string, NodeType> = {
   Assert,
@@ -1130,7 +1130,6 @@ const CoreConfigTypes: Record<string, NodeType> = {
   Heading,
   Typography,
   AssertionDefinitionAssertions,
-  AssertionDefinitionSubject,
 };
 
 export const ConfigTypes: Record<string, NodeType> = createConfigTypes(rootRedoclyConfigSchema);

package/src/utils.ts

@@ -5,9 +5,10 @@ import fetch from 'node-fetch';
 import * as pluralize from 'pluralize';
 import { parseYaml } from './js-yaml';
 import { UserContext } from './walk';
-import { HttpResolveConfig } from './config';
 import { env } from './env';
 import { logger, colorize } from './logger';
+import { HttpResolveConfig } from './config';
+import { HttpsProxyAgent } from 'https-proxy-agent';
 
 export { parseYaml, stringifyYaml } from './js-yaml';
 
@@ -278,3 +279,8 @@ export async function pause(ms: number): Promise<void> {
 function getUpdatedFieldName(updatedField: string, updatedObject?: string) {
   return `${typeof updatedObject !== 'undefined' ? `${updatedObject}.` : ''}${updatedField}`;
 }
+
+export function getProxyAgent() {
+  const proxy = process.env.HTTPS_PROXY || process.env.HTTP_PROXY;
+  return proxy ? new HttpsProxyAgent(proxy) : undefined;
+}