@redocly/openapi-core 1.0.0-beta.105 → 1.0.0-beta.108

package/src/format/codeframes.ts

@@ -1,7 +1,7 @@
-import { gray, red, options as colorOptions } from 'colorette';
 import * as yamlAst from 'yaml-ast-parser';
 import { unescapePointer } from '../ref-utils';
 import { LineColLocationObject, Loc, LocationObject } from '../walk';
+import { colorize, colorOptions } from '../logger';
 
 type YAMLMapping = yamlAst.YAMLMapping & { kind: yamlAst.Kind.MAPPING };
 type YAMLMap = yamlAst.YamlMap & { kind: yamlAst.Kind.MAP };
@@ -36,17 +36,23 @@ export function getCodeframe(location: LineColLocationObject, color: boolean) {
     if (skipLines > 0 && i >= endLineNum - skipLines) break;
     const line = lines[i - 1] || '';
     if (line !== '') currentPad = padSize(line);
-    let startIdx = i === startLineNum ? start.col - 1 : currentPad;
-    let endIdx = i === endLineNum ? end.col - 1 : line.length;
+    const startIdx = i === startLineNum ? start.col - 1 : currentPad;
+    const endIdx = i === endLineNum ? end.col - 1 : line.length;
 
-    prefixedLines.push([`${i}`, markLine(line, startIdx, endIdx, red)]);
+    prefixedLines.push([`${i}`, markLine(line, startIdx, endIdx, colorize.red)]);
     if (!color) prefixedLines.push(['', underlineLine(line, startIdx, endIdx)]);
   }
 
   if (skipLines > 0) {
-    prefixedLines.push([`…`, `${whitespace(currentPad)}${gray(`< ${skipLines} more lines >`)}`]);
+    prefixedLines.push([
+      `…`,
+      `${whitespace(currentPad)}${colorize.gray(`< ${skipLines} more lines >`)}`,
+    ]);
     // print last line
-    prefixedLines.push([`${endLineNum}`, markLine(lines[endLineNum - 1], -1, end.col - 1, red)]);
+    prefixedLines.push([
+      `${endLineNum}`,
+      markLine(lines[endLineNum - 1], -1, end.col - 1, colorize.red),
+    ]);
 
     if (!color) prefixedLines.push(['', underlineLine(lines[endLineNum - 1], -1, end.col - 1)]);
   }
@@ -63,7 +69,7 @@ export function getCodeframe(location: LineColLocationObject, color: boolean) {
     line: string,
     startIdx: number = -1,
     endIdx: number = +Infinity,
-    variant = gray,
+    variant = colorize.gray
   ) {
     if (!color) return line;
     if (!line) return line;
@@ -84,14 +90,14 @@ function printPrefixedLines(lines: [string, string][]): string {
 
   const padLen = Math.max(...existingLines.map(([prefix]) => prefix.length));
   const dedentLen = Math.min(
-    ...existingLines.map(([_, line]) => (line === '' ? Infinity : padSize(line))),
+    ...existingLines.map(([_, line]) => (line === '' ? Infinity : padSize(line)))
   );
 
   return existingLines
     .map(
       ([prefix, line]) =>
-        gray(leftPad(padLen, prefix) + ' |') +
-        (line ? ' ' + limitLineLength(line.substring(dedentLen)) : ''),
+        colorize.gray(leftPad(padLen, prefix) + ' |') +
+        (line ? ' ' + limitLineLength(line.substring(dedentLen)) : '')
     )
     .join('\n');
 }
@@ -99,7 +105,7 @@ function printPrefixedLines(lines: [string, string][]): string {
 function limitLineLength(line: string, maxLen: number = MAX_LINE_LENGTH) {
   const overflowLen = line.length - maxLen;
   if (overflowLen > 0) {
-    const charsMoreText = gray(`...<${overflowLen} chars>`);
+    const charsMoreText = colorize.gray(`...<${overflowLen} chars>`);
     return line.substring(0, maxLen - charsMoreText.length) + charsMoreText;
   } else {
     return line;
@@ -146,7 +152,7 @@ export function getLineColLocation(location: LocationObject): LineColLocationObj
 function positionsToLoc(
   source: string,
   startPos: number,
-  endPos: number,
+  endPos: number
 ): { start: Loc; end: Loc } {
   let currentLine = 1;
   let currentCol = 1;

package/src/format/format.ts

@@ -1,20 +1,12 @@
 import * as path from 'path';
-import {
-  options as colorOptions,
-  gray,
-  blue,
-  bgRed,
-  bgYellow,
-  black,
-  yellow,
-  red,
-} from 'colorette';
+import { colorOptions, colorize, logger } from '../logger';
+import { output } from '../output';
 
 const coreVersion = require('../../package.json').version;
 
 import { NormalizedProblem, ProblemSeverity, LineColLocationObject, LocationObject } from '../walk';
 import { getCodeframe, getLineColLocation } from './codeframes';
-import { env } from "../config";
+import { env } from '../env';
 
 export type Totals = {
   errors: number;
@@ -27,13 +19,13 @@ const ERROR_MESSAGE = {
 };
 
 const BG_COLORS = {
-  warn: (str: string) => bgYellow(black(str)),
-  error: bgRed,
+  warn: (str: string) => colorize.bgYellow(colorize.black(str)),
+  error: colorize.bgRed,
 };
 
 const COLORS = {
-  warn: yellow,
-  error: red,
+  warn: colorize.yellow,
+  error: colorize.red,
 };
 
 const SEVERITY_NAMES = {
@@ -84,7 +76,7 @@ export function formatProblems(
     color?: boolean;
     totals: Totals;
     version: string;
-  },
+  }
 ) {
   const {
     maxProblems = 100,
@@ -114,38 +106,38 @@ export function formatProblems(
     case 'codeframe':
       for (let i = 0; i < problems.length; i++) {
         const problem = problems[i];
-        process.stderr.write(`${formatCodeframe(problem, i)}\n`);
+        logger.info(`${formatCodeframe(problem, i)}\n`);
       }
       break;
     case 'stylish': {
       const groupedByFile = groupByFiles(problems);
       for (const [file, { ruleIdPad, locationPad: positionPad, fileProblems }] of Object.entries(
-        groupedByFile,
+        groupedByFile
       )) {
-        process.stderr.write(`${blue(path.relative(cwd, file))}:\n`);
+        logger.info(`${colorize.blue(path.relative(cwd, file))}:\n`);
 
         for (let i = 0; i < fileProblems.length; i++) {
           const problem = fileProblems[i];
-          process.stderr.write(`${formatStylish(problem, positionPad, ruleIdPad)}\n`);
+          logger.info(`${formatStylish(problem, positionPad, ruleIdPad)}\n`);
         }
 
-        process.stderr.write('\n');
+        logger.info('\n');
       }
       break;
     }
     case 'checkstyle': {
       const groupedByFile = groupByFiles(problems);
 
-      process.stdout.write('<?xml version="1.0" encoding="UTF-8"?>\n');
-      process.stdout.write('<checkstyle version="4.3">\n');
+      output.write('<?xml version="1.0" encoding="UTF-8"?>\n');
+      output.write('<checkstyle version="4.3">\n');
 
       for (const [file, { fileProblems }] of Object.entries(groupedByFile)) {
-        process.stdout.write(`<file name="${xmlEscape(path.relative(cwd, file))}">\n`);
+        output.write(`<file name="${xmlEscape(path.relative(cwd, file))}">\n`);
         fileProblems.forEach(formatCheckstyle);
-        process.stdout.write(`</file>\n`);
+        output.write(`</file>\n`);
       }
 
-      process.stdout.write(`</checkstyle>\n`);
+      output.write(`</checkstyle>\n`);
       break;
     }
     case 'codeclimate':
@@ -154,10 +146,10 @@ export function formatProblems(
   }
 
   if (totalProblems - ignoredProblems > maxProblems) {
-    process.stderr.write(
-      `< ... ${totalProblems - maxProblems} more problems hidden > ${gray(
-        'increase with `--max-problems N`',
-      )}\n`,
+    logger.info(
+      `< ... ${totalProblems - maxProblems} more problems hidden > ${colorize.gray(
+        'increase with `--max-problems N`'
+      )}\n`
     );
   }
 
@@ -177,7 +169,7 @@ export function formatProblems(
         fingerprint: `${p.ruleId}${p.location.length > 0 ? '-' + p.location[0].pointer : ''}`,
       };
     });
-    process.stdout.write(JSON.stringify(issues, null, 2));
+    output.write(JSON.stringify(issues, null, 2));
   }
 
   function outputJSON() {
@@ -185,7 +177,7 @@ export function formatProblems(
       totals,
       version,
       problems: problems.map((p) => {
-        let problem = {
+        const problem = {
           ...p,
           location: p.location.map((location: any) => ({
             ...location,
@@ -211,7 +203,7 @@ export function formatProblems(
         return problem;
       }),
     };
-    process.stdout.write(JSON.stringify(resultObject, null, 2));
+    output.write(JSON.stringify(resultObject, null, 2));
   }
 
   function getBgColor(problem: NormalizedProblem) {
@@ -227,7 +219,7 @@ export function formatProblems(
     const location = problem.location[0]; // TODO: support multiple locations
     const relativePath = path.relative(cwd, location.source.absoluteRef);
     const loc = getLineColLocation(location);
-    const atPointer = location.pointer ? gray(`at ${location.pointer}`) : '';
+    const atPointer = location.pointer ? colorize.gray(`at ${location.pointer}`) : '';
     const fileWithLoc = `${relativePath}:${loc.start.line}:${loc.start.col}`;
     return (
       `[${idx + 1}] ${bgColor(fileWithLoc)} ${atPointer}\n\n` +
@@ -236,19 +228,21 @@ export function formatProblems(
       getCodeframe(loc, color) +
       '\n\n' +
       formatFrom(cwd, problem.from) +
-      `${SEVERITY_NAMES[problem.severity]} was generated by the ${blue(problem.ruleId)} rule.\n\n`
+      `${SEVERITY_NAMES[problem.severity]} was generated by the ${colorize.blue(
+        problem.ruleId
+      )} rule.\n\n`
     );
   }
 
   function formatStylish(problem: OnlyLineColProblem, locationPad: number, ruleIdPad: number) {
     const color = COLORS[problem.severity];
     if (!SEVERITY_NAMES[problem.severity]) {
-      return 'Error not found severity. Please check your config file. Allowed values: \`warn,error,off\`'
+      return 'Error not found severity. Please check your config file. Allowed values: `warn,error,off`';
     }
     const severityName = color(SEVERITY_NAMES[problem.severity].toLowerCase().padEnd(7));
     const { start } = problem.location[0];
     return `  ${`${start.line}:${start.col}`.padEnd(
-      locationPad,
+      locationPad
     )}  ${severityName}  ${problem.ruleId.padEnd(ruleIdPad)}  ${problem.message}`;
   }
 
@@ -257,8 +251,8 @@ export function formatProblems(
     const severity = problem.severity == 'warn' ? 'warning' : 'error';
     const message = xmlEscape(problem.message);
     const source = xmlEscape(problem.ruleId);
-    process.stdout.write(
-      `<error line="${line}" column="${col}" severity="${severity}" message="${message}" source="${source}" />\n`,
+    output.write(
+      `<error line="${line}" column="${col}" severity="${severity}" message="${message}" source="${source}" />\n`
     );
   }
 }
@@ -269,7 +263,7 @@ function formatFrom(cwd: string, location?: LocationObject) {
   const loc = getLineColLocation(location);
   const fileWithLoc = `${relativePath}:${loc.start.line}:${loc.start.col}`;
 
-  return `referenced from ${blue(fileWithLoc)}\n\n`;
+  return `referenced from ${colorize.blue(fileWithLoc)}\n\n`;
 }
 
 function formatDidYouMean(problem: NormalizedProblem) {
@@ -307,12 +301,12 @@ const groupByFiles = (problems: NormalizedProblem[]) => {
     fileGroups[absoluteRef].fileProblems.push(mappedProblem);
     fileGroups[absoluteRef].ruleIdPad = Math.max(
       problem.ruleId.length,
-      fileGroups[absoluteRef].ruleIdPad,
+      fileGroups[absoluteRef].ruleIdPad
     );
 
     fileGroups[absoluteRef].locationPad = Math.max(
       Math.max(...mappedProblem.location.map((loc) => `${loc.start.line}:${loc.start.col}`.length)),
-      fileGroups[absoluteRef].locationPad,
+      fileGroups[absoluteRef].locationPad
     );
   }
 
@@ -320,6 +314,7 @@ const groupByFiles = (problems: NormalizedProblem[]) => {
 };
 
 function xmlEscape(s: string): string {
+  // eslint-disable-next-line no-control-regex
   return s.replace(/[<>&"'\x00-\x1F\x7F\u0080-\uFFFF]/gu, (char) => {
     switch (char) {
       case '<':

package/src/index.ts

@@ -1,9 +1,9 @@
-export { BundleOutputFormat, readFileFromUrl, slash, doesYamlFileExist } from './utils';
+export { BundleOutputFormat, readFileFromUrl, slash, doesYamlFileExist, isTruthy } from './utils';
 export { Oas3_1Types } from './types/oas3_1';
 export { Oas3Types } from './types/oas3';
 export { Oas2Types } from './types/oas2';
 export { ConfigTypes } from './types/redocly-yaml';
-export {
+export type {
   Oas3Definition,
   Oas3_1Definition,
   Oas3Components,
@@ -15,15 +15,16 @@ export {
   Oas3Tag,
   Oas3_1Webhooks,
   Referenced,
+  OasRef,
 } from './typings/openapi';
-export { Oas2Definition } from './typings/swagger';
-export { StatsAccumulator, StatsName } from './typings/common';
+export type { Oas2Definition } from './typings/swagger';
+export type { StatsAccumulator, StatsName } from './typings/common';
 export { normalizeTypes } from './types';
 export { Stats } from './rules/other/stats';
 
 export {
   Config,
-  LintConfig,
+  StyleguideConfig,
   RawConfig,
   IGNORE_FILE,
   Region,
@@ -33,10 +34,10 @@ export {
   getConfig,
   findConfig,
   CONFIG_FILE_NAMES,
-  RuleSeverity
+  RuleSeverity,
+  createConfig,
 } from './config';
 
-
 export { RedoclyClient, isRedoclyRegistryURL } from './redocly';
 
 export {

package/src/js-yaml/index.ts

@@ -1,18 +1,14 @@
 // TODO: add a type for "types" https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/js-yaml/index.d.ts
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
-import { JSON_SCHEMA, types, LoadOptions, DumpOptions, load, dump  } from 'js-yaml';
+import { JSON_SCHEMA, types, LoadOptions, DumpOptions, load, dump } from 'js-yaml';
 
 const DEFAULT_SCHEMA_WITHOUT_TIMESTAMP = JSON_SCHEMA.extend({
   implicit: [types.merge],
-  explicit: [
-    types.binary,
-    types.omap,
-    types.pairs,
-    types.set,
-  ],
+  explicit: [types.binary, types.omap, types.pairs, types.set],
 });
 
 export const parseYaml = (str: string, opts?: LoadOptions): unknown =>
-  load(str, {schema: DEFAULT_SCHEMA_WITHOUT_TIMESTAMP, ...opts});
+  load(str, { schema: DEFAULT_SCHEMA_WITHOUT_TIMESTAMP, ...opts });
 
 export const stringifyYaml = (obj: any, opts?: DumpOptions): string => dump(obj, opts);

package/src/lint.ts

@@ -1,20 +1,17 @@
 import { BaseResolver, resolveDocument, Document, makeDocumentFromString } from './resolve';
-import {
-  normalizeVisitors,
-} from './visitors';
+import { normalizeVisitors } from './visitors';
 import { Oas3_1Types } from './types/oas3_1';
 import { Oas3Types } from './types/oas3';
 import { Oas2Types } from './types/oas2';
 import { NodeType } from './types';
 import { ProblemSeverity, WalkContext, walkDocument } from './walk';
-import { LintConfig, Config, initRules, defaultPlugin, resolvePlugins } from './config';
+import { StyleguideConfig, Config, initRules, defaultPlugin, resolvePlugins } from './config';
 import { normalizeTypes } from './types';
 import { releaseAjvInstance } from './rules/ajv';
 import { detectOpenAPI, Oas3RuleSet, OasMajorVersion, OasVersion, openAPIMajor } from './oas-types';
 import { ConfigTypes } from './types/redocly-yaml';
 import { OasSpec } from './rules/common/spec';
 
-
 export async function lint(opts: {
   ref: string;
   config: Config;
@@ -27,7 +24,7 @@ export async function lint(opts: {
     document,
     ...opts,
     externalRefResolver,
-    config: opts.config.lint,
+    config: opts.config.styleguide,
   });
 }
 
@@ -44,13 +41,13 @@ export async function lintFromString(opts: {
     document,
     ...opts,
     externalRefResolver,
-    config: opts.config.lint,
+    config: opts.config.styleguide,
   });
 }
 
 export async function lintDocument(opts: {
   document: Document;
-  config: LintConfig;
+  config: StyleguideConfig;
   customTypes?: Record<string, NodeType>;
   externalRefResolver: BaseResolver;
 }) {
@@ -62,10 +59,14 @@ export async function lintDocument(opts: {
   const rules = config.getRulesForOasVersion(oasMajorVersion);
   const types = normalizeTypes(
     config.extendTypes(
-      customTypes ?? oasMajorVersion === OasMajorVersion.Version3 ? (oasVersion === OasVersion.Version3_1 ? Oas3_1Types : Oas3Types) : Oas2Types,
-      oasVersion,
+      customTypes ?? oasMajorVersion === OasMajorVersion.Version3
+        ? oasVersion === OasVersion.Version3_1
+          ? Oas3_1Types
+          : Oas3Types
+        : Oas2Types,
+      oasVersion
     ),
-    config,
+    config
   );
 
   const ctx: WalkContext = {
@@ -80,7 +81,7 @@ export async function lintDocument(opts: {
   const resolvedRefMap = await resolveDocument({
     rootDocument: document,
     rootType: types.DefinitionRoot,
-    externalRefResolver
+    externalRefResolver,
   });
 
   walkDocument({
@@ -93,10 +94,7 @@ export async function lintDocument(opts: {
   return ctx.problems.map((problem) => config.addProblemToIgnore(problem));
 }
 
-export async function lintConfig(opts: {
-  document: Document
-  severity?: ProblemSeverity 
-}) {
+export async function lintConfig(opts: { document: Document; severity?: ProblemSeverity }) {
   const { document, severity } = opts;
 
   const ctx: WalkContext = {
@@ -105,13 +103,19 @@ export async function lintConfig(opts: {
     visitorsData: {},
   };
   const plugins = resolvePlugins([defaultPlugin]);
-  const config = new LintConfig({
+  const config = new StyleguideConfig({
     plugins,
     rules: { spec: 'error' },
   });
 
   const types = normalizeTypes(ConfigTypes, config);
-  const rules = [{ severity: severity || 'error', ruleId: 'configuration spec', visitor: OasSpec({ severity: 'error' }) }];
+  const rules = [
+    {
+      severity: severity || 'error',
+      ruleId: 'configuration spec',
+      visitor: OasSpec({ severity: 'error' }),
+    },
+  ];
   const normalizedVisitors = normalizeVisitors(rules, types);
 
   walkDocument({

package/src/logger.ts

@@ -0,0 +1,34 @@
+import * as colorette from 'colorette';
+export { options as colorOptions } from 'colorette';
+
+import { isBrowser } from './env';
+import { identity } from './utils';
+
+export const colorize = new Proxy(colorette, {
+  get(target: typeof colorette, prop: string): typeof identity {
+    if (isBrowser) {
+      return identity;
+    }
+
+    return (target as any)[prop];
+  },
+});
+class Logger {
+  protected stderr(str: string) {
+    return process.stderr.write(str);
+  }
+
+  info(str: string) {
+    return isBrowser ? console.log(str) : this.stderr(str);
+  }
+
+  warn(str: string) {
+    return isBrowser ? console.warn(str) : this.stderr(colorize.yellow(str));
+  }
+
+  error(str: string) {
+    return isBrowser ? console.error(str) : this.stderr(colorize.red(str));
+  }
+}
+
+export const logger = new Logger();

package/src/oas-types.ts

@@ -1,9 +1,4 @@
-import {
-  Oas3Rule,
-  Oas3Preprocessor,
-  Oas2Rule,
-  Oas2Preprocessor,
-} from './visitors';
+import { Oas3Rule, Oas3Preprocessor, Oas2Rule, Oas2Preprocessor } from './visitors';
 
 export type RuleSet<T> = Record<string, T>;
 

package/src/output.ts

@@ -0,0 +1,7 @@
+import { isBrowser } from './env';
+
+export const output = {
+  write(str: string) {
+    return isBrowser ? undefined : process.stdout.write(str);
+  },
+};

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

@@ -59,55 +59,57 @@ describe('RedoclyClient', () => {
 
   it('should resolve all tokens', async () => {
     let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => {
-      return { token: "accessToken", us: "accessToken", eu: "eu-accessToken" };
+      return { token: 'accessToken', us: 'accessToken', eu: 'eu-accessToken' };
     });
     const client = new RedoclyClient();
     const tokens = client.getAllTokens();
     expect(tokens).toStrictEqual([
       { region: 'us', token: 'accessToken' },
-      { region: 'eu', token: 'eu-accessToken' }
+      { region: 'eu', token: 'eu-accessToken' },
     ]);
     spy.mockRestore();
   });
 
   it('should resolve valid tokens data', async () => {
     let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => {
-      return { us: "accessToken", eu: "eu-accessToken" }
+      return { us: 'accessToken', eu: 'eu-accessToken' };
     });
     const client = new RedoclyClient();
     const tokens = await client.getValidTokens();
     expect(tokens).toStrictEqual([
       { region: 'us', token: 'accessToken', valid: true },
-      { region: 'eu', token: 'eu-accessToken', valid: true }
+      { region: 'eu', token: 'eu-accessToken', valid: true },
     ]);
     spy.mockRestore();
   });
 
   it('should not call setAccessTokens by default', () => {
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({}));
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({}));
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient();
-    expect(client.setAccessTokens).not.toHaveBeenCalled()
+    expect(client.setAccessTokens).not.toHaveBeenCalled();
     spy.mockRestore();
   });
 
   it('should set correct accessTokens - backward compatibility: default US region', () => {
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ token: testToken }));
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ token: testToken }));
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient();
-    expect(client.setAccessTokens).toBeCalledWith(
-      expect.objectContaining({ us: testToken })
-    );
+    expect(client.setAccessTokens).toBeCalledWith(expect.objectContaining({ us: testToken }));
     spy.mockRestore();
   });
 
   it('should set correct accessTokens - backward compatibility: EU region', () => {
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ token: testToken }));
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ token: testToken }));
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient('eu');
-    expect(client.setAccessTokens).toBeCalledWith(
-      expect.objectContaining({ eu: testToken })
-    );
+    expect(client.setAccessTokens).toBeCalledWith(expect.objectContaining({ eu: testToken }));
     spy.mockRestore();
   });
 
@@ -116,25 +118,29 @@ describe('RedoclyClient', () => {
     let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation();
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient();
-    expect(client.setAccessTokens).toHaveBeenNthCalledWith(1, { "us": REDOCLY_AUTHORIZATION_TOKEN });
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(1, { us: REDOCLY_AUTHORIZATION_TOKEN });
     spy.mockRestore();
   });
 
   it('should set correct accessTokens prioritizing REDOCLY_AUTHORIZATION env over token in file', () => {
     process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ token: testToken }));
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ token: testToken }));
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient();
-    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { "us": REDOCLY_AUTHORIZATION_TOKEN });
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { us: REDOCLY_AUTHORIZATION_TOKEN });
     spy.mockRestore();
   });
 
   it('should set correct accessTokens prioritizing REDOCLY_AUTHORIZATION env over EU token', () => {
     process.env.REDOCLY_AUTHORIZATION = REDOCLY_AUTHORIZATION_TOKEN;
-    let spy = jest.spyOn(RedoclyClient.prototype, 'readCredentialsFile').mockImplementation(() => ({ us: testToken }));
+    let spy = jest
+      .spyOn(RedoclyClient.prototype, 'readCredentialsFile')
+      .mockImplementation(() => ({ us: testToken }));
     jest.spyOn(RedoclyClient.prototype, 'setAccessTokens').mockImplementation();
     const client = new RedoclyClient('eu');
-    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { "eu": REDOCLY_AUTHORIZATION_TOKEN });
+    expect(client.setAccessTokens).toHaveBeenNthCalledWith(2, { eu: REDOCLY_AUTHORIZATION_TOKEN });
     spy.mockRestore();
   });
 });