@redocly/cli 1.22.1 → 1.23.1

package/src/utils/fetch-with-timeout.ts

@@ -1,24 +1,33 @@
-import nodeFetch from 'node-fetch';
+import nodeFetch, { type RequestInit } from 'node-fetch';
 import AbortController from 'abort-controller';
 import { getProxyAgent } from '@redocly/openapi-core';
 
-const TIMEOUT = 3000;
+export const DEFAULT_FETCH_TIMEOUT = 3000;
 
-export default async (url: string, options = {}) => {
-  try {
-    const controller = new AbortController();
-    const timeout = setTimeout(() => {
-      controller.abort();
-    }, TIMEOUT);
+export type FetchWithTimeoutOptions = RequestInit & {
+  timeout?: number;
+};
 
-    const res = await nodeFetch(url, {
-      signal: controller.signal,
+export default async (url: string, { timeout, ...options }: FetchWithTimeoutOptions = {}) => {
+  if (!timeout) {
+    return nodeFetch(url, {
       ...options,
       agent: getProxyAgent(),
     });
-    clearTimeout(timeout);
-    return res;
-  } catch (e) {
-    return;
   }
+
+  const controller = new AbortController();
+  const timeoutId = setTimeout(() => {
+    controller.abort();
+  }, timeout);
+
+  const res = await nodeFetch(url, {
+    signal: controller.signal,
+    ...options,
+    agent: getProxyAgent(),
+  });
+
+  clearTimeout(timeoutId);
+
+  return res;
 };

package/src/utils/miscellaneous.ts

@@ -16,13 +16,19 @@ import {
   loadConfig,
   RedoclyClient,
 } from '@redocly/openapi-core';
-import { isEmptyObject, isPlainObject, pluralize } from '@redocly/openapi-core/lib/utils';
+import {
+  isEmptyObject,
+  isNotEmptyArray,
+  isNotEmptyObject,
+  isPlainObject,
+  pluralize,
+} from '@redocly/openapi-core/lib/utils';
 import { ConfigValidationError } from '@redocly/openapi-core/lib/config';
 import { deprecatedRefDocsSchema } from '@redocly/config/lib/reference-docs-config-schema';
 import { outputExtensions } from '../types';
 import { version } from './update-version-notifier';
 import { DESTINATION_REGEX } from '../commands/push';
-import fetch from './fetch-with-timeout';
+import fetch, { DEFAULT_FETCH_TIMEOUT } from './fetch-with-timeout';
 
 import type { Arguments } from 'yargs';
 import type {
@@ -42,8 +48,7 @@ export async function getFallbackApisOrExit(
   config: ConfigApis
 ): Promise<Entrypoint[]> {
   const { apis } = config;
-  const shouldFallbackToAllDefinitions =
-    !isNotEmptyArray(argsApis) && apis && Object.keys(apis).length > 0;
+  const shouldFallbackToAllDefinitions = !isNotEmptyArray(argsApis) && isNotEmptyObject(apis);
   const res = shouldFallbackToAllDefinitions
     ? fallbackToAllDefinitions(apis, config)
     : await expandGlobsInEntrypoints(argsApis!, config);
@@ -64,10 +69,6 @@ function getConfigDirectory(config: ConfigApis) {
   return config.configFile ? dirname(config.configFile) : process.cwd();
 }
 
-function isNotEmptyArray<T>(args?: T[]): boolean {
-  return Array.isArray(args) && !!args.length;
-}
-
 function isApiPathValid(apiPath: string): string | void {
   if (!apiPath.trim()) {
     exitWithError('Path cannot be empty.');
@@ -80,15 +81,21 @@ function fallbackToAllDefinitions(
   apis: Record<string, ResolvedApi>,
   config: ConfigApis
 ): Entrypoint[] {
-  return Object.entries(apis).map(([alias, { root }]) => ({
+  return Object.entries(apis).map(([alias, { root, output }]) => ({
     path: isAbsoluteUrl(root) ? root : resolve(getConfigDirectory(config), root),
     alias,
+    output: output && resolve(getConfigDirectory(config), output),
   }));
 }
 
 function getAliasOrPath(config: ConfigApis, aliasOrPath: string): Entrypoint {
-  return config.apis[aliasOrPath]
-    ? { path: config.apis[aliasOrPath]?.root, alias: aliasOrPath }
+  const aliasApi = config.apis[aliasOrPath];
+  return aliasApi
+    ? {
+        path: aliasApi.root,
+        alias: aliasOrPath,
+        output: aliasApi.output,
+      }
     : {
         path: aliasOrPath,
         // find alias by path, take the first match
@@ -99,10 +106,10 @@ function getAliasOrPath(config: ConfigApis, aliasOrPath: string): Entrypoint {
       };
 }
 
-async function expandGlobsInEntrypoints(args: string[], config: ConfigApis) {
+async function expandGlobsInEntrypoints(argApis: string[], config: ConfigApis) {
   return (
     await Promise.all(
-      (args as string[]).map(async (aliasOrPath) => {
+      argApis.map(async (aliasOrPath) => {
         return glob.hasMagic(aliasOrPath) && !isAbsoluteUrl(aliasOrPath)
           ? (await promisify(glob)(aliasOrPath)).map((g: string) => getAliasOrPath(config, g))
           : getAliasOrPath(config, aliasOrPath);
@@ -356,29 +363,36 @@ export function printConfigLintTotals(totals: Totals, command?: string | number)
   }
 }
 
-export function getOutputFileName(
-  entrypoint: string,
-  entries: number,
-  output?: string,
-  ext?: BundleOutputFormat
-) {
-  if (!output) {
-    return { outputFile: 'stdout', ext: ext || 'yaml' };
+export function getOutputFileName({
+  entrypoint,
+  output,
+  argvOutput,
+  ext,
+  entries,
+}: {
+  entrypoint: string;
+  output?: string;
+  argvOutput?: string;
+  ext?: BundleOutputFormat;
+  entries: number;
+}) {
+  let outputFile = output || argvOutput;
+  if (!outputFile) {
+    return { ext: ext || 'yaml' };
   }
 
-  let outputFile = output;
-  if (entries > 1) {
+  if (entries > 1 && argvOutput) {
     ext = ext || (extname(entrypoint).substring(1) as BundleOutputFormat);
-    if (!outputExtensions.includes(ext as any)) {
+    if (!outputExtensions.includes(ext)) {
       throw new Error(`Invalid file extension: ${ext}.`);
     }
-    outputFile = join(output, basename(entrypoint, extname(entrypoint))) + '.' + ext;
+    outputFile = join(argvOutput, basename(entrypoint, extname(entrypoint))) + '.' + ext;
   } else {
-    if (output) {
-      ext = ext || (extname(output).substring(1) as BundleOutputFormat);
-    }
-    ext = ext || (extname(entrypoint).substring(1) as BundleOutputFormat);
-    if (!outputExtensions.includes(ext as any)) {
+    ext =
+      ext ||
+      (extname(outputFile).substring(1) as BundleOutputFormat) ||
+      (extname(entrypoint).substring(1) as BundleOutputFormat);
+    if (!outputExtensions.includes(ext)) {
       throw new Error(`Invalid file extension: ${ext}.`);
     }
     outputFile = join(dirname(outputFile), basename(outputFile, extname(outputFile))) + '.' + ext;
@@ -569,6 +583,7 @@ export async function sendTelemetry(
       spec_full_version,
     };
     await fetch(`https://api.redocly.com/registry/telemetry/cli`, {
+      timeout: DEFAULT_FETCH_TIMEOUT,
       method: 'POST',
       headers: {
         'content-type': 'application/json',

package/src/utils/update-version-notifier.ts

@@ -2,7 +2,7 @@ import { tmpdir } from 'os';
 import { join } from 'path';
 import { existsSync, writeFileSync, readFileSync, statSync } from 'fs';
 import { compare } from 'semver';
-import fetch from './fetch-with-timeout';
+import fetch, { DEFAULT_FETCH_TIMEOUT } from './fetch-with-timeout';
 import { cyan, green, yellow } from 'colorette';
 import { cleanColors } from './miscellaneous';
 
@@ -34,10 +34,16 @@ const isNewVersionAvailable = (current: string, latest: string) => compare(curre
 
 const getLatestVersion = async (packageName: string): Promise<string | undefined> => {
   const latestUrl = `http://registry.npmjs.org/${packageName}/latest`;
-  const response = await fetch(latestUrl);
-  if (!response) return;
-  const info = await response.json();
-  return info.version;
+
+  try {
+    const response = await fetch(latestUrl, { timeout: DEFAULT_FETCH_TIMEOUT });
+    const info = await response.json();
+
+    return info.version;
+  } catch {
+    // Do nothing
+    return;
+  }
 };
 
 export const cacheLatestVersion = () => {