@redocly/cli 1.7.0 → 1.8.1

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');
+  });
+});

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

@@ -0,0 +1,293 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { handlePush } from '../push';
+import { ReuniteApiClient } from '../../api';
+
+const remotes = {
+  push: jest.fn(),
+  upsert: jest.fn(),
+  getDefaultBranch: jest.fn(),
+};
+
+jest.mock('@redocly/openapi-core', () => ({
+  slash: jest.fn().mockImplementation((p) => p),
+}));
+
+jest.mock('../../api', () => ({
+  ...jest.requireActual('../../api'),
+  ReuniteApiClient: jest.fn().mockImplementation(function (this: any, ...args) {
+    this.remotes = remotes;
+  }),
+}));
+
+describe('handlePush()', () => {
+  let pathResolveSpy: jest.SpyInstance;
+  let pathRelativeSpy: jest.SpyInstance;
+  let pathDirnameSpy: jest.SpyInstance;
+  let fsStatSyncSpy: jest.SpyInstance;
+  let fsReaddirSyncSpy: jest.SpyInstance;
+
+  beforeEach(() => {
+    remotes.getDefaultBranch.mockResolvedValueOnce('test-default-branch');
+    remotes.upsert.mockResolvedValueOnce({ id: 'test-remote-id' });
+    remotes.push.mockResolvedValueOnce({ branchName: 'uploaded-to-branch' });
+
+    jest.spyOn(fs, 'createReadStream').mockReturnValue('stream' as any);
+
+    pathResolveSpy = jest.spyOn(path, 'resolve');
+    pathRelativeSpy = jest.spyOn(path, 'relative');
+    pathDirnameSpy = jest.spyOn(path, 'dirname');
+    fsStatSyncSpy = jest.spyOn(fs, 'statSync');
+    fsReaddirSyncSpy = jest.spyOn(fs, 'readdirSync');
+  });
+
+  afterEach(() => {
+    pathResolveSpy.mockRestore();
+    pathRelativeSpy.mockRestore();
+    pathDirnameSpy.mockRestore();
+    fsStatSyncSpy.mockRestore();
+    fsReaddirSyncSpy.mockRestore();
+  });
+
+  it('should upload files', async () => {
+    const mockConfig = { apis: {} } as any;
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    fsStatSyncSpy.mockReturnValueOnce({
+      isDirectory() {
+        return false;
+      },
+    } as any);
+
+    pathResolveSpy.mockImplementationOnce((p) => p);
+    pathRelativeSpy.mockImplementationOnce((_, p) => p);
+    pathDirnameSpy.mockImplementation((_: string) => '.');
+
+    await handlePush(
+      {
+        domain: 'test-domain',
+        'mount-path': 'test-mount-path',
+        organization: 'test-org',
+        project: 'test-project',
+        branch: 'test-branch',
+        namespace: 'test-namespace',
+        repository: 'test-repository',
+        'commit-sha': 'test-commit-sha',
+        'commit-url': 'test-commit-url',
+        'default-branch': 'test-branch',
+        'created-at': 'test-created-at',
+        author: 'TestAuthor <test-author@mail.com>',
+        message: 'Test message',
+        files: ['test-file'],
+        'max-execution-time': 10,
+      },
+      mockConfig
+    );
+
+    expect(remotes.getDefaultBranch).toHaveBeenCalledWith('test-org', 'test-project');
+    expect(remotes.upsert).toHaveBeenCalledWith('test-org', 'test-project', {
+      mountBranchName: 'test-default-branch',
+      mountPath: 'test-mount-path',
+    });
+    expect(remotes.push).toHaveBeenCalledWith(
+      'test-org',
+      'test-project',
+      {
+        isMainBranch: true,
+        remoteId: 'test-remote-id',
+        commit: {
+          message: 'Test message',
+          branchName: 'test-branch',
+          createdAt: 'test-created-at',
+          namespace: 'test-namespace',
+          repository: 'test-repository',
+          sha: 'test-commit-sha',
+          url: 'test-commit-url',
+          author: {
+            name: 'TestAuthor',
+            email: 'test-author@mail.com',
+          },
+        },
+      },
+      [
+        {
+          path: 'test-file',
+          stream: 'stream',
+        },
+      ]
+    );
+  });
+
+  it('should collect files from directory and preserve file structure', async () => {
+    const mockConfig = { apis: {} } as any;
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    /*
+      ├── app
+      │   ├── index.html
+      ├── openapi.yaml
+      └── some-ref.yaml
+    */
+
+    fsStatSyncSpy.mockImplementation(
+      (filePath) =>
+        ({
+          isDirectory() {
+            return filePath === 'test-folder' || filePath === 'test-folder/app';
+          },
+        } as any)
+    );
+
+    fsReaddirSyncSpy.mockImplementation((dirPath): any => {
+      if (dirPath === 'test-folder') {
+        return ['app', 'another-ref.yaml', 'openapi.yaml'];
+      }
+
+      if (dirPath === 'test-folder/app') {
+        return ['index.html'];
+      }
+
+      throw new Error('Not a directory');
+    });
+
+    await handlePush(
+      {
+        domain: 'test-domain',
+        'mount-path': 'test-mount-path',
+        organization: 'test-org',
+        project: 'test-project',
+        branch: 'test-branch',
+        author: 'TestAuthor <test-author@mail.com>',
+        message: 'Test message',
+        'default-branch': 'main',
+        files: ['test-folder'],
+        'max-execution-time': 10,
+      },
+      mockConfig
+    );
+
+    expect(remotes.push).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.anything(),
+      expect.anything(),
+      [
+        {
+          path: 'app/index.html',
+          stream: 'stream',
+        },
+
+        {
+          path: 'another-ref.yaml',
+          stream: 'stream',
+        },
+        {
+          path: 'openapi.yaml',
+          stream: 'stream',
+        },
+      ]
+    );
+  });
+
+  it('should not upload files if no files passed', async () => {
+    const mockConfig = { apis: {} } as any;
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    await handlePush(
+      {
+        domain: 'test-domain',
+        'mount-path': 'test-mount-path',
+        organization: 'test-org',
+        project: 'test-project',
+        branch: 'test-branch',
+        author: 'TestAuthor <test-author@mail.com>',
+        message: 'Test message',
+        'default-branch': 'main',
+        files: [],
+        'max-execution-time': 10,
+      },
+      mockConfig
+    );
+
+    expect(remotes.getDefaultBranch).not.toHaveBeenCalled();
+    expect(remotes.upsert).not.toHaveBeenCalled();
+    expect(remotes.push).not.toHaveBeenCalled();
+  });
+
+  it('should get organization from config if not passed', async () => {
+    const mockConfig = { organization: 'test-org-from-config', apis: {} } as any;
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+
+    fsStatSyncSpy.mockReturnValueOnce({
+      isDirectory() {
+        return false;
+      },
+    } as any);
+
+    pathResolveSpy.mockImplementationOnce((p) => p);
+    pathRelativeSpy.mockImplementationOnce((_, p) => p);
+    pathDirnameSpy.mockImplementation((_: string) => '.');
+
+    await handlePush(
+      {
+        domain: 'test-domain',
+        'mount-path': 'test-mount-path',
+        project: 'test-project',
+        branch: 'test-branch',
+        author: 'TestAuthor <test-author@mail.com>',
+        message: 'Test message',
+        files: ['test-file'],
+        'default-branch': 'main',
+        'max-execution-time': 10,
+      },
+      mockConfig
+    );
+
+    expect(remotes.getDefaultBranch).toHaveBeenCalledWith(
+      'test-org-from-config',
+      expect.anything()
+    );
+    expect(remotes.upsert).toHaveBeenCalledWith(
+      'test-org-from-config',
+      expect.anything(),
+      expect.anything()
+    );
+    expect(remotes.push).toHaveBeenCalledWith(
+      'test-org-from-config',
+      expect.anything(),
+      expect.anything(),
+      expect.anything()
+    );
+  });
+
+  it('should get domain from env if not passed', async () => {
+    const mockConfig = { organization: 'test-org-from-config', apis: {} } as any;
+    process.env.REDOCLY_AUTHORIZATION = 'test-api-key';
+    process.env.REDOCLY_DOMAIN = 'test-domain-from-env';
+
+    fsStatSyncSpy.mockReturnValueOnce({
+      isDirectory() {
+        return false;
+      },
+    } as any);
+
+    pathResolveSpy.mockImplementationOnce((p) => p);
+    pathRelativeSpy.mockImplementationOnce((_, p) => p);
+    pathDirnameSpy.mockImplementation((_: string) => '.');
+
+    await handlePush(
+      {
+        'mount-path': 'test-mount-path',
+        project: 'test-project',
+        branch: 'test-branch',
+        'default-branch': 'main',
+        author: 'TestAuthor <test-author@mail.com>',
+        message: 'Test message',
+        files: ['test-file'],
+        'max-execution-time': 10,
+      },
+      mockConfig
+    );
+
+    expect(ReuniteApiClient).toBeCalledWith('test-domain-from-env', 'test-api-key');
+  });
+});