@squiz/component-cli-lib 1.69.0 → 1.70.0

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>`;
-}

package/templates/advanced/manifest.json

@@ -1,60 +0,0 @@
-{
-  "$schema": "http://localhost:3000/schemas/v1.json",
-  "name": "default",
-  "namespace": "default-namespace",
-  "displayName": "Default Component",
-  "description": "Default example component",
-  "version": "0.0.1",
-  "mainFunction": "main",
-  "icon": {
-    "id": "fiber_new",
-    "color": {
-      "type": "enum",
-      "value": "green"
-    }
-  },
-  "functions": [
-    {
-      "name": "main",
-      "entry": "dist/main.js",
-      "input": {},
-      "output": {
-        "responseType": "html",
-        "staticFiles": [
-          {
-            "location": "header",
-            "file": {
-              "type": "css",
-              "filepath": "default.css"
-            }
-          },
-          {
-            "location": "footer",
-            "file": {
-              "type": "js",
-              "filepath": "default.js"
-            }
-          }
-        ]
-      }
-    }
-  ],
-  "previews": {
-    "default": {
-      "functionData": {
-        "main": {
-          "inputData": {
-            "type": "file",
-            "path": "previews/example.data.json"
-          },
-          "wrapper": {
-            "path": "previews/preview.html"
-          }
-        }
-      }
-    }
-  },
-  "staticFiles": {
-    "locationRoot": "dist"
-  }
-}