@redocly/cli 1.27.1 → 1.28.0

package/src/__tests__/commands/push.test.ts

@@ -4,26 +4,66 @@ import { exitWithError } from '../../utils/miscellaneous';
 import { getApiRoot, getDestinationProps, handlePush, transformPush } from '../../commands/push';
 import { ConfigFixture } from '../fixtures/config';
 import { yellow } from 'colorette';
-
-jest.mock('fs');
-jest.mock('node-fetch', () => ({
-  default: jest.fn(() => ({
-    ok: true,
-    json: jest.fn().mockResolvedValue({}),
-  })),
+import { Readable } from 'node:stream';
+
+// Mock fs operations
+jest.mock('fs', () => ({
+  ...jest.requireActual('fs'),
+  createReadStream: jest.fn(() => {
+    const readable = new Readable();
+    readable.push('test data');
+    readable.push(null);
+    return readable;
+  }),
+  statSync: jest.fn(() => ({ isDirectory: () => false, size: 10 })),
+  readFileSync: jest.fn(() => Buffer.from('test data')),
+  existsSync: jest.fn(() => false),
+  readdirSync: jest.fn(() => []),
 }));
+
 jest.mock('@redocly/openapi-core');
 jest.mock('../../utils/miscellaneous');
 
+// Mock fetch
+const mockFetch = jest.fn(() =>
+  Promise.resolve({
+    ok: true,
+    status: 200,
+    json: () => Promise.resolve({}),
+    headers: new Headers(),
+    statusText: 'OK',
+    redirected: false,
+    type: 'default',
+    url: '',
+    clone: () => ({} as Response),
+    body: null,
+    bodyUsed: false,
+    arrayBuffer: async () => new ArrayBuffer(0),
+    blob: async () => new Blob(),
+    formData: async () => new FormData(),
+    text: async () => '',
+  } as Response)
+);
+
+const originalFetch = global.fetch;
+
 (getMergedConfig as jest.Mock).mockImplementation((config) => config);
 
 describe('push', () => {
   const redoclyClient = require('@redocly/openapi-core').__redoclyClient;
 
+  beforeAll(() => {
+    global.fetch = mockFetch;
+  });
+
   beforeEach(() => {
     jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
   });
 
+  afterAll(() => {
+    global.fetch = originalFetch;
+  });
+
   it('pushes definition', async () => {
     await handlePush({
       argv: {

package/src/__tests__/fetch-with-timeout.test.ts

@@ -1,12 +1,37 @@
 import AbortController from 'abort-controller';
 import fetchWithTimeout from '../utils/fetch-with-timeout';
-import nodeFetch from 'node-fetch';
 import { getProxyAgent } from '@redocly/openapi-core';
 import { HttpsProxyAgent } from 'https-proxy-agent';
 
-jest.mock('node-fetch');
 jest.mock('@redocly/openapi-core');
 
+const signalInstance = new AbortController().signal;
+
+const mockFetch = jest.fn(() =>
+  Promise.resolve({
+    ok: true,
+    status: 200,
+    json: () => Promise.resolve({}),
+    headers: new Headers(),
+    statusText: 'OK',
+    redirected: false,
+    type: 'default',
+    url: '',
+    clone: () => ({} as Response),
+    body: null,
+    bodyUsed: false,
+    arrayBuffer: async () => new ArrayBuffer(0),
+    blob: async () => new Blob(),
+    formData: async () => new FormData(),
+    text: async () => '',
+    signal: signalInstance,
+    dispatcher: undefined,
+  } as Response)
+);
+
+const originalFetch = global.fetch;
+global.fetch = mockFetch;
+
 describe('fetchWithTimeout', () => {
   beforeAll(() => {
     // @ts-ignore
@@ -18,36 +43,39 @@ describe('fetchWithTimeout', () => {
     (getProxyAgent as jest.Mock).mockReturnValueOnce(undefined);
   });
 
-  afterEach(() => {
-    jest.clearAllMocks();
+  afterAll(() => {
+    global.fetch = originalFetch;
   });
 
-  it('should call node-fetch with signal', async () => {
+  it('should call fetch with signal', async () => {
     await fetchWithTimeout('url', { timeout: 1000 });
 
     expect(global.setTimeout).toHaveBeenCalledTimes(1);
-    expect(nodeFetch).toHaveBeenCalledWith('url', {
-      signal: new AbortController().signal,
-      agent: undefined,
-    });
+    expect(global.fetch).toHaveBeenCalledWith(
+      'url',
+      expect.objectContaining({
+        signal: expect.any(AbortSignal),
+        dispatcher: undefined,
+      })
+    );
     expect(global.clearTimeout).toHaveBeenCalledTimes(1);
   });
 
-  it('should call node-fetch with proxy agent', async () => {
+  it('should call fetch with proxy agent', async () => {
     (getProxyAgent as jest.Mock).mockRestore();
     const proxyAgent = new HttpsProxyAgent('http://localhost');
     (getProxyAgent as jest.Mock).mockReturnValueOnce(proxyAgent);
 
     await fetchWithTimeout('url');
 
-    expect(nodeFetch).toHaveBeenCalledWith('url', { agent: proxyAgent });
+    expect(global.fetch).toHaveBeenCalledWith('url', { dispatcher: proxyAgent });
   });
 
-  it('should call node-fetch without signal when timeout is not passed', async () => {
+  it('should call fetch without signal when timeout is not passed', async () => {
     await fetchWithTimeout('url');
 
     expect(global.setTimeout).not.toHaveBeenCalled();
-    expect(nodeFetch).toHaveBeenCalledWith('url', { agent: undefined });
+    expect(global.fetch).toHaveBeenCalledWith('url', { agent: undefined });
     expect(global.clearTimeout).not.toHaveBeenCalled();
   });
 });

package/src/__tests__/wrapper.test.ts

@@ -6,11 +6,23 @@ import { Arguments } from 'yargs';
 import { handlePush, PushOptions } from '../commands/push';
 import { detectSpec } from '@redocly/openapi-core';
 
-jest.mock('node-fetch');
+const mockFetch = jest.fn();
+const originalFetch = global.fetch;
+
 jest.mock('../utils/miscellaneous', () => ({
   sendTelemetry: jest.fn(),
   loadConfigAndHandleErrors: jest.fn(),
 }));
+
+beforeAll(() => {
+  global.fetch = mockFetch;
+});
+
+afterAll(() => {
+  jest.resetAllMocks();
+  global.fetch = originalFetch;
+});
+
 jest.mock('../commands/lint', () => ({
   handleLint: jest.fn().mockImplementation(({ collectSpecData }) => {
     collectSpecData({ openapi: '3.1.0' });

package/src/cms/api/__tests__/api.client.test.ts

@@ -1,15 +1,21 @@
-import fetch, { Response } from 'node-fetch';
-import * as FormData from 'form-data';
 import { red, yellow } from 'colorette';
 
 import { ReuniteApi, PushPayload, ReuniteApiError } from '../api-client';
 
-jest.mock('node-fetch', () => ({
-  default: jest.fn(),
-}));
+const originalFetch = global.fetch;
+
+beforeAll(() => {
+  // Reset fetch mock before each test
+  global.fetch = jest.fn();
+});
+
+afterAll(() => {
+  // Restore original fetch after each test
+  global.fetch = originalFetch;
+});
 
 function mockFetchResponse(response: any) {
-  (fetch as jest.MockedFunction<typeof fetch>).mockResolvedValue(response as unknown as Response);
+  (global.fetch as jest.Mock).mockResolvedValue(response);
 }
 
 describe('ApiClient', () => {
@@ -38,7 +44,7 @@ describe('ApiClient', () => {
 
       const result = await apiClient.remotes.getDefaultBranch(testOrg, testProject);
 
-      expect(fetch).toHaveBeenCalledWith(
+      expect(global.fetch).toHaveBeenCalledWith(
         `${testDomain}/api/orgs/${testOrg}/projects/${testProject}/source`,
         {
           method: 'GET',
@@ -115,7 +121,7 @@ describe('ApiClient', () => {
 
       const result = await apiClient.remotes.upsert(testOrg, testProject, remotePayload);
 
-      expect(fetch).toHaveBeenCalledWith(
+      expect(global.fetch).toHaveBeenCalledWith(
         `${testDomain}/api/orgs/${testOrg}/projects/${testProject}/remotes`,
         {
           method: 'POST',
@@ -213,12 +219,11 @@ describe('ApiClient', () => {
     });
 
     it('should push to remote', async () => {
-      let passedFormData = new FormData();
+      let passedFormData: FormData = new FormData();
 
       (fetch as jest.MockedFunction<typeof fetch>).mockImplementationOnce(
         async (_: any, options: any): Promise<Response> => {
           passedFormData = options.body as FormData;
-
           return {
             ok: true,
             json: jest.fn().mockResolvedValue(responseMock),
@@ -226,14 +231,14 @@ describe('ApiClient', () => {
         }
       );
 
-      const formData = new FormData();
+      const formData = new globalThis.FormData();
 
       formData.append('remoteId', testRemoteId);
       formData.append('commit[message]', pushPayload.commit.message);
       formData.append('commit[author][name]', pushPayload.commit.author.name);
       formData.append('commit[author][email]', pushPayload.commit.author.email);
       formData.append('commit[branchName]', pushPayload.commit.branchName);
-      formData.append('files[some-file.yaml]', filesMock[0].stream);
+      formData.append('files[some-file.yaml]', new Blob([filesMock[0].stream]));
 
       const result = await apiClient.remotes.push(testOrg, testProject, pushPayload, filesMock);
 
@@ -247,10 +252,7 @@ describe('ApiClient', () => {
           },
         })
       );
-
-      expect(
-        JSON.stringify(passedFormData).replace(new RegExp(passedFormData.getBoundary(), 'g'), '')
-      ).toEqual(JSON.stringify(formData).replace(new RegExp(formData.getBoundary(), 'g'), ''));
+      expect(passedFormData).toEqual(formData);
       expect(result).toEqual(responseMock);
     });
 

package/src/cms/api/api-client.ts

@@ -1,12 +1,11 @@
 import { yellow, red } from 'colorette';
-import * as FormData from 'form-data';
 import fetchWithTimeout, {
   type FetchWithTimeoutOptions,
   DEFAULT_FETCH_TIMEOUT,
 } from '../../utils/fetch-with-timeout';
 
-import type { Response } from 'node-fetch';
 import type { ReadStream } from 'fs';
+import type { Readable } from 'node:stream';
 import type {
   ListRemotesResponse,
   ProjectSourceResponse,
@@ -178,7 +177,7 @@ class RemotesApi {
     payload: PushPayload,
     files: { path: string; stream: ReadStream | Buffer }[]
   ): Promise<PushResponse> {
-    const formData = new FormData();
+    const formData = new globalThis.FormData();
 
     formData.append('remoteId', payload.remoteId);
     formData.append('commit[message]', payload.commit.message);
@@ -192,7 +191,10 @@ class RemotesApi {
     payload.commit.createdAt && formData.append('commit[createdAt]', payload.commit.createdAt);
 
     for (const file of files) {
-      formData.append(`files[${file.path}]`, file.stream);
+      const blob = Buffer.isBuffer(file.stream)
+        ? new Blob([file.stream])
+        : new Blob([await streamToBuffer(file.stream)]);
+      formData.append(`files[${file.path}]`, blob, file.path);
     }
 
     payload.isMainBranch && formData.append('isMainBranch', 'true');
@@ -369,3 +371,11 @@ export type PushPayload = {
   };
   isMainBranch?: boolean;
 };
+
+export async function streamToBuffer(stream: ReadStream | Readable): Promise<Buffer> {
+  const chunks: Buffer[] = [];
+  for await (const chunk of stream) {
+    chunks.push(chunk);
+  }
+  return Buffer.concat(chunks);
+}

package/src/commands/join.ts

@@ -23,14 +23,17 @@ import { isObject, isString, keysOf } from '../utils/js-utils';
 import { COMPONENTS, OPENAPI3_METHOD } from './split/types';
 import { crawl, startsWithComponents } from './split';
 
-import type { Oas3Definition, Document, Oas3Tag, Referenced } from '@redocly/openapi-core';
+import type { Document, Referenced } from '@redocly/openapi-core';
 import type { BundleResult } from '@redocly/openapi-core/lib/bundle';
 import type {
+  Oas3Definition,
+  Oas3_1Definition,
   Oas3Parameter,
   Oas3PathItem,
   Oas3Server,
-  Oas3_1Definition,
+  Oas3Tag,
 } from '@redocly/openapi-core/lib/typings/openapi';
+import type { StrictObject } from '@redocly/openapi-core/lib/utils';
 import type { CommandArgs } from '../wrapper';
 import type { VerifyConfigOptions } from '../types';
 
@@ -311,7 +314,7 @@ export async function handleJoin({
     }
   }
 
-  function collectServers(openapi: Oas3Definition) {
+  function collectServers(openapi: Oas3Definition | Oas3_1Definition) {
     const { servers } = openapi;
     if (servers) {
       if (!joinedDef.hasOwnProperty('servers')) {
@@ -325,7 +328,10 @@ export async function handleJoin({
     }
   }
 
-  function collectExternalDocs(openapi: Oas3Definition, { api }: JoinDocumentContext) {
+  function collectExternalDocs(
+    openapi: Oas3Definition | Oas3_1Definition,
+    { api }: JoinDocumentContext
+  ) {
     const { externalDocs } = openapi;
     if (externalDocs) {
       if (joinedDef.hasOwnProperty('externalDocs')) {
@@ -339,7 +345,7 @@ export async function handleJoin({
   }
 
   function collectPaths(
-    openapi: Oas3Definition,
+    openapi: Oas3Definition | Oas3_1Definition,
     {
       apiFilename,
       apiTitle,
@@ -567,7 +573,7 @@ export async function handleJoin({
 
   function collectWebhooks(
     oasVersion: SpecVersion,
-    openapi: Oas3_1Definition,
+    openapi: StrictObject<Oas3Definition | Oas3_1Definition>,
     {
       apiFilename,
       apiTitle,

package/src/commands/push.ts

@@ -1,6 +1,5 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import fetch from 'node-fetch';
 import { performance } from 'perf_hooks';
 import { yellow, green, blue, red } from 'colorette';
 import { createHash } from 'crypto';
@@ -22,7 +21,10 @@ import {
 } from '../utils/miscellaneous';
 import { promptClientToken } from './login';
 import { handlePush as handleCMSPush } from '../cms/commands/push';
+import { streamToBuffer } from '../cms/api/api-client';
 
+import type { Readable } from 'node:stream';
+import type { Agent } from 'node:http';
 import type { Config, BundleOutputFormat, Region } from '@redocly/openapi-core';
 import type { CommandArgs } from '../wrapper';
 import type { VerifyConfigOptions } from '../types';
@@ -436,7 +438,7 @@ export function getApiRoot({
   return api?.root;
 }
 
-function uploadFileToS3(url: string, filePathOrBuffer: string | Buffer) {
+async function uploadFileToS3(url: string, filePathOrBuffer: string | Buffer) {
   const fileSizeInBytes =
     typeof filePathOrBuffer === 'string'
       ? fs.statSync(filePathOrBuffer).size
@@ -445,12 +447,24 @@ function uploadFileToS3(url: string, filePathOrBuffer: string | Buffer) {
   const readStream =
     typeof filePathOrBuffer === 'string' ? fs.createReadStream(filePathOrBuffer) : filePathOrBuffer;
 
-  return fetch(url, {
+  type NodeFetchRequestInit = RequestInit & {
+    dispatcher?: Agent;
+  };
+
+  const requestOptions: NodeFetchRequestInit = {
     method: 'PUT',
     headers: {
       'Content-Length': fileSizeInBytes.toString(),
     },
-    body: readStream,
-    agent: getProxyAgent(),
-  });
+    body: Buffer.isBuffer(readStream)
+      ? new Blob([readStream])
+      : new Blob([await streamToBuffer(readStream as Readable)]),
+  };
+
+  const proxyAgent = getProxyAgent();
+  if (proxyAgent) {
+    requestOptions.dispatcher = proxyAgent;
+  }
+
+  return fetch(url, requestOptions);
 }

package/src/commands/split/index.ts

@@ -22,20 +22,18 @@ import {
   OPENAPI3_COMPONENT_NAMES,
 } from './types';
 
-import type { OasRef } from '@redocly/openapi-core';
+import type { Oas3Definition, Oas3_1Definition, Oas2Definition } from '@redocly/openapi-core';
 import type {
-  Definition,
-  Oas2Definition,
   Oas3Schema,
-  Oas3Definition,
-  Oas3_1Definition,
+  Oas3_1Schema,
   Oas3Components,
+  Oas3_1Components,
   Oas3ComponentName,
-  ComponentsFiles,
-  RefObject,
   Oas3PathItem,
+  OasRef,
   Referenced,
-} from './types';
+} from '@redocly/openapi-core/lib/typings/openapi';
+import type { ComponentsFiles, Definition, RefObject } from './types';
 import type { CommandArgs } from '../../wrapper';
 import type { VerifyConfigOptions } from '../../types';
 
@@ -239,7 +237,7 @@ function doesFileDiffer(filename: string, componentData: any) {
 
 function removeEmptyComponents(
   openapi: Oas3Definition | Oas3_1Definition,
-  componentType: Oas3ComponentName
+  componentType: Oas3ComponentName<Oas3Schema | Oas3_1Schema>
 ) {
   if (openapi.components && isEmptyObject(openapi.components[componentType])) {
     delete openapi.components[componentType];
@@ -264,15 +262,17 @@ function getFileNamePath(componentDirPath: string, componentName: string, ext: s
 }
 
 function gatherComponentsFiles(
-  components: Oas3Components,
+  components: Oas3Components | Oas3_1Components,
   componentsFiles: ComponentsFiles,
-  componentType: Oas3ComponentName,
+  componentType: Oas3ComponentName<Oas3Schema | Oas3_1Schema>,
   componentName: string,
   filename: string
 ) {
   let inherits: string[] = [];
   if (componentType === OPENAPI3_COMPONENT.Schemas) {
-    inherits = ((components?.[componentType]?.[componentName] as Oas3Schema)?.allOf || [])
+    inherits = (
+      (components?.[componentType]?.[componentName] as Oas3Schema | Oas3_1Schema)?.allOf || []
+    )
       .map(({ $ref }) => $ref)
       .filter(isTruthy);
   }
@@ -347,7 +347,9 @@ function iterateComponents(
     componentTypes.forEach(iterateComponentTypes);
 
     // eslint-disable-next-line no-inner-declarations
-    function iterateAndGatherComponentsFiles(componentType: Oas3ComponentName) {
+    function iterateAndGatherComponentsFiles(
+      componentType: Oas3ComponentName<Oas3Schema | Oas3_1Schema>
+    ) {
       const componentDirPath = path.join(componentsDir, componentType);
       for (const componentName of Object.keys(components?.[componentType] || {})) {
         const filename = getFileNamePath(componentDirPath, componentName, ext);
@@ -356,7 +358,7 @@ function iterateComponents(
     }
 
     // eslint-disable-next-line no-inner-declarations
-    function iterateComponentTypes(componentType: Oas3ComponentName) {
+    function iterateComponentTypes(componentType: Oas3ComponentName<Oas3Schema | Oas3_1Schema>) {
       const componentDirPath = path.join(componentsDir, componentType);
       createComponentDir(componentDirPath, componentType);
       for (const componentName of Object.keys(components?.[componentType] || {})) {

package/src/commands/split/types.ts

@@ -1,29 +1,6 @@
-import {
-  Oas3Schema,
-  Oas3_1Schema,
-  Oas3Definition,
-  Oas3_1Definition,
-  Oas3Components,
-  Oas3PathItem,
-  Oas3Paths,
-  Oas3ComponentName,
-  Oas3_1Webhooks,
-  Oas2Definition,
-  Referenced,
-} from '@redocly/openapi-core';
-export {
-  Oas3_1Definition,
-  Oas3Definition,
-  Oas2Definition,
-  Oas3Components,
-  Oas3Paths,
-  Oas3PathItem,
-  Oas3ComponentName,
-  Oas3_1Schema,
-  Oas3Schema,
-  Oas3_1Webhooks,
-  Referenced,
-};
+import type { Oas2Definition } from '@redocly/openapi-core';
+import type { Oas3_1Definition, Oas3Definition } from '@redocly/openapi-core/lib/typings/openapi';
+
 export type Definition = Oas3_1Definition | Oas3Definition | Oas2Definition;
 export interface ComponentsFiles {
   [schemas: string]: any;

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

@@ -1,5 +1,3 @@
-import nodeFetch, { type RequestInit } from 'node-fetch';
-import AbortController from 'abort-controller';
 import { getProxyAgent } from '@redocly/openapi-core';
 
 export const DEFAULT_FETCH_TIMEOUT = 3000;
@@ -10,24 +8,23 @@ export type FetchWithTimeoutOptions = RequestInit & {
 
 export default async (url: string, { timeout, ...options }: FetchWithTimeoutOptions = {}) => {
   if (!timeout) {
-    return nodeFetch(url, {
+    return fetch(url, {
       ...options,
-      agent: getProxyAgent(),
-    });
+      dispatcher: getProxyAgent(),
+    } as RequestInit);
   }
 
-  const controller = new AbortController();
+  const controller = new globalThis.AbortController();
   const timeoutId = setTimeout(() => {
     controller.abort();
   }, timeout);
 
-  const res = await nodeFetch(url, {
+  const res = await fetch(url, {
     signal: controller.signal,
     ...options,
-    agent: getProxyAgent(),
-  });
+    dispatcher: getProxyAgent(),
+  } as RequestInit);
 
   clearTimeout(timeoutId);
-
   return res;
 };