@superblocksteam/sabs-client 0.127.0

package/src/sabs.test.ts

@@ -0,0 +1,423 @@
+import { ApplicationMetadata, BuildStatus } from '@superblocksteam/sabs-types';
+import axios, { AxiosError, AxiosHeaders } from 'axios';
+
+import { SabsClient } from './sabs';
+
+describe('sabs service', () => {
+  let anyBuildKey: string;
+
+  beforeEach(() => {
+    anyBuildKey = 'any-secret-build-key';
+  });
+
+  afterEach(() => {
+    jest.restoreAllMocks();
+  });
+
+  describe('build', () => {
+    test.each([
+      { accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } },
+      { accessToken: undefined, expectedHeaders: undefined }
+    ])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
+      const expectedBuildId = 'expectedBuildId';
+      const expectedCreated = new Date();
+      const expectedUpdated = new Date();
+
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockResolvedValue({
+        data: {
+          buildId: expectedBuildId,
+          created: expectedCreated,
+          updated: expectedUpdated
+        }
+      });
+
+      const anyDirectoryHash = 'anyDirectoryHash';
+      const anyApplicationMetadata = new ApplicationMetadata({
+        id: 'anyApplicationId',
+        organizationId: 'anyOrganizationId'
+      });
+
+      const sabs = new SabsClient('http://localhost:3000');
+      const result = await sabs.build({
+        directoryHash: anyDirectoryHash,
+        meta: anyApplicationMetadata,
+        buildKey: anyBuildKey,
+        accessToken
+      });
+
+      expect(result).toEqual({
+        buildId: expectedBuildId,
+        created: expectedCreated,
+        updated: expectedUpdated
+      });
+      expect(mockAxios).toHaveBeenCalledWith({
+        method: 'POST',
+        url: 'http://localhost:3000/v1/builds',
+        headers: expectedHeaders,
+        data: {
+          directoryHash: anyDirectoryHash,
+          applicationMetadata: anyApplicationMetadata,
+          buildKey: anyBuildKey
+        }
+      });
+    });
+
+    test('raises error when request fails', async () => {
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockRejectedValue(new Error('any error'));
+
+      const anyDirectoryHash = 'anyDirectoryHash';
+      const anyApplicationMetadata = new ApplicationMetadata({
+        id: 'anyApplicationId',
+        organizationId: 'anyOrganizationId'
+      });
+
+      const sabs = new SabsClient('http://localhost:3000');
+      await expect(sabs.build({ directoryHash: anyDirectoryHash, meta: anyApplicationMetadata, buildKey: anyBuildKey })).rejects.toThrow();
+
+      expect(mockAxios).toHaveBeenCalledWith({
+        method: 'POST',
+        url: 'http://localhost:3000/v1/builds',
+        data: {
+          directoryHash: anyDirectoryHash,
+          applicationMetadata: anyApplicationMetadata,
+          buildKey: anyBuildKey
+        }
+      });
+    });
+  });
+
+  describe('status', () => {
+    test.each([
+      { accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } },
+      { accessToken: undefined, expectedHeaders: undefined }
+    ])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
+      const expectedBuildId = 'expectedBuildId';
+      const expectedStatus = BuildStatus.SUCCESS;
+      const expectedCreated = new Date();
+      const expectedUpdated = new Date();
+
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockResolvedValue({
+        data: {
+          buildId: expectedBuildId,
+          status: expectedStatus,
+          created: expectedCreated,
+          updated: expectedUpdated
+        }
+      });
+
+      const anyBuildId = 'anyBuildId';
+
+      const sabs = new SabsClient('http://localhost:3000');
+      const result = await sabs.status({ buildId: anyBuildId, accessToken });
+
+      expect(result).toEqual({
+        buildId: expectedBuildId,
+        status: expectedStatus,
+        created: expectedCreated,
+        updated: expectedUpdated
+      });
+      expect(mockAxios).toHaveBeenCalledWith({
+        method: 'GET',
+        url: `http://localhost:3000/v1/builds/${anyBuildId}`,
+        headers: expectedHeaders
+      });
+    });
+
+    test('raises error when request fails', async () => {
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockRejectedValue(new Error('any error'));
+
+      const anyBuildId = 'anyBuildId';
+
+      const sabs = new SabsClient('http://localhost:3000');
+      await expect(sabs.status({ buildId: anyBuildId })).rejects.toThrow();
+
+      expect(mockAxios).toHaveBeenCalledWith({
+        method: 'GET',
+        url: `http://localhost:3000/v1/builds/${anyBuildId}`
+      });
+    });
+  });
+
+  describe('list', () => {
+    test.each([
+      { accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } },
+      { accessToken: undefined, expectedHeaders: undefined }
+    ])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockResolvedValue({
+        data: {
+          builds: [
+            {
+              buildId: 'id1',
+              status: BuildStatus.SUCCESS,
+              created: new Date('2023-01-01'),
+              updated: new Date('2023-01-02')
+            },
+            {
+              buildId: 'id2',
+              status: BuildStatus.RUNNING,
+              created: new Date('2023-01-03'),
+              updated: new Date('2023-01-04')
+            },
+            {
+              buildId: 'id3',
+              status: BuildStatus.FAILED,
+              error: 'Build failed',
+              created: new Date('2023-01-05'),
+              updated: new Date('2023-01-06')
+            }
+          ]
+        }
+      });
+
+      const anyOrganizationId = 'anyOrganizationId';
+      const anyApplicationId = 'anyApplicationId';
+      const anyDirectoryHash = 'anyDirectoryHash';
+
+      const sabs = new SabsClient('http://localhost:3000');
+      const result = await sabs.list({
+        organizationId: anyOrganizationId,
+        applicationId: anyApplicationId,
+        directoryHash: anyDirectoryHash,
+        accessToken
+      });
+
+      expect(result).toEqual({
+        builds: [
+          {
+            buildId: 'id1',
+            status: BuildStatus.SUCCESS,
+            created: new Date('2023-01-01'),
+            updated: new Date('2023-01-02')
+          },
+          {
+            buildId: 'id2',
+            status: BuildStatus.RUNNING,
+            created: new Date('2023-01-03'),
+            updated: new Date('2023-01-04')
+          },
+          {
+            buildId: 'id3',
+            status: BuildStatus.FAILED,
+            error: 'Build failed',
+            created: new Date('2023-01-05'),
+            updated: new Date('2023-01-06')
+          }
+        ]
+      });
+      expect(mockAxios).toHaveBeenCalledWith({
+        method: 'GET',
+        url: `http://localhost:3000/v1/build`,
+        headers: expectedHeaders,
+        params: {
+          organizationId: anyOrganizationId,
+          applicationId: anyApplicationId,
+          directoryHash: anyDirectoryHash
+        }
+      });
+    });
+
+    test('raises error when request fails', async () => {
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockRejectedValue(new Error('any error'));
+
+      const anyOrganizationId = 'anyOrganizationId';
+      const anyApplicationId = 'anyApplicationId';
+      const anyDirectoryHash = 'anyDirectoryHash';
+
+      const sabs = new SabsClient('http://localhost:3000');
+      await expect(
+        sabs.list({
+          organizationId: anyOrganizationId,
+          applicationId: anyApplicationId,
+          directoryHash: anyDirectoryHash
+        })
+      ).rejects.toThrow();
+
+      expect(mockAxios).toHaveBeenCalledWith({
+        method: 'GET',
+        url: `http://localhost:3000/v1/build`,
+        headers: undefined,
+        params: {
+          organizationId: anyOrganizationId,
+          applicationId: anyApplicationId,
+          directoryHash: anyDirectoryHash
+        }
+      });
+    });
+  });
+
+  describe('terminate', () => {
+    test.each([
+      { accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } },
+      { accessToken: undefined, expectedHeaders: undefined }
+    ])('returns expected response with accessToken=$accessToken', async ({ accessToken, expectedHeaders }) => {
+      const expectedBuildId = 'expectedBuildId';
+      const expectedStatus = BuildStatus.TIMED_OUT;
+      const expectedError = 'build timed out';
+      const expectedCreated = new Date();
+      const expectedUpdated = new Date();
+
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockResolvedValue({
+        data: {
+          buildId: expectedBuildId,
+          status: expectedStatus,
+          error: expectedError,
+          created: expectedCreated,
+          updated: expectedUpdated
+        }
+      });
+
+      const anyBuildId = 'anyBuildId';
+      const anyStatus = BuildStatus.TIMED_OUT;
+      const anyError = 'build timed out';
+
+      const sabs = new SabsClient('http://localhost:3000');
+      const result = await sabs.terminate({ buildId: anyBuildId, status: anyStatus, buildKey: anyBuildKey, error: anyError, accessToken });
+
+      expect(result).toEqual({
+        buildId: expectedBuildId,
+        status: expectedStatus,
+        error: expectedError,
+        created: expectedCreated,
+        updated: expectedUpdated
+      });
+      expect(mockAxios).toHaveBeenCalledWith({
+        method: 'POST',
+        url: `http://localhost:3000/v1/builds/${anyBuildId}/terminate`,
+        headers: expectedHeaders,
+        data: {
+          buildId: anyBuildId,
+          status: anyStatus,
+          error: anyError,
+          buildKey: anyBuildKey
+        }
+      });
+    });
+
+    test('raises error when request fails', async () => {
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockRejectedValue(new Error('any error'));
+
+      const anyBuildId = 'anyBuildId';
+      const anyStatus = BuildStatus.TIMED_OUT;
+      const anyError = 'build timed out';
+
+      const sabs = new SabsClient('http://localhost:3000');
+      await expect(sabs.terminate({ buildId: anyBuildId, status: anyStatus, buildKey: anyBuildKey, error: anyError })).rejects.toThrow();
+
+      expect(mockAxios).toHaveBeenCalledWith({
+        method: 'POST',
+        url: `http://localhost:3000/v1/builds/${anyBuildId}/terminate`,
+        data: {
+          buildId: anyBuildId,
+          status: anyStatus,
+          error: anyError,
+          buildKey: anyBuildKey
+        }
+      });
+    });
+  });
+
+  describe('bulkStatus', () => {
+    test('returns expected response', async () => {
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockResolvedValue({
+        data: {
+          builds: [
+            {
+              buildId: 'build1',
+              status: BuildStatus.SUCCESS,
+              created: new Date('2023-01-01'),
+              updated: new Date('2023-01-02')
+            },
+            {
+              buildId: 'build2',
+              status: BuildStatus.RUNNING,
+              created: new Date('2023-01-03'),
+              updated: new Date('2023-01-04')
+            }
+          ]
+        }
+      });
+
+      const anyOrganizationId = 'anyOrganizationId';
+      const anyApplicationId = 'anyApplicationId';
+      const anyDirectoryHashes = ['hash1', 'hash2'];
+
+      const sabs = new SabsClient('http://localhost:3000');
+      const result = await sabs.bulkStatus({
+        organizationId: anyOrganizationId,
+        applicationId: anyApplicationId,
+        directoryHashes: anyDirectoryHashes
+      });
+
+      expect(result).toEqual({
+        builds: [
+          {
+            buildId: 'build1',
+            status: BuildStatus.SUCCESS,
+            created: new Date('2023-01-01'),
+            updated: new Date('2023-01-02')
+          },
+          {
+            buildId: 'build2',
+            status: BuildStatus.RUNNING,
+            created: new Date('2023-01-03'),
+            updated: new Date('2023-01-04')
+          }
+        ]
+      });
+      expect(mockAxios).toHaveBeenCalledWith({
+        method: 'POST',
+        url: `http://localhost:3000/v1/builds/${anyOrganizationId}/${anyApplicationId}/bulk-status`,
+        data: {
+          organizationId: anyOrganizationId,
+          applicationId: anyApplicationId,
+          directoryHashes: anyDirectoryHashes
+        }
+      });
+    });
+  });
+
+  describe('executeRequest', () => {
+    test('raies expected error when error is axios error', async () => {
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockRejectedValue(
+        new AxiosError('request failed', 'internal', undefined, undefined, {
+          headers: {},
+          config: {
+            headers: new AxiosHeaders()
+          },
+          status: 500,
+          statusText: 'internal server error',
+          data: 'failed to process request'
+        })
+      );
+
+      const anyBuildId = 'anyBuildId';
+
+      const expectedError = 'sabs service request failed: request failed\n[500] internal server error: "failed to process request"';
+
+      const sabs = new SabsClient('http://localhost:3000');
+      await expect(sabs.status({ buildId: anyBuildId })).rejects.toThrow(expectedError);
+    });
+
+    test('re-raises error when error is not axios error', async () => {
+      const mockAxios = jest.spyOn(axios, 'request');
+      mockAxios.mockRejectedValue(new Error('unexpected error'));
+
+      const anyBuildId = 'anyBuildId';
+
+      const expectedError = 'sabs service request failed: unexpected error';
+
+      const sabs = new SabsClient('http://localhost:3000');
+      await expect(sabs.status({ buildId: anyBuildId })).rejects.toThrow(expectedError);
+    });
+  });
+});

package/src/sabs.ts

@@ -0,0 +1,203 @@
+import {
+  ApplicationMetadata,
+  BuildRequest,
+  BuildResponse,
+  BuildStatus,
+  ListRequest,
+  ListResponse,
+  StatusResponse,
+  TerminateRequest,
+  TerminateResponse,
+  BulkStatusRequest,
+  BulkStatusResponse,
+  CreateLiveEditRequest,
+  CreateLiveEditResponse
+} from '@superblocksteam/sabs-types';
+import axios, { AxiosRequestConfig, RawAxiosRequestHeaders } from 'axios';
+
+export class SabsClient {
+  private readonly baseUrl: string;
+
+  public constructor(baseUrl: string) {
+    this.baseUrl = baseUrl;
+  }
+
+  public async build({
+    directoryHash,
+    meta,
+    buildKey,
+    accessToken
+  }: {
+    directoryHash: string;
+    meta: ApplicationMetadata;
+    buildKey: string;
+    accessToken?: string;
+  }): Promise<BuildResponse> {
+    const data = new BuildRequest({
+      directoryHash: directoryHash,
+      applicationMetadata: meta,
+      buildKey
+    });
+
+    return this.executeRequest<BuildResponse>(
+      {
+        method: 'POST',
+        url: `${this.baseUrl}/v1/builds`,
+        data
+      },
+      accessToken
+    );
+  }
+
+  public async status({ buildId, accessToken }: { buildId: string; accessToken?: string }): Promise<StatusResponse> {
+    return this.executeRequest<StatusResponse>(
+      {
+        method: 'GET',
+        url: `${this.baseUrl}/v1/builds/${buildId}`
+      },
+      accessToken
+    );
+  }
+
+  public async bulkStatus({
+    organizationId,
+    applicationId,
+    directoryHashes,
+    accessToken
+  }: {
+    organizationId: string;
+    applicationId: string;
+    directoryHashes: string[];
+    accessToken?: string;
+  }): Promise<BulkStatusResponse> {
+    const data = new BulkStatusRequest({
+      organizationId,
+      applicationId,
+      directoryHashes
+    });
+
+    return this.executeRequest<BulkStatusResponse>(
+      {
+        method: 'POST',
+        url: `${this.baseUrl}/v1/builds/${organizationId}/${applicationId}/bulk-status`,
+        data
+      },
+      accessToken
+    );
+  }
+
+  public async list({
+    organizationId,
+    applicationId,
+    directoryHash,
+    accessToken
+  }: {
+    organizationId: string;
+    applicationId: string;
+    directoryHash: string;
+    accessToken?: string;
+  }): Promise<ListResponse> {
+    const data = new ListRequest({
+      organizationId,
+      applicationId,
+      directoryHash
+    });
+
+    return this.executeRequest<ListResponse>(
+      {
+        method: 'GET',
+        url: `${this.baseUrl}/v1/build`,
+        params: data
+      },
+      accessToken
+    );
+  }
+
+  public async terminate({
+    buildId,
+    status,
+    buildKey,
+    error,
+    accessToken
+  }: {
+    buildId: string;
+    status: BuildStatus;
+    buildKey?: string;
+    error?: string;
+    accessToken?: string;
+  }): Promise<TerminateResponse> {
+    const data = new TerminateRequest({
+      buildId,
+      status,
+      error,
+      buildKey
+    });
+
+    return this.executeRequest<TerminateResponse>(
+      {
+        method: 'POST',
+        url: `${this.baseUrl}/v1/builds/${buildId}/terminate`,
+        data
+      },
+      accessToken
+    );
+  }
+
+  public async createLiveEdit({
+    applicationId,
+    organizationId,
+    branch,
+    expiresIn,
+    accessToken
+  }: {
+    applicationId: string;
+    organizationId: string;
+    branch: string;
+    expiresIn: number;
+    accessToken: string;
+  }): Promise<CreateLiveEditResponse> {
+    const data = new CreateLiveEditRequest({
+      application: {
+        applicationId,
+        organizationId: organizationId,
+        branch: branch
+      },
+      sessionJwt: accessToken,
+      expiresIn: BigInt(expiresIn)
+    });
+
+    return this.executeRequest<CreateLiveEditResponse>(
+      {
+        method: 'POST',
+        url: `${this.baseUrl}/v1/live-edit`,
+        data
+      },
+      accessToken
+    );
+  }
+
+  private async executeRequest<T>(config: AxiosRequestConfig, accessToken?: string): Promise<T> {
+    let headers: RawAxiosRequestHeaders | undefined;
+    if (accessToken || config.headers) {
+      headers = {
+        ...config.headers,
+        Authorization: accessToken ? `Bearer ${accessToken}` : undefined
+      };
+    }
+
+    try {
+      const response = await axios.request<T>({
+        ...config,
+        headers
+      });
+      return response.data;
+    } catch (error) {
+      let errMsg = `sabs service request failed: ${error.message}`;
+      if (axios.isAxiosError(error)) {
+        errMsg += `\n[${error.response?.status}] ${error.response?.statusText}: ${JSON.stringify(error.response?.data)}`;
+      }
+
+      throw new Error(errMsg);
+    }
+  }
+}

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "commonjs",
+    "composite": true,
+    "incremental": true,
+    "declaration": true,
+    "declarationMap": true,
+    "sourceMap": true,
+    "moduleResolution": "node",
+    "esModuleInterop": true,
+    "resolveJsonModule": true,
+    "rootDir": "./src",
+    "outDir": "./dist",
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true,
+    "strictNullChecks": true,
+    "allowJs": false,
+    "skipLibCheck": true
+  },
+  "exclude": ["./dist", "./node_modules"],
+  "include": ["./**/*.ts"]
+}

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "rootDir": ".",
+    "noEmit": true
+  },
+  "include": ["./test/**/*.ts", "./src/**/*.ts", "./*.config.js", "./src/**/*.json"],
+  "exclude": ["node_modules"]
+}