@squiz/component-cli-lib 1.67.0 → 1.68.1

package/lib/integration-tests/helper.d.ts

@@ -1,3 +1,4 @@
+import axios from 'axios';
 import { ComponentSetWebModelForCreate, Manifest } from '@squiz/component-lib';
 import { ContentApi } from '@squiz/component-web-api-lib';
 interface Config {
@@ -12,12 +13,12 @@ interface Config {
 }
 declare const configObj: Config;
 export default configObj;
-export declare const managementService: import("axios").AxiosInstance;
-export declare const managementServiceRoot: import("axios").AxiosInstance;
-export declare const renderService: import("axios").AxiosInstance;
-export declare const contentService: import("axios").AxiosInstance;
-export declare const pageRenderService: import("axios").AxiosInstance;
-export declare const jobService: import("axios").AxiosInstance;
+export declare const managementService: axios.AxiosInstance;
+export declare const managementServiceRoot: axios.AxiosInstance;
+export declare const renderService: axios.AxiosInstance;
+export declare const contentService: axios.AxiosInstance;
+export declare const pageRenderService: axios.AxiosInstance;
+export declare const jobService: axios.AxiosInstance;
 export declare const ci_buildVersion: string;
 export declare const ci_buildBranch: string;
 export declare function getTestComponents(): Promise<import("@squiz/component-lib").ManifestV1[]>;

package/lib/integration-tests/test-setup.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/utils.d.ts

@@ -6,3 +6,4 @@ export declare function handleError(error: any): Error;
 export declare function isAxiosError(error: any): error is AxiosError;
 export declare function isAxiosResponse(response: unknown): response is AxiosResponse;
 export declare function isUserInOrganization(organisationName?: string): boolean;
+export declare function assertComponentTypeAllowed(componentType: unknown, apiClient: AxiosInstance, endpoint: string, managementURL: string): Promise<void>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squiz/component-cli-lib",
-  "version": "1.67.0",
+  "version": "1.68.1",
   "description": "",
   "main": "lib/index.js",
   "private": false,
@@ -17,10 +17,10 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
-    "@squiz/component-lib": "^1.64.0",
-    "@squiz/component-web-api-lib": "^1.65.0",
-    "@squiz/dx-common-lib": "^1.64.0",
-    "@squiz/dx-json-schema-lib": "^1.68.0",
+    "@squiz/component-lib": "^1.78.1",
+    "@squiz/component-web-api-lib": "^1.65.1",
+    "@squiz/dx-common-lib": "^1.68.3",
+    "@squiz/dx-json-schema-lib": "^1.76.1",
     "@squiz/dx-logger-lib": "^1.64.0",
     "@squiz/dxp-session-lib": "^1.65.0",
     "@squiz/virus-scanner-lib": "^1.64.0",
@@ -37,9 +37,10 @@
     "typescript": "4.9.4"
   },
   "dependencies": {
-    "@squiz/render-runtime-lib": "^1.64.0",
-    "@squiz/edge-dev-render-runtime-lib": "^2.1.0",
-    "@squiz/runtime-sandbox-node": "^1.64.0",
+    "@squiz/edge-dev-render-runtime-lib": "^2.1.1",
+    "@squiz/job-runner-lib": "file:job-runner-lib.tgz",
+    "@squiz/render-runtime-lib": "^1.76.0",
+    "@squiz/runtime-sandbox-node": "^1.64.2",
     "archiver": "5.3.1",
     "axios": "1.6.0",
     "cli-color": "^2.0.2",

package/src/component-dev-folder-structures.integration.spec.ts

@@ -2,7 +2,7 @@ import supertest from 'supertest';
 import path from 'path';
 import fsp from 'fs/promises';
 
-import { TestHelpers } from '@squiz/render-runtime-lib';
+import { TestHelpers } from '@squiz/render-runtime-lib/test-helpers';
 import { startDevelopmentRender } from './component-dev';
 import { Server } from 'http';
 

package/src/component-dev.integration.spec.ts

@@ -1,4 +1,4 @@
-import { routeTests, TestHelpers } from '@squiz/render-runtime-lib';
+import { routeTests, TestHelpers } from '@squiz/render-runtime-lib/test-helpers';
 import { startDevelopmentRender } from './component-dev';
 import supertest from 'supertest';
 import { Server } from 'http';

package/src/integration-tests/service-deployment.integration.spec.ts

@@ -14,25 +14,29 @@ interface HealthInfo {
 }
 
 describe('Verify latest services deployments', () => {
-  it('Should have latest Management API service', async () => {
+  it.skip('Should have latest Management API service', async () => {
     const response: HealthInfo = (await managementServiceRoot.get('/health')).data;
     expect(response.buildVersion).toBe(ci_buildVersion);
     expect(response.buildBranch).toBe(ci_buildBranch);
   });
 
   it('Should return 200 for Management API docs', async () => {
-    const req = await managementService.get('/docs');
+    const req = await managementService.get('/v1/docs', {
+      baseURL: managementService.defaults.baseURL?.replace(/v1\/?/, ''),
+    });
     expect(req.status).toBe(200);
     expect(req.headers['content-type']).toEqual('text/html; charset=utf-8');
   });
 
   it('Should return 200 for Management API docs.json', async () => {
-    const req = await managementService.get('/docs.json');
+    const req = await managementService.get('/static/v1/docs.json', {
+      baseURL: managementService.defaults.baseURL?.replace(/v1\/?/, ''),
+    });
     expect(req.status).toBe(200);
     expect(req.headers['content-type']).toEqual('application/json; charset=UTF-8');
   });
 
-  it('Should have latest Render Runtime service', async () => {
+  it.skip('Should have latest Render Runtime service', async () => {
     const response: HealthInfo = (await renderService.get('/health')).data;
     expect(response.buildVersion).toBe(ci_buildVersion);
     expect(response.buildBranch).toBe(ci_buildBranch);
@@ -45,12 +49,12 @@ describe('Verify latest services deployments', () => {
   });
 
   it('Should return 200 for Render Runtime API docs.json', async () => {
-    const req = await renderService.get('/docs.json');
+    const req = await renderService.get('/static/docs.json');
     expect(req.status).toBe(200);
     expect(req.headers['content-type']).toEqual('application/json; charset=UTF-8');
   });
 
-  it('Should have latest Content API service', async () => {
+  it.skip('Should have latest Content API service', async () => {
     const response: HealthInfo = (await contentService.get('/health')).data;
     expect(response.buildVersion).toBe(ci_buildVersion);
     expect(response.buildBranch).toBe(ci_buildBranch);
@@ -63,7 +67,7 @@ describe('Verify latest services deployments', () => {
   });
 
   it('Should return 200 for Content API docs.json', async () => {
-    const req = await contentService.get('/docs.json');
+    const req = await contentService.get('/static/docs.json');
     expect(req.status).toBe(200);
     expect(req.headers['content-type']).toEqual('application/json; charset=UTF-8');
   });

package/src/upload-component-folder.ts

@@ -13,6 +13,7 @@ import {
   handleResponse,
   isAxiosResponse,
   isUserInOrganization,
+  assertComponentTypeAllowed,
 } from './utils';
 
 export const logger: Logger = getLogger({ name: 'upload-component', format: 'human' });
@@ -35,6 +36,9 @@ export async function uploadComponentFolder(
     const manifestService = new ManifestServiceForDev(folderPath, logger);
     const manifestPath = path.join(folderPath, `manifest.json`);
     const manifest = await manifestService.readManifest(manifestPath);
+
+    await assertComponentTypeAllowed(manifest.type, apiClient, '/health', componentServiceManagementUrl);
+
     const shouldValidateNamespace = !isUserInOrganization();
     await manifestService.assertManifestIsValid(manifestPath, manifest.getModel(), {
       validateNamespace: shouldValidateNamespace,

package/src/upload-job.ts

@@ -1,7 +1,7 @@
 import { uploadFile } from '@squiz/virus-scanner-lib';
 
 import { zipDirectory } from '@squiz/dx-common-lib';
-import { ManifestServiceForDev, JobManifestV1Model } from '@squiz/component-lib';
+import { ManifestServiceForDev, JobManifestV1Model } from '@squiz/job-runner-lib';
 import fsp from 'fs/promises';
 import path from 'path';
 import { AxiosInstance } from 'axios';

package/src/utils.spec.ts

@@ -6,6 +6,7 @@ import {
   isAxiosError,
   isAxiosResponse,
   isUserInOrganization,
+  assertComponentTypeAllowed,
 } from './utils';
 import axios, { AxiosResponse, AxiosError } from 'axios';
 
@@ -46,7 +47,7 @@ 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' } } as AxiosResponse));
+      .mockImplementation(() => Promise.resolve({ data: { status: 'Success' }, status: 200 } as AxiosResponse));
 
     const res = await watchAndWaitForUploadAndScanComplete(jobService, '/upload-job/status/', '123');
     expect(res).toBeUndefined();
@@ -55,7 +56,7 @@ describe('cli lib utils watchAndWaitForUploadAndScanComplete', () => {
   it('should throw specific error if virus scan is flagged', async () => {
     jest
       .spyOn(jobService as any, `get`)
-      .mockImplementation(() => Promise.resolve({ data: { status: 'Flagged' } } as AxiosResponse));
+      .mockImplementation(() => Promise.resolve({ data: { status: 'Flagged' }, status: 200 } as AxiosResponse));
 
     await expect(async () => {
       await watchAndWaitForUploadAndScanComplete(jobService, '/upload-job/status/', '123');
@@ -65,7 +66,7 @@ describe('cli lib utils watchAndWaitForUploadAndScanComplete', () => {
   it('should throw generic error if virus scan is Error', async () => {
     jest
       .spyOn(jobService as any, `get`)
-      .mockImplementation(() => Promise.resolve({ data: { status: 'Error' } } as AxiosResponse));
+      .mockImplementation(() => Promise.resolve({ data: { status: 'Error' }, status: 200 } as AxiosResponse));
 
     await expect(async () => {
       await watchAndWaitForUploadAndScanComplete(jobService, '/upload-job/status/', '123');
@@ -75,11 +76,11 @@ describe('cli lib utils watchAndWaitForUploadAndScanComplete', () => {
   it('should poll until a result is received', async () => {
     jest
       .spyOn(jobService as any, `get`)
-      .mockImplementationOnce(() => Promise.resolve({ data: { status: 'Scanning' } } as AxiosResponse))
-      .mockImplementationOnce(() => Promise.resolve({ data: { status: 'Scanning' } } as AxiosResponse))
-      .mockImplementationOnce(() => Promise.resolve({ data: { status: 'Scanning' } } as AxiosResponse))
-      .mockImplementationOnce(() => Promise.resolve({ data: { status: 'Scanning' } } as AxiosResponse))
-      .mockImplementationOnce(() => Promise.resolve({ data: { status: 'Success' } } 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: '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();
@@ -142,6 +143,20 @@ describe('cli lib utils handleResponse', () => {
       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', () => {
@@ -234,3 +249,122 @@ describe('isUserInFooOrganization', () => {
     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,6 +1,7 @@
 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,
@@ -8,7 +9,7 @@ export async function watchAndWaitForUploadAndScanComplete(
   id: string,
   managementURL?: string,
 ): Promise<void> {
-  let poll: () => Promise<any>;
+  let poll: () => Promise<ScanStatus>;
   if (managementURL) {
     poll = () => handleResponse<ScanStatus>(apiClient.get(endpoint + id, { baseURL: managementURL }));
   } else {
@@ -64,7 +65,10 @@ export async function checkIfVersionExists(apiClient: AxiosInstance, endpoint: s
 export async function handleResponse<T>(axiosInstance: Promise<AxiosResponse<T>>): Promise<T> {
   try {
     const response = await axiosInstance;
-    return response.data;
+    if (response.status.toString().startsWith('2')) {
+      return response.data;
+    }
+    throw handleError(response.data);
   } catch (error) {
     throw handleError(error);
   }
@@ -76,7 +80,7 @@ export function handleError(error: any): Error {
   const newError = new Error(errorMessage || 'An error has occurred');
 
   if (isAxiosError(error)) {
-    const errorCode = response.status ?? 'unknown';
+    const errorCode = response?.status ?? 'unknown';
     if (response?.data?.message) {
       newError.message = `Unexpected response code ${errorCode}. ${response.data.message}`.trim();
     } else {
@@ -120,3 +124,26 @@ export function isUserInOrganization(organisationName: string = 'squiz'): boolea
 
   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/tsconfig.json

@@ -3,6 +3,8 @@
 
   "compilerOptions": {
     "outDir": "lib",
+    "moduleResolution": "node16",
+    "module": "Node16",
     "resolveJsonModule": true,
     "composite": true,
     "rootDir": "./src",