@redocly/cli 1.6.0 → 1.8.0

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

@@ -0,0 +1,199 @@
+import fetchWithTimeout from '../../utils/fetch-with-timeout';
+import fetch from 'node-fetch';
+import * as FormData from 'form-data';
+
+import type { Response } from 'node-fetch';
+import type { ReadStream } from 'fs';
+import type {
+  ListRemotesResponse,
+  ProjectSourceResponse,
+  PushResponse,
+  UpsertRemoteResponse,
+} from './types';
+
+class RemotesApiClient {
+  constructor(private readonly domain: string, private readonly apiKey: string) {}
+
+  private async getParsedResponse<T>(response: Response): Promise<T> {
+    const responseBody = await response.json();
+
+    if (response.ok) {
+      return responseBody as T;
+    }
+
+    throw new Error(responseBody.title || response.statusText);
+  }
+
+  async getDefaultBranch(organizationId: string, projectId: string) {
+    const response = await fetch(
+      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/source`,
+      {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+      }
+    );
+
+    try {
+      const source = await this.getParsedResponse<ProjectSourceResponse>(response);
+
+      return source.branchName;
+    } catch (err) {
+      throw new Error(`Failed to fetch default branch: ${err.message || 'Unknown error'}`);
+    }
+  }
+
+  async upsert(
+    organizationId: string,
+    projectId: string,
+    remote: {
+      mountPath: string;
+      mountBranchName: string;
+    }
+  ): Promise<UpsertRemoteResponse> {
+    const response = await fetch(
+      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes`,
+      {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: JSON.stringify({
+          mountPath: remote.mountPath,
+          mountBranchName: remote.mountBranchName,
+          type: 'CICD',
+          autoMerge: true,
+        }),
+      }
+    );
+
+    try {
+      return await this.getParsedResponse<UpsertRemoteResponse>(response);
+    } catch (err) {
+      throw new Error(`Failed to upsert remote: ${err.message || 'Unknown error'}`);
+    }
+  }
+
+  async push(
+    organizationId: string,
+    projectId: string,
+    payload: PushPayload,
+    files: { path: string; stream: ReadStream | Buffer }[]
+  ): Promise<PushResponse> {
+    const formData = new FormData();
+
+    formData.append('remoteId', payload.remoteId);
+    formData.append('commit[message]', payload.commit.message);
+    formData.append('commit[author][name]', payload.commit.author.name);
+    formData.append('commit[author][email]', payload.commit.author.email);
+    formData.append('commit[branchName]', payload.commit.branchName);
+    payload.commit.url && formData.append('commit[url]', payload.commit.url);
+    payload.commit.namespace && formData.append('commit[namespaceId]', payload.commit.namespace);
+    payload.commit.sha && formData.append('commit[sha]', payload.commit.sha);
+    payload.commit.repository && formData.append('commit[repositoryId]', payload.commit.repository);
+    payload.commit.createdAt && formData.append('commit[createdAt]', payload.commit.createdAt);
+
+    for (const file of files) {
+      formData.append(`files[${file.path}]`, file.stream);
+    }
+
+    payload.isMainBranch && formData.append('isMainBranch', 'true');
+
+    const response = await fetch(
+      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/pushes`,
+      {
+        method: 'POST',
+        headers: {
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+        body: formData,
+      }
+    );
+
+    try {
+      return await this.getParsedResponse<PushResponse>(response);
+    } catch (err) {
+      throw new Error(`Failed to push: ${err.message || 'Unknown error'}`);
+    }
+  }
+
+  async getRemotesList(organizationId: string, projectId: string, mountPath: string) {
+    const response = await fetch(
+      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/remotes?filter=mountPath:/${mountPath}/`,
+      {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+      }
+    );
+
+    try {
+      return await this.getParsedResponse<ListRemotesResponse>(response);
+    } catch (err) {
+      throw new Error(`Failed to get remote list: ${err.message || 'Unknown error'}`);
+    }
+  }
+
+  async getPush({
+    organizationId,
+    projectId,
+    pushId,
+  }: {
+    organizationId: string;
+    projectId: string;
+    pushId: string;
+  }) {
+    const response = await fetchWithTimeout(
+      `${this.domain}/api/orgs/${organizationId}/projects/${projectId}/pushes/${pushId}`,
+      {
+        method: 'GET',
+        headers: {
+          'Content-Type': 'application/json',
+          Authorization: `Bearer ${this.apiKey}`,
+        },
+      }
+    );
+
+    if (!response) {
+      throw new Error(`Failed to get push status: Time is up`);
+    }
+
+    try {
+      return await this.getParsedResponse<PushResponse>(response);
+    } catch (err) {
+      throw new Error(`Failed to get push status: ${err.message || 'Unknown error'}`);
+    }
+  }
+}
+
+export class ReuniteApiClient {
+  remotes: RemotesApiClient;
+
+  constructor(public domain: string, private readonly apiKey: string) {
+    this.remotes = new RemotesApiClient(this.domain, this.apiKey);
+  }
+}
+
+export type PushPayload = {
+  remoteId: string;
+  commit: {
+    message: string;
+    branchName: string;
+    sha?: string;
+    url?: string;
+    createdAt?: string;
+    namespace?: string;
+    repository?: string;
+    author: {
+      name: string;
+      email: string;
+      image?: string;
+    };
+  };
+  isMainBranch?: boolean;
+};

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

@@ -0,0 +1,26 @@
+import { resolve } from 'path';
+import { homedir } from 'os';
+import { existsSync, readFileSync } from 'fs';
+import { isNotEmptyObject } from '@redocly/openapi-core/lib/utils';
+import { TOKEN_FILENAME } from '@redocly/openapi-core/lib/redocly';
+
+function readCredentialsFile(credentialsPath: string) {
+  return existsSync(credentialsPath) ? JSON.parse(readFileSync(credentialsPath, 'utf-8')) : {};
+}
+
+export function getApiKeys(domain: string) {
+  const apiKey = process.env.REDOCLY_AUTHORIZATION;
+
+  if (apiKey) {
+    return apiKey;
+  }
+
+  const credentialsPath = resolve(homedir(), TOKEN_FILENAME);
+  const credentials = readCredentialsFile(credentialsPath);
+
+  if (isNotEmptyObject(credentials) && credentials[domain]) {
+    return credentials[domain];
+  }
+
+  throw new Error('No api key provided, please use environment variable REDOCLY_AUTHORIZATION.');
+}

package/src/cms/api/domains.ts

@@ -0,0 +1,11 @@
+const DEFAULT_DOMAIN = 'https://app.cloud.redocly.com';
+
+export function getDomain(): string {
+  const domain = process.env.REDOCLY_DOMAIN;
+
+  if (domain) {
+    return domain;
+  }
+
+  return DEFAULT_DOMAIN;
+}

package/src/cms/api/index.ts

@@ -0,0 +1,3 @@
+export * from './api-client';
+export * from './domains';
+export * from './api-keys';

package/src/cms/api/types.ts

@@ -0,0 +1,101 @@
+export type ProjectSourceResponse = {
+  branchName: string;
+  contentPath: string;
+  isInternal: boolean;
+};
+
+export type UpsertRemoteResponse = {
+  id: string;
+  type: 'CICD';
+  mountPath: string;
+  mountBranchName: string;
+  organizationId: string;
+  projectId: string;
+};
+
+export type ListRemotesResponse = {
+  object: 'list';
+  page: {
+    endCursor: string;
+    startCursor: string;
+    haxNextPage: boolean;
+    hasPrevPage: boolean;
+    limit: number;
+    total: number;
+  };
+  items: Remote[];
+};
+
+export type Remote = {
+  mountPath: string;
+  type: string;
+  autoSync: boolean;
+  autoMerge: boolean;
+  createdAt: string;
+  updatedAt: string;
+  providerType: string;
+  namespaceId: string;
+  repositoryId: string;
+  projectId: string;
+  mountBranchName: string;
+  contentPath: string;
+  credentialId: string;
+  branchName: string;
+  contentType: string;
+  id: string;
+};
+
+export type PushResponse = {
+  id: string;
+  remoteId: string;
+  commit: {
+    message: string;
+    branchName: string;
+    sha: string | null;
+    url: string | null;
+    createdAt: string | null;
+    namespace: string | null;
+    repository: string | null;
+    author: {
+      name: string;
+      email: string;
+      image: string | null;
+    };
+  };
+  remote: {
+    commits: {
+      branchName: string;
+      sha: string;
+    }[];
+  };
+  hasChanges: boolean;
+  isOutdated: boolean;
+  isMainBranch: boolean;
+  status: PushStatusResponse;
+};
+
+type DeploymentStatusResponse = {
+  deploy: {
+    url: string | null;
+    status: DeploymentStatus;
+  };
+  scorecard: ScorecardItem[];
+};
+
+export type PushStatusResponse = {
+  preview: DeploymentStatusResponse;
+  production: DeploymentStatusResponse;
+};
+
+export type ScorecardItem = {
+  name: string;
+  status: PushStatusBase;
+  description: string;
+  url: string;
+};
+
+export type PushStatusBase = 'pending' | 'success' | 'running' | 'failed';
+
+// export type BuildStatus = PushStatusBase | 'NOT_STARTED' | 'QUEUED';
+
+export type DeploymentStatus = 'skipped' | PushStatusBase;

package/src/cms/commands/__tests__/push-status.test.ts

@@ -0,0 +1,212 @@
+import { handlePushStatus } from '../push-status';
+import { PushResponse } from '../../api/types';
+import { exitWithError } from '../../../utils/miscellaneous';
+
+const remotes = {
+  getPush: jest.fn(),
+  getRemotesList: jest.fn(),
+};
+
+jest.mock('../../../utils/miscellaneous');
+
+jest.mock('colorette', () => ({
+  green: (str: string) => str,
+  yellow: (str: string) => str,
+  red: (str: string) => str,
+  gray: (str: string) => str,
+  magenta: (str: string) => str,
+  cyan: (str: string) => str,
+}));
+
+jest.mock('../../api', () => ({
+  ...jest.requireActual('../../api'),
+  ReuniteApiClient: jest.fn().mockImplementation(function (this: any, ...args) {
+    this.remotes = remotes;
+  }),
+}));
+
+describe('handlePushStatus()', () => {
+  const mockConfig = { apis: {} } as any;
+
+  const pushResponseStub = {
+    hasChanges: true,
+    status: {
+      preview: {
+        scorecard: [],
+        deploy: {
+          url: 'https://test-url',
+          status: 'success',
+        },
+      },
+      production: {
+        scorecard: [],
+        deploy: {
+          url: 'https://test-url',
+          status: 'success',
+        },
+      },
+    },
+  } as unknown as PushResponse;
+
+  beforeEach(() => {
+    jest.spyOn(process.stderr, 'write').mockImplementation(() => true);
+    jest.spyOn(process.stdout, 'write').mockImplementation(() => true);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should throw error if organization not provided', async () => {
+    await handlePushStatus(
+      {
+        domain: 'test-domain',
+        organization: '',
+        project: 'test-project',
+        pushId: 'test-push-id',
+        'max-execution-time': 1000,
+      },
+      mockConfig
+    );
+
+    expect(exitWithError).toHaveBeenCalledWith(
+      "No organization provided, please use --organization option or specify the 'organization' field in the config file."
+    );
+  });
+
+  it('should return success push status for preview-build', async () => {
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+    remotes.getPush.mockResolvedValueOnce(pushResponseStub);
+
+    await handlePushStatus(
+      {
+        domain: 'test-domain',
+        organization: 'test-org',
+        project: 'test-project',
+        pushId: 'test-push-id',
+        'max-execution-time': 1000,
+      },
+      mockConfig
+    );
+    expect(process.stdout.write).toHaveBeenCalledTimes(1);
+    expect(process.stdout.write).toHaveBeenCalledWith(
+      '🚀 PREVIEW deployment succeeded.\nPreview URL: https://test-url\n'
+    );
+  });
+
+  it('should return success push status for preview and production builds', async () => {
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+    remotes.getPush.mockResolvedValue({ ...pushResponseStub, isMainBranch: true });
+
+    await handlePushStatus(
+      {
+        domain: 'test-domain',
+        organization: 'test-org',
+        project: 'test-project',
+        pushId: 'test-push-id',
+        'max-execution-time': 1000,
+      },
+      mockConfig
+    );
+    expect(process.stdout.write).toHaveBeenCalledTimes(2);
+    expect(process.stdout.write).toHaveBeenCalledWith(
+      '🚀 PREVIEW deployment succeeded.\nPreview URL: https://test-url\n'
+    );
+    expect(process.stdout.write).toHaveBeenCalledWith(
+      '🚀 PRODUCTION deployment succeeded.\nPreview URL: https://test-url\n'
+    );
+  });
+
+  it('should return failed push status for preview build', async () => {
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    remotes.getPush.mockResolvedValue({
+      isOutdated: false,
+      hasChanges: true,
+      status: {
+        preview: { deploy: { status: 'failed', url: 'https://test-url' }, scorecard: [] },
+      },
+    });
+
+    await handlePushStatus(
+      {
+        domain: 'test-domain',
+        organization: 'test-org',
+        project: 'test-project',
+        pushId: 'test-push-id',
+        'max-execution-time': 1000,
+      },
+      mockConfig
+    );
+    expect(exitWithError).toHaveBeenCalledWith(
+      '❌ PREVIEW deployment failed.\nPreview URL: https://test-url'
+    );
+  });
+
+  it('should return success push status for preview build and print scorecards', async () => {
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    remotes.getPush.mockResolvedValue({
+      isOutdated: false,
+      hasChanges: true,
+      status: {
+        preview: {
+          deploy: { status: 'success', url: 'https://test-url' },
+          scorecard: [
+            {
+              name: 'test-name',
+              status: 'success',
+              description: 'test-description',
+              url: 'test-url',
+            },
+          ],
+        },
+      },
+    });
+
+    await handlePushStatus(
+      {
+        domain: 'test-domain',
+        organization: 'test-org',
+        project: 'test-project',
+        pushId: 'test-push-id',
+        'max-execution-time': 1000,
+      },
+      mockConfig
+    );
+    expect(process.stdout.write).toHaveBeenCalledTimes(4);
+    expect(process.stdout.write).toHaveBeenCalledWith(
+      '🚀 PREVIEW deployment succeeded.\nPreview URL: https://test-url\n'
+    );
+    expect(process.stdout.write).toHaveBeenCalledWith('\nScorecard:');
+    expect(process.stdout.write).toHaveBeenCalledWith(
+      '\n    Name: test-name\n    Status: success\n    URL: test-url\n    Description: test-description\n'
+    );
+    expect(process.stdout.write).toHaveBeenCalledWith('\n');
+  });
+
+  it('should display message if there is no changes', async () => {
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    remotes.getPush.mockResolvedValueOnce({
+      isOutdated: false,
+      hasChanges: false,
+      status: {
+        preview: { deploy: { status: 'skipped', url: 'https://test-url' }, scorecard: [] },
+      },
+    });
+
+    await handlePushStatus(
+      {
+        domain: 'test-domain',
+        organization: 'test-org',
+        project: 'test-project',
+        pushId: 'test-push-id',
+        wait: true,
+        'max-execution-time': 1000,
+      },
+      mockConfig
+    );
+    expect(process.stderr.write).toHaveBeenCalledWith('Files not uploaded. Reason: no changes.\n');
+  });
+});