@squiz/component-cli-lib 1.69.1 → 1.70.1

package/src/upload-job.ts

@@ -1,101 +0,0 @@
-import { uploadFile } from '@squiz/virus-scanner-lib';
-
-import { zipDirectory } from '@squiz/dx-common-lib';
-import { ManifestServiceForDev, JobManifestV1Model } from '@squiz/job-runner-lib';
-import fsp from 'fs/promises';
-import path from 'path';
-import { AxiosInstance } from 'axios';
-import color from 'cli-color';
-import { getLogger, Logger } from '@squiz/dx-logger-lib';
-import { watchAndWaitForUploadAndScanComplete, handleResponse, checkIfVersionExists, isAxiosResponse } from './utils';
-
-export const logger: Logger = getLogger({ name: 'upload-job', format: 'human' });
-
-export async function uploadJobFolder(
-  apiClient: AxiosInstance,
-  folderPath: string,
-  baseTempDir: string = '',
-): Promise<void> {
-  const tmpDir = await fsp.mkdtemp(path.resolve(baseTempDir, 'job-upload'));
-
-  try {
-    const manifest = await getAndValidateManifest(apiClient, folderPath);
-
-    const initialUpload = await initializeUpload(apiClient, folderPath, tmpDir);
-
-    await uploadFile(initialUpload.upload, initialUpload.zip);
-
-    await watchAndWaitForUploadAndScanComplete(apiClient, '/upload-job/status/', initialUpload.upload.id);
-
-    logger.info(`deployment id: ${initialUpload.upload.id} status: deploying job folder`);
-
-    const result = await pollForResult(apiClient, initialUpload.upload.id, manifest.getModel());
-
-    await cleanupTmpDir(tmpDir);
-
-    if (result.status === 'successful') {
-      logger.info(`deployment id: ${initialUpload.upload.id} status: ${color.green('success')}`);
-    } else {
-      const message = result?.message ?? 'unknown';
-      logger.error(`failed due an unexpected reason: ${message}`);
-      await cleanupTmpDir(tmpDir);
-    }
-  } catch (e) {
-    await cleanupTmpDir(tmpDir);
-    throw e;
-  }
-}
-
-async function initializeUpload(apiClient: AxiosInstance, folderPath: string, tmpDir: string) {
-  logger.info('Initial scanning');
-  const zip = await zipDirectory(folderPath, tmpDir);
-  const initialUpload = { zip: zip, upload: await handleResponse<any>(apiClient.post('/upload-job', {})) };
-  logger.info(`deployment id: ${initialUpload.upload.id} status: transferring`);
-  return initialUpload;
-}
-
-async function getAndValidateManifest(apiClient: AxiosInstance, folderPath: string) {
-  const manifestService = new ManifestServiceForDev(folderPath, logger);
-  const manifestPath = path.join(folderPath, `manifest.json`);
-
-  const manifest = await manifestService.readJobManifest(manifestPath);
-
-  if (await checkIfVersionExists(apiClient, `/job/${manifest.getName()}/${manifest.getVersion()}`)) {
-    throw new Error(`Cannot upload job version, ${manifest.getName()} ${manifest.getVersion()} already exists`);
-  }
-  return manifest;
-}
-
-async function pollForResult(apiClient: AxiosInstance, uploadId: string, manifest: JobManifestV1Model) {
-  let result = await handleResponse<any>(apiClient.post(`/upload-job/next`, { id: uploadId, manifest: manifest }));
-
-  if (!isAxiosResponse(result)) {
-    let retriesAllowed = 12;
-    while (retriesAllowed > 0) {
-      logger.info(
-        `deployment id: ${uploadId} status: ${color.yellow(
-          `unknown, retrying to check the upload status ${retriesAllowed} more times`,
-        )}`,
-      );
-      if (await checkIfVersionExists(apiClient, `/job/${manifest.name}/${manifest.version}`)) {
-        result = {
-          status: 'successful',
-        };
-        break;
-      }
-      await new Promise((r) => setTimeout(r, 10000));
-      retriesAllowed--;
-    }
-    if (retriesAllowed === 0) {
-      logger.error(`deployment id: ${uploadId} status: ${color.red('failed to check the upload status')}`);
-      throw new Error(result.toString());
-    }
-  }
-  return result;
-}
-
-async function cleanupTmpDir(tmpDir: string) {
-  await fsp.rm(tmpDir, { force: true, recursive: true }).catch((error: any) => {
-    logger.error('failed to remove temp directory', error);
-  });
-}

package/src/utils.spec.ts

@@ -1,370 +0,0 @@
-import {
-  watchAndWaitForUploadAndScanComplete,
-  checkIfVersionExists,
-  handleResponse,
-  handleError,
-  isAxiosError,
-  isAxiosResponse,
-  isUserInOrganization,
-  assertComponentTypeAllowed,
-} from './utils';
-import axios, { AxiosResponse, AxiosError } from 'axios';
-
-jest.mock('child_process', () => {
-  return {
-    execSync: (command: string) => {
-      if (command === 'npm whoami') {
-        return 'testuser\n';
-      }
-      if (command === 'npm org ls testuser foo') {
-        return 'user role';
-      }
-      if (command === 'npm org ls testuser bar') {
-        return 'No teams in the organization\n';
-      }
-      if (command === 'npm org ls testuser not_logged') {
-        throw new Error('Not logged in');
-      }
-    },
-  };
-});
-
-beforeEach(() => {
-  jest.resetAllMocks();
-
-  // Reset our process.env.NODE_ENV variable
-  process.env.NODE_ENV = 'test';
-});
-
-const jobService = axios.create({
-  baseURL: 'some_url',
-  headers: {
-    authorization: 'someToken',
-  },
-});
-
-describe('cli lib utils watchAndWaitForUploadAndScanComplete', () => {
-  it('should pass if virus scan is successful', async () => {
-    jest
-      .spyOn(jobService as any, `get`)
-      .mockImplementation(() => Promise.resolve({ data: { status: 'Success' }, status: 200 } as AxiosResponse));
-
-    const res = await watchAndWaitForUploadAndScanComplete(jobService, '/upload-job/status/', '123');
-    expect(res).toBeUndefined();
-  });
-
-  it('should throw specific error if virus scan is flagged', async () => {
-    jest
-      .spyOn(jobService as any, `get`)
-      .mockImplementation(() => Promise.resolve({ data: { status: 'Flagged' }, status: 200 } as AxiosResponse));
-
-    await expect(async () => {
-      await watchAndWaitForUploadAndScanComplete(jobService, '/upload-job/status/', '123');
-    }).rejects.toThrow('upload has been flagged as a virus');
-  });
-
-  it('should throw generic error if virus scan is Error', async () => {
-    jest
-      .spyOn(jobService as any, `get`)
-      .mockImplementation(() => Promise.resolve({ data: { status: 'Error' }, status: 200 } as AxiosResponse));
-
-    await expect(async () => {
-      await watchAndWaitForUploadAndScanComplete(jobService, '/upload-job/status/', '123');
-    }).rejects.toThrow('there has been an error');
-  });
-
-  it('should poll until a result is received', async () => {
-    jest
-      .spyOn(jobService as any, `get`)
-      .mockImplementationOnce(() => Promise.resolve({ data: { status: 'Scanning' }, status: 200 } as AxiosResponse))
-      .mockImplementationOnce(() => Promise.resolve({ data: { status: 'Scanning' }, status: 200 } as AxiosResponse))
-      .mockImplementationOnce(() => Promise.resolve({ data: { status: 'Scanning' }, status: 200 } as AxiosResponse))
-      .mockImplementationOnce(() => Promise.resolve({ data: { status: 'Scanning' }, status: 200 } as AxiosResponse))
-      .mockImplementationOnce(() => Promise.resolve({ data: { status: 'Success' }, status: 200 } as AxiosResponse));
-
-    const res = await watchAndWaitForUploadAndScanComplete(jobService, '/upload-job/status/', '123');
-    expect(res).toBeUndefined();
-    expect((jobService as any).get.mock.calls).toHaveLength(5);
-  });
-});
-
-describe('cli lib utils checkIfVersionExists', () => {
-  it('should return true if version exists', async () => {
-    jest.spyOn(jobService as any, `get`).mockImplementation(() => Promise.resolve({ status: 200 } as AxiosResponse));
-
-    const res = await checkIfVersionExists(jobService, '/job/testJob/1.0.0');
-    expect(res).toBe(true);
-  });
-
-  it('should return false if version does not exist', async () => {
-    jest.spyOn(jobService as any, `get`).mockImplementation(() => Promise.resolve({ status: 404 } as AxiosResponse));
-
-    const res = await checkIfVersionExists(jobService, '/job/testJob/5.0.0');
-    expect(res).toBe(false);
-  });
-
-  it('should throw an error if status is not 404 or 200', async () => {
-    jest
-      .spyOn(jobService as any, `get`)
-      .mockImplementation(() =>
-        Promise.resolve({ status: 500, data: { message: 'something bad happened' } } as AxiosResponse),
-      );
-
-    await expect(async () => {
-      await checkIfVersionExists(jobService, '/job/testJob/5.0.0');
-    }).rejects.toThrow('Unexpected response code 500. something bad happened');
-  });
-});
-
-describe('cli lib utils handleResponse', () => {
-  it('should return response data for a successful request', async () => {
-    jest.spyOn(jobService as any, `get`).mockImplementation(
-      () =>
-        new Promise((resolve) => {
-          resolve({ status: 200, data: { status: 'Successful' } } as AxiosResponse);
-        }),
-    );
-
-    const response = jobService.get('/upload-job/status/123');
-    const res = await handleResponse(response);
-    expect(res).toStrictEqual({ status: 'Successful' });
-  });
-
-  it('should throw an error if error occurs in the request', async () => {
-    jest.spyOn(jobService as any, `get`).mockImplementation(
-      () =>
-        new Promise((resolve, reject) => {
-          reject(new Error('something really bad happened'));
-        }),
-    );
-
-    const response = jobService.get('/upload-job/status/123');
-    await expect(async () => {
-      await handleResponse(response);
-    }).rejects.toThrow('something really bad happened');
-  });
-
-  it('should throw an error if response is not 200 status', async () => {
-    jest.spyOn(jobService as any, `get`).mockImplementation(
-      () =>
-        new Promise((resolve) => {
-          resolve({ status: 400, data: { message: 'some bad request' } } as AxiosResponse);
-        }),
-    );
-
-    const response = jobService.get('/upload-job/status/123');
-    await expect(async () => {
-      await handleResponse(response);
-    }).rejects.toThrow('some bad request');
-  });
-});
-
-describe('cli lib utils handleError', () => {
-  it('should throw an error with message if not an AxiosError', async () => {
-    const error = new Error('oh no');
-    const res = handleError(error);
-
-    expect(res.message).toBe('oh no');
-  });
-  it('should throw an error with generic message if not an AxiosError', async () => {
-    const error = new Error();
-    const res = handleError(error);
-
-    expect(res.message).toBe('An error has occurred');
-  });
-
-  it('should throw an error with additional fields if an AxiosError without message', async () => {
-    const error = new AxiosError('i am an axios error', '500', undefined, undefined, {
-      status: 500,
-      data: { status: 'fail' },
-    } as AxiosResponse);
-    const res = handleError(error);
-
-    expect(res.message).toBe('i am an axios error (code: 500)');
-  });
-
-  it('should throw an error with additional fields if an AxiosError with message', async () => {
-    const error = new AxiosError('i am an axios error', '500', undefined, undefined, {
-      status: 500,
-      data: { message: 'i have failed' },
-    } as AxiosResponse);
-    const res = handleError(error);
-
-    expect(res.message).toBe('Unexpected response code 500. i have failed');
-  });
-});
-
-describe('cli lib utils isAxiosError', () => {
-  it('should return false if not an AxiosError', async () => {
-    const error = new Error('oh no');
-    const res = isAxiosError(error);
-
-    expect(res).toBe(false);
-  });
-  it('should return true if  an AxiosError', async () => {
-    const error = new AxiosError('i am an axios error', '500', undefined, undefined, {
-      status: 500,
-      data: { message: 'i have failed' },
-    } as AxiosResponse);
-    const res = isAxiosError(error);
-
-    expect(res).toBe(true);
-  });
-});
-
-describe('cli lib utils isAxiosResponse', () => {
-  it('should return true if an AxiosResponse', async () => {
-    const resp = {
-      status: 200,
-      data: { message: 'i have succeeded' },
-    } as AxiosResponse;
-    const res = isAxiosResponse(resp);
-
-    expect(res).toBe(true);
-  });
-  it('should return false if not an AxiosResponse', async () => {
-    const resp = {
-      code: 200,
-      data: { message: 'i am not an axios response' },
-    };
-    const res = isAxiosResponse(resp);
-
-    expect(res).toBe(false);
-  });
-});
-
-describe('isUserInFooOrganization', () => {
-  it('should return true if the user is logged in and belongs to the "foo" organization', () => {
-    const result = isUserInOrganization('foo');
-    expect(result).toBe(true);
-  });
-
-  it('should return false if the user is logged in but does not belong to the "bar" organization', () => {
-    const result = isUserInOrganization('bar');
-    expect(result).toBe(false);
-  });
-
-  it('should return false if the user is not logged in', () => {
-    const result = isUserInOrganization('not_logged');
-    expect(result).toBe(false);
-  });
-});
-
-describe('cli lib utils assertComponentTypeAllowed', () => {
-  it('"edge" component only - should NOT throw error if uploading "edge" component', async () => {
-    const response = {
-      data: {
-        edgeComponentsOnly: true,
-      },
-    } as AxiosResponse;
-    const spy = jest.spyOn(jobService as any, `get`);
-    spy.mockImplementation(() => Promise.resolve(response));
-
-    await assertComponentTypeAllowed('edge', jobService, 'foo', 'some-url');
-    expect(spy).toHaveBeenCalledTimes(0);
-  });
-
-  it('"edge" component only - should throw error if uploading "server" component', async () => {
-    const response = {
-      data: {
-        edgeComponentsOnly: true,
-      },
-    } as AxiosResponse;
-    const spy = jest.spyOn(jobService as any, `get`);
-    spy.mockImplementation(() => Promise.resolve(response));
-
-    await expect(assertComponentTypeAllowed('server', jobService, 'foo', 'some-url')).rejects.toThrow(
-      `Cannot upload "server" type component. ` +
-        `Tenant component service is configured to allow "edge" type components only.`,
-    );
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  it('"edge" component only - should throw error if uploading "undefined" component', async () => {
-    const response = {
-      data: {
-        edgeComponentsOnly: true,
-      },
-    } as AxiosResponse;
-    const spy = jest.spyOn(jobService as any, `get`);
-    spy.mockImplementation(() => Promise.resolve(response));
-
-    await expect(assertComponentTypeAllowed(undefined, jobService, 'foo', 'some-url')).rejects.toThrow(
-      `Cannot upload "server" type component. ` +
-        `Tenant component service is configured to allow "edge" type components only.`,
-    );
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  it('no restriction set - should NOT throw error uploading "edge" component', async () => {
-    const response = {
-      data: {
-        edgeComponentsOnly: false,
-      },
-    } as AxiosResponse;
-    const spy = jest.spyOn(jobService as any, `get`);
-    spy.mockImplementation(() => Promise.resolve(response));
-
-    await assertComponentTypeAllowed('edge', jobService, 'foo', 'some-url');
-    expect(spy).toHaveBeenCalledTimes(0);
-  });
-
-  it('no restriction set - should NOT throw error uploading "server" component', async () => {
-    const response = {
-      data: {
-        edgeComponentsOnly: false,
-      },
-    } as AxiosResponse;
-    const spy = jest.spyOn(jobService as any, `get`);
-    spy.mockImplementation(() => Promise.resolve(response));
-
-    assertComponentTypeAllowed('server', jobService, 'foo', 'some-url');
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  it('no restriction set - should NOT throw error uploading "undefined" component', async () => {
-    const response = {
-      data: {
-        edgeComponentsOnly: false,
-      },
-    } as AxiosResponse;
-    const spy = jest.spyOn(jobService as any, `get`);
-    spy.mockImplementation(() => Promise.resolve(response));
-
-    assertComponentTypeAllowed(undefined, jobService, 'foo', 'some-url');
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  it('settings undefined - should NOT throw error uploading "edge" component', async () => {
-    const response = {
-      data: {},
-    } as AxiosResponse;
-    const spy = jest.spyOn(jobService as any, `get`);
-    spy.mockImplementation(() => Promise.resolve(response));
-
-    await assertComponentTypeAllowed('edge', jobService, 'foo', 'some-url');
-    expect(spy).toHaveBeenCalledTimes(0);
-  });
-
-  it('settings undefined - should NOT throw error uploading "server" component', async () => {
-    const response = {
-      data: {},
-    } as AxiosResponse;
-    const spy = jest.spyOn(jobService as any, `get`);
-    spy.mockImplementation(() => Promise.resolve(response));
-
-    assertComponentTypeAllowed('server', jobService, 'foo', 'some-url');
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-
-  it('settings undefined - should NOT throw error uploading "undefined" component', async () => {
-    const response = {
-      data: {},
-    } as AxiosResponse;
-    const spy = jest.spyOn(jobService as any, `get`);
-    spy.mockImplementation(() => Promise.resolve(response));
-
-    assertComponentTypeAllowed(undefined, jobService, 'foo', 'some-url');
-    expect(spy).toHaveBeenCalledTimes(1);
-  });
-});

package/src/utils.ts

@@ -1,149 +0,0 @@
-import { AxiosResponse, AxiosError, AxiosInstance } from 'axios';
-import { ScanStatus } from '@squiz/virus-scanner-lib';
-import { execSync } from 'child_process';
-import { ComponentType } from '@squiz/component-lib';
-
-export async function watchAndWaitForUploadAndScanComplete(
-  apiClient: AxiosInstance,
-  endpoint: string,
-  id: string,
-  managementURL?: string,
-): Promise<void> {
-  let poll: () => Promise<ScanStatus>;
-  if (managementURL) {
-    poll = () => handleResponse<ScanStatus>(apiClient.get(endpoint + id, { baseURL: managementURL }));
-  } else {
-    poll = () => handleResponse<ScanStatus>(apiClient.get(endpoint + id));
-  }
-  return new Promise((resolve, reject) => {
-    const recurse = () =>
-      poll().then(async (req) => {
-        if (req.status == 'Success') {
-          resolve();
-        } else if (req.status == 'Flagged') {
-          reject(new Error('upload has been flagged as a virus'));
-        } else if (req.status == 'Error') {
-          reject(new Error('there has been an error'));
-        } else {
-          setTimeout(async () => {
-            await recurse();
-          }, 1000);
-        }
-      });
-
-    recurse();
-  });
-}
-
-export async function checkIfVersionExists(apiClient: AxiosInstance, endpoint: string, managementURL?: string) {
-  try {
-    const response = await apiClient.get(endpoint, {
-      validateStatus: null,
-      baseURL: managementURL,
-    });
-
-    if (response.status === 200) {
-      return true;
-    } else if (response.status === 404) {
-      return false;
-    }
-
-    const error = new AxiosError(
-      response?.data?.message || response.statusText,
-      response.status.toString(),
-      undefined,
-      undefined,
-      response,
-    );
-
-    throw handleError(error);
-  } catch (error) {
-    throw handleError(error);
-  }
-}
-
-export async function handleResponse<T>(axiosInstance: Promise<AxiosResponse<T>>): Promise<T> {
-  try {
-    const response = await axiosInstance;
-    if (response.status.toString().startsWith('2')) {
-      return response.data;
-    }
-    throw handleError(response.data);
-  } catch (error) {
-    throw handleError(error);
-  }
-}
-
-export function handleError(error: any): Error {
-  const { response } = error;
-  const errorMessage = error.message;
-  const newError = new Error(errorMessage || 'An error has occurred');
-
-  if (isAxiosError(error)) {
-    const errorCode = response?.status ?? 'unknown';
-    if (response?.data?.message) {
-      newError.message = `Unexpected response code ${errorCode}. ${response.data.message}`.trim();
-    } else {
-      newError.message = `${errorMessage} (code: ${errorCode})`;
-    }
-  }
-
-  newError.stack = error.stack;
-
-  return newError;
-}
-
-export function isAxiosError(error: any): error is AxiosError {
-  return error && error.isAxiosError === true;
-}
-
-export function isAxiosResponse(response: unknown): response is AxiosResponse {
-  return response instanceof Object && Object.prototype.hasOwnProperty.call(response, 'status');
-}
-
-/**
- * Execute a shell command and return the trimmed result as a string.
- * @param {string} command - The shell command to execute.
- * @returns {string} The trimmed result of the shell command.
- */
-function executeShellCommand(command: string): string {
-  try {
-    return execSync(command, { encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
-  } catch (error) {
-    return '';
-  }
-}
-
-export function isUserInOrganization(organisationName: string = 'squiz'): boolean {
-  const npmUsername = executeShellCommand('npm whoami');
-  if (!npmUsername) {
-    return false;
-  }
-  const orgListProcess = executeShellCommand(`npm org ls ${npmUsername} ${organisationName}`);
-  const isMember = orgListProcess.includes('user');
-
-  return isMember;
-}
-
-export async function assertComponentTypeAllowed(
-  componentType: unknown,
-  apiClient: AxiosInstance,
-  endpoint: string,
-  managementURL: string,
-) {
-  if ((componentType as ComponentType) !== 'edge') {
-    try {
-      const response = await apiClient.get(endpoint, {
-        baseURL: managementURL,
-      });
-      if (response.data.edgeComponentsOnly) {
-        throw Error(
-          `Cannot upload "server" type component. ` +
-            `Tenant component service is configured to allow "edge" type components only.`,
-        );
-      }
-    } catch (error) {
-      throw handleError(error);
-    }
-  }
-}

package/templates/advanced/build.js

@@ -1,43 +0,0 @@
-// Build process
-const esbuild = require('esbuild');
-const { sassPlugin } = require('esbuild-sass-plugin');
-const postcss = require('postcss');
-const autoprefixer = require('autoprefixer');
-
-const esbuildOptions = {
-  outdir: 'dist',
-  bundle: true,
-  minify: false,
-  treeShaking: true,
-};
-
-// Server build
-esbuild
-  .build({
-    ...esbuildOptions,
-    platform: 'node',
-    entryPoints: ['./main.js'],
-    format: 'cjs',
-    target: 'node16',
-  })
-  .catch(() => process.exit(1));
-
-// Client Build
-esbuild
-  .build({
-    ...esbuildOptions,
-    platform: 'browser',
-    entryPoints: ['./static/default.js', './static/default.scss'],
-    format: 'esm',
-    target: 'es2020',
-    plugins: [
-      sassPlugin({
-        async transform(source) {
-          const { css } = await postcss([autoprefixer]).process(source);
-          return css;
-        },
-      }),
-    ],
-  })
-  .then(() => console.log('⚡ Styles & Scripts Compiled! ⚡ '))
-  .catch(() => process.exit(1));

package/templates/advanced/main.js

@@ -1,3 +0,0 @@
-export default async function (input, info) {
-  return `<div>hello world</div>`;
-}