@superblocksteam/sabs-client 0.419.0 → 0.422.0

package/src/sabs.test.ts

@@ -1,1324 +0,0 @@
-import { ApplicationMetadata, BuildStatus, CreateLiveEditResponse, LiveEditStatus } from '@superblocksteam/sabs-types';
-import axios, { AxiosError, AxiosHeaders } from 'axios';
-
-import { SabsClient } from './sabs';
-
-describe('sabs service', () => {
-  let anyBuildKey: string;
-  let anyAccessToken: string;
-
-  beforeEach(() => {
-    anyBuildKey = 'any-secret-build-key';
-    anyAccessToken = 'any-access-token';
-  });
-
-  afterEach(() => {
-    jest.restoreAllMocks();
-  });
-
-  describe('build', () => {
-    test.each([{ accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } }])(
-      '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, accessToken: anyAccessToken })
-      ).rejects.toThrow();
-
-      expect(mockAxios).toHaveBeenCalledWith({
-        method: 'POST',
-        url: 'http://localhost:3000/v1/builds',
-        headers: { Authorization: `Bearer ${anyAccessToken}` },
-        data: {
-          directoryHash: anyDirectoryHash,
-          applicationMetadata: anyApplicationMetadata,
-          buildKey: anyBuildKey
-        }
-      });
-    });
-
-    test('raises error when directory hash is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      const anyApplicationMetadata = new ApplicationMetadata({
-        id: 'anyApplicationId',
-        organizationId: 'anyOrganizationId'
-      });
-      await expect(sabs.build({ directoryHash: '', meta: anyApplicationMetadata, buildKey: anyBuildKey })).rejects.toThrow();
-    });
-
-    test('raises error when application metadata is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.build({
-          directoryHash: '',
-          meta: undefined as unknown as ApplicationMetadata,
-          buildKey: anyBuildKey,
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when build key is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      const anyApplicationMetadata = new ApplicationMetadata({
-        id: 'anyApplicationId',
-        organizationId: 'anyOrganizationId'
-      });
-      await expect(
-        sabs.build({ directoryHash: 'anyDirectoryHash', meta: anyApplicationMetadata, buildKey: '', accessToken: anyAccessToken })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when application id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      const anyApplicationMetadata = new ApplicationMetadata({
-        id: '',
-        organizationId: 'anyOrganizationId'
-      });
-      await expect(
-        sabs.build({ directoryHash: 'anyDirectoryHash', meta: anyApplicationMetadata, buildKey: anyBuildKey, accessToken: anyAccessToken })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when organization id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      const anyApplicationMetadata = new ApplicationMetadata({
-        id: 'anyApplicationId',
-        organizationId: ''
-      });
-      await expect(
-        sabs.build({ directoryHash: 'anyDirectoryHash', meta: anyApplicationMetadata, buildKey: anyBuildKey, accessToken: anyAccessToken })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when access token is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      const anyApplicationMetadata = new ApplicationMetadata({
-        id: 'anyApplicationId',
-        organizationId: 'anyOrganizationId'
-      });
-      await expect(
-        sabs.build({ directoryHash: 'anyDirectoryHash', meta: anyApplicationMetadata, buildKey: anyBuildKey, accessToken: '' })
-      ).rejects.toThrow();
-    });
-  });
-
-  describe('status', () => {
-    test.each([{ accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } }])(
-      '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, accessToken: anyAccessToken })).rejects.toThrow();
-
-      expect(mockAxios).toHaveBeenCalledWith({
-        headers: { Authorization: `Bearer ${anyAccessToken}` },
-        method: 'GET',
-        url: `http://localhost:3000/v1/builds/${anyBuildId}`
-      });
-    });
-
-    test('raises error when build id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(sabs.status({ buildId: '', accessToken: anyAccessToken })).rejects.toThrow();
-    });
-
-    test('raises error when access token is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(sabs.status({ buildId: 'anyBuildId', accessToken: '' })).rejects.toThrow();
-    });
-  });
-
-  describe('list', () => {
-    test.each([{ accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } }])(
-      '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,
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-
-      expect(mockAxios).toHaveBeenCalledWith({
-        method: 'GET',
-        url: `http://localhost:3000/v1/build`,
-        headers: { Authorization: `Bearer ${anyAccessToken}` },
-        params: {
-          organizationId: anyOrganizationId,
-          applicationId: anyApplicationId,
-          directoryHash: anyDirectoryHash
-        }
-      });
-    });
-
-    test('raises error when organization id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.list({ organizationId: '', applicationId: 'anyApplicationId', directoryHash: 'anyDirectoryHash', accessToken: anyAccessToken })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when application id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.list({
-          organizationId: 'anyOrganizationId',
-          applicationId: '',
-          directoryHash: 'anyDirectoryHash',
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when directory hash is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.list({
-          organizationId: 'anyOrganizationId',
-          applicationId: 'anyApplicationId',
-          directoryHash: '',
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when access token is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.list({
-          organizationId: 'anyOrganizationId',
-          applicationId: 'anyApplicationId',
-          directoryHash: 'anyDirectoryHash',
-          accessToken: ''
-        })
-      ).rejects.toThrow();
-    });
-  });
-
-  describe('terminate', () => {
-    test.each([{ accessToken: 'anyScopedJwt', expectedHeaders: { Authorization: 'Bearer anyScopedJwt' } }])(
-      '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, accessToken: anyAccessToken })
-      ).rejects.toThrow();
-
-      expect(mockAxios).toHaveBeenCalledWith({
-        method: 'POST',
-        headers: { Authorization: `Bearer ${anyAccessToken}` },
-        url: `http://localhost:3000/v1/builds/${anyBuildId}/terminate`,
-        data: {
-          buildId: anyBuildId,
-          status: anyStatus,
-          error: anyError,
-          buildKey: anyBuildKey
-        }
-      });
-    });
-
-    test('raises error when build id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.terminate({
-          buildId: '',
-          status: BuildStatus.TIMED_OUT,
-          buildKey: anyBuildKey,
-          error: 'build timed out',
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when status is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.terminate({
-          buildId: 'anyBuildId',
-          status: undefined as unknown as BuildStatus,
-          buildKey: anyBuildKey,
-          error: 'build timed out',
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when build key is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.terminate({
-          buildId: 'anyBuildId',
-          status: BuildStatus.TIMED_OUT,
-          buildKey: '',
-          error: 'build timed out',
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when access token is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.terminate({
-          buildId: 'anyBuildId',
-          status: BuildStatus.TIMED_OUT,
-          buildKey: anyBuildKey,
-          error: 'build timed out',
-          accessToken: ''
-        })
-      ).rejects.toThrow();
-    });
-
-    test('includes stepTimings when provided', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockResolvedValue({
-        data: {
-          buildId: 'expectedBuildId',
-          status: BuildStatus.SUCCESS,
-          created: new Date(),
-          updated: new Date()
-        }
-      });
-
-      const stepTimings = {
-        createTempDirMs: 100,
-        fetchAppBundleMs: 200,
-        npmInstallMs: 300,
-        buildMs: 400,
-        uploadMs: 500
-      };
-
-      const sabs = new SabsClient('http://localhost:3000');
-      await sabs.terminate({
-        buildId: 'anyBuildId',
-        status: BuildStatus.SUCCESS,
-        buildKey: anyBuildKey,
-        stepTimings,
-        accessToken: anyAccessToken
-      });
-
-      expect(mockAxios).toHaveBeenCalledWith(
-        expect.objectContaining({
-          data: expect.objectContaining({
-            stepTimings: expect.objectContaining({
-              createTempDirMs: BigInt(100),
-              fetchAppBundleMs: BigInt(200),
-              npmInstallMs: BigInt(300),
-              buildMs: BigInt(400),
-              uploadMs: BigInt(500)
-            })
-          })
-        })
-      );
-    });
-
-    test('includes sizeMetrics when provided', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockResolvedValue({
-        data: {
-          buildId: 'expectedBuildId',
-          status: BuildStatus.SUCCESS,
-          created: new Date(),
-          updated: new Date()
-        }
-      });
-
-      const sizeMetrics = {
-        sourceBundleSizeBytes: 1000000,
-        nodeModulesSizeBytes: 50000000,
-        buildOutputSizeBytes: 2000000,
-        dependencyCount: 150
-      };
-
-      const sabs = new SabsClient('http://localhost:3000');
-      await sabs.terminate({
-        buildId: 'anyBuildId',
-        status: BuildStatus.SUCCESS,
-        buildKey: anyBuildKey,
-        sizeMetrics,
-        accessToken: anyAccessToken
-      });
-
-      expect(mockAxios).toHaveBeenCalledWith(
-        expect.objectContaining({
-          data: expect.objectContaining({
-            sizeMetrics: expect.objectContaining({
-              sourceBundleSizeBytes: BigInt(1000000),
-              nodeModulesSizeBytes: BigInt(50000000),
-              buildOutputSizeBytes: BigInt(2000000),
-              dependencyCount: BigInt(150)
-            })
-          })
-        })
-      );
-    });
-
-    test('includes both stepTimings and sizeMetrics when provided', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockResolvedValue({
-        data: {
-          buildId: 'expectedBuildId',
-          status: BuildStatus.SUCCESS,
-          created: new Date(),
-          updated: new Date()
-        }
-      });
-
-      const stepTimings = {
-        createTempDirMs: 100,
-        npmInstallMs: 300
-      };
-
-      const sizeMetrics = {
-        sourceBundleSizeBytes: 1000000,
-        dependencyCount: 150
-      };
-
-      const sabs = new SabsClient('http://localhost:3000');
-      await sabs.terminate({
-        buildId: 'anyBuildId',
-        status: BuildStatus.SUCCESS,
-        buildKey: anyBuildKey,
-        stepTimings,
-        sizeMetrics,
-        accessToken: anyAccessToken
-      });
-
-      expect(mockAxios).toHaveBeenCalledWith(
-        expect.objectContaining({
-          data: expect.objectContaining({
-            stepTimings: expect.objectContaining({
-              createTempDirMs: BigInt(100),
-              npmInstallMs: BigInt(300)
-            }),
-            sizeMetrics: expect.objectContaining({
-              sourceBundleSizeBytes: BigInt(1000000),
-              dependencyCount: BigInt(150)
-            })
-          })
-        })
-      );
-    });
-
-    test('handles partial sizeMetrics with undefined fields', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockResolvedValue({
-        data: {
-          buildId: 'expectedBuildId',
-          status: BuildStatus.SUCCESS,
-          created: new Date(),
-          updated: new Date()
-        }
-      });
-
-      const sizeMetrics = {
-        sourceBundleSizeBytes: 1000000
-        // Other fields intentionally undefined
-      };
-
-      const sabs = new SabsClient('http://localhost:3000');
-      await sabs.terminate({
-        buildId: 'anyBuildId',
-        status: BuildStatus.SUCCESS,
-        buildKey: anyBuildKey,
-        sizeMetrics,
-        accessToken: anyAccessToken
-      });
-
-      expect(mockAxios).toHaveBeenCalledWith(
-        expect.objectContaining({
-          data: expect.objectContaining({
-            sizeMetrics: expect.objectContaining({
-              sourceBundleSizeBytes: BigInt(1000000)
-            })
-          })
-        })
-      );
-    });
-  });
-
-  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,
-        accessToken: anyAccessToken
-      });
-
-      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',
-        headers: { Authorization: `Bearer ${anyAccessToken}` },
-        url: `http://localhost:3000/v1/builds/${anyOrganizationId}/${anyApplicationId}/bulk-status`,
-        data: {
-          organizationId: anyOrganizationId,
-          applicationId: anyApplicationId,
-          directoryHashes: anyDirectoryHashes
-        }
-      });
-    });
-
-    test('raises error when access token is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.bulkStatus({
-          organizationId: 'anyOrganizationId',
-          applicationId: 'anyApplicationId',
-          directoryHashes: ['anyDirectoryHash'],
-          accessToken: ''
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when organization id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.bulkStatus({
-          organizationId: '',
-          applicationId: 'anyApplicationId',
-          directoryHashes: ['anyDirectoryHash'],
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when application id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.bulkStatus({
-          organizationId: 'anyOrganizationId',
-          applicationId: '',
-          directoryHashes: ['anyDirectoryHash'],
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when directory hashes is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.bulkStatus({
-          organizationId: 'anyOrganizationId',
-          applicationId: 'anyApplicationId',
-          directoryHashes: [],
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-  });
-
-  describe('liveEdit', () => {
-    const applicationId = 'anyApplicationId';
-    const organizationId = 'anyOrganizationId';
-    const branch = 'anyBranch';
-
-    test('raises error when application id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.createLiveEdit({
-          applicationId: '',
-          organizationId: 'anyOrganizationId',
-          branch: 'anyBranch',
-          expiresIn: 1000,
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when organization id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.createLiveEdit({
-          applicationId: 'anyApplicationId',
-          organizationId: '',
-          branch: 'anyBranch',
-          expiresIn: 1000,
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when branch is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.createLiveEdit({
-          applicationId: 'anyApplicationId',
-          organizationId: 'anyOrganizationId',
-          branch: '',
-          expiresIn: 1000,
-          accessToken: anyAccessToken
-        })
-      ).rejects.toThrow();
-    });
-
-    test('raises error when access token is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(
-        sabs.createLiveEdit({
-          applicationId: 'anyApplicationId',
-          organizationId: 'anyOrganizationId',
-          branch: 'anyBranch',
-          expiresIn: 1000,
-          accessToken: ''
-        })
-      ).rejects.toThrow();
-    });
-
-    test('createLiveEdit', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      const expiresInSeconds = 1000;
-      const now = Date.now();
-      const expectedRequest = {
-        application: {
-          applicationId,
-          organizationId,
-          branch
-        },
-        expiresIn: BigInt(expiresInSeconds),
-        sessionJwt: anyAccessToken,
-        clientKey: ''
-      };
-      const newLiveEditResponse = new CreateLiveEditResponse({
-        liveEditId: 'liveEditId',
-        liveEditUrl: 'http://localhost:3000/live-edit/liveEditId',
-        application: {
-          applicationId,
-          organizationId,
-          branch
-        },
-        expiresAt: BigInt(now + expiresInSeconds * 1000)
-      });
-
-      mockAxios.mockResolvedValue({ data: newLiveEditResponse });
-
-      const sabs = new SabsClient('http://localhost:3000');
-      const result = await sabs.createLiveEdit({
-        applicationId,
-        organizationId,
-        branch,
-        expiresIn: expiresInSeconds,
-        accessToken: anyAccessToken
-      });
-
-      expect(result).toEqual(newLiveEditResponse);
-      expect(mockAxios).toHaveBeenCalledWith({
-        method: 'POST',
-        url: 'http://localhost:3000/v1/live-edit',
-        data: expectedRequest,
-        headers: {
-          Authorization: `Bearer ${anyAccessToken}`
-        }
-      });
-    });
-
-    test('createLiveEdit with clientKey', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      const expiresInSeconds = 1000;
-      const now = Date.now();
-      const clientKey = 'user-123';
-      const expectedRequest = {
-        application: {
-          applicationId,
-          organizationId,
-          branch
-        },
-        expiresIn: BigInt(expiresInSeconds),
-        sessionJwt: anyAccessToken,
-        clientKey: clientKey
-      };
-      const newLiveEditResponse = new CreateLiveEditResponse({
-        liveEditId: 'liveEditId',
-        liveEditUrl: 'http://localhost:3000/live-edit/liveEditId',
-        application: {
-          applicationId,
-          organizationId,
-          branch
-        },
-        expiresAt: BigInt(now + expiresInSeconds * 1000)
-      });
-
-      mockAxios.mockResolvedValue({ data: newLiveEditResponse });
-
-      const sabs = new SabsClient('http://localhost:3000');
-      const result = await sabs.createLiveEdit({
-        applicationId,
-        organizationId,
-        branch,
-        expiresIn: expiresInSeconds,
-        accessToken: anyAccessToken,
-        clientKey: clientKey
-      });
-
-      expect(result).toEqual(newLiveEditResponse);
-      expect(mockAxios).toHaveBeenCalledWith({
-        method: 'POST',
-        url: 'http://localhost:3000/v1/live-edit',
-        data: expectedRequest,
-        headers: {
-          Authorization: `Bearer ${anyAccessToken}`
-        }
-      });
-    });
-
-    test('terminateLiveEdit', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      const liveEditId = 'liveEditId';
-      const expectedRequest = { liveEditId };
-      const expectedCreated = new Date();
-      const expectedUpdated = new Date();
-      const expectedResponse = {
-        liveEditId,
-        status: LiveEditStatus.TERMINATED,
-        application: {
-          applicationId,
-          organizationId,
-          branch
-        },
-        created: expectedCreated,
-        updated: expectedUpdated
-      };
-
-      mockAxios.mockResolvedValue({ data: expectedResponse });
-
-      const sabs = new SabsClient('http://localhost:3000');
-      const result = await sabs.terminateLiveEdit({ liveEditId, accessToken: anyAccessToken });
-
-      expect(result).toEqual(expectedResponse);
-      expect(mockAxios).toHaveBeenCalledWith({
-        method: 'POST',
-        url: `http://localhost:3000/v1/live-edit/${liveEditId}/terminate`,
-        data: expectedRequest,
-        headers: {
-          Authorization: `Bearer ${anyAccessToken}`
-        }
-      });
-    });
-
-    test('raises error when live edit id is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(sabs.terminateLiveEdit({ liveEditId: '', accessToken: anyAccessToken })).rejects.toThrow();
-    });
-
-    test('raises error when access token is empty', async () => {
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(sabs.terminateLiveEdit({ liveEditId: 'liveEditId', accessToken: '' })).rejects.toThrow();
-    });
-
-    test('terminateLiveEdit raises error when request fails', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockRejectedValue(new Error('any error'));
-
-      const liveEditId = 'liveEditId';
-
-      const sabs = new SabsClient('http://localhost:3000');
-      await expect(sabs.terminateLiveEdit({ liveEditId, accessToken: anyAccessToken })).rejects.toThrow();
-
-      expect(mockAxios).toHaveBeenCalledWith({
-        method: 'POST',
-        url: `http://localhost:3000/v1/live-edit/${liveEditId}/terminate`,
-        data: {
-          liveEditId
-        },
-        headers: {
-          Authorization: `Bearer ${anyAccessToken}`
-        }
-      });
-    });
-  });
-
-  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 sabs = new SabsClient('http://localhost:3000');
-      await expect(sabs.status({ buildId: anyBuildId, accessToken: anyAccessToken })).rejects.toThrow();
-    });
-
-    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 sabs = new SabsClient('http://localhost:3000');
-      await expect(sabs.status({ buildId: anyBuildId, accessToken: anyAccessToken })).rejects.toThrow();
-    });
-  });
-
-  describe('backward compatibility', () => {
-    test('errors can be caught as generic Error instances (backward compatibility)', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockRejectedValue(
-        new AxiosError('Service unavailable', 'ECONNREFUSED', undefined, undefined, {
-          headers: {},
-          config: {
-            headers: new AxiosHeaders()
-          },
-          status: 503,
-          statusText: 'Service Unavailable',
-          data: { message: 'Server temporarily unavailable' }
-        })
-      );
-
-      const sabs = new SabsClient('http://localhost:3000');
-      const applicationId = 'test-app';
-      const organizationId = 'test-org';
-      const directoryHash = 'abc123';
-
-      // This simulates how existing applications might handle errors
-      try {
-        const result = await sabs.build({
-          directoryHash,
-          meta: new ApplicationMetadata({
-            id: applicationId,
-            organizationId
-          }),
-          buildKey: anyBuildKey,
-          accessToken: anyAccessToken
-        });
-
-        // Should not reach here
-        expect(result).toBeUndefined();
-      } catch (error) {
-        // Legacy error handling - should still work with new error types
-        expect(error).toBeInstanceOf(Error);
-        expect(error.message).toContain('SABS API Error (503)');
-
-        // Verify we can still access basic Error properties
-        expect(typeof error.message).toBe('string');
-        expect(error.name).toBeDefined();
-
-        // This is how existing code might log and re-throw
-        const loggedError = {
-          error,
-          applicationId,
-          organizationId,
-          directoryHash,
-          message: error.message
-        };
-
-        expect(loggedError.error).toBe(error);
-        expect(loggedError.message).toBe(error.message);
-
-        // Re-throwing as generic Error should work
-        expect(() => {
-          throw new Error('Unable to launch build');
-        }).toThrow('Unable to launch build');
-      }
-    });
-
-    test('new error types provide additional functionality when accessed', async () => {
-      const mockAxios = jest.spyOn(axios, 'request');
-      mockAxios.mockRejectedValue(
-        new AxiosError('Unauthorized', 'UNAUTHORIZED', undefined, undefined, {
-          headers: {},
-          config: {
-            headers: new AxiosHeaders()
-          },
-          status: 401,
-          statusText: 'Unauthorized',
-          data: { message: 'Invalid token' }
-        })
-      );
-
-      const sabs = new SabsClient('http://localhost:3000');
-
-      try {
-        await sabs.status({ buildId: 'test-build', accessToken: 'invalid-token' });
-      } catch (error) {
-        // Backward compatible - can still catch as Error
-        expect(error).toBeInstanceOf(Error);
-
-        // But applications can now also check for specific error types
-        const { UnauthorizedError } = await import('./errors');
-        expect(error).toBeInstanceOf(UnauthorizedError);
-
-        // And access the status code if needed
-        if ('status' in error) {
-          expect(error.status).toBe(401);
-        }
-      }
-    });
-
-    describe('response data handling', () => {
-      test('handles responseData with message property', async () => {
-        const mockAxios = jest.spyOn(axios, 'request');
-        mockAxios.mockRejectedValue(
-          new AxiosError('Bad Request', 'BAD_REQUEST', undefined, undefined, {
-            headers: {},
-            config: {
-              headers: new AxiosHeaders()
-            },
-            status: 400,
-            statusText: 'Bad Request',
-            data: { message: 'Directory hash is required' }
-          })
-        );
-
-        const sabs = new SabsClient('http://localhost:3000');
-
-        try {
-          await sabs.build({
-            directoryHash: 'test', // Use non-empty value to avoid client-side validation
-            meta: new ApplicationMetadata({ id: 'test', organizationId: 'test' }),
-            buildKey: 'test',
-            accessToken: 'test'
-          });
-        } catch (error) {
-          expect(error).toBeInstanceOf(Error);
-          expect(error.message).toBe('SABS API Error (400): Directory hash is required');
-        }
-      });
-
-      test('handles responseData as string', async () => {
-        const mockAxios = jest.spyOn(axios, 'request');
-        mockAxios.mockRejectedValue(
-          new AxiosError('Internal Server Error', 'INTERNAL_SERVER_ERROR', undefined, undefined, {
-            headers: {},
-            config: {
-              headers: new AxiosHeaders()
-            },
-            status: 500,
-            statusText: 'Internal Server Error',
-            data: 'Database connection failed'
-          })
-        );
-
-        const sabs = new SabsClient('http://localhost:3000');
-
-        try {
-          await sabs.build({
-            directoryHash: 'test',
-            meta: new ApplicationMetadata({ id: 'test', organizationId: 'test' }),
-            buildKey: 'test',
-            accessToken: 'test'
-          });
-        } catch (error) {
-          expect(error).toBeInstanceOf(Error);
-          expect(error.message).toBe('SABS API Error (500): Database connection failed');
-        }
-      });
-
-      test('handles null responseData', async () => {
-        const mockAxios = jest.spyOn(axios, 'request');
-        mockAxios.mockRejectedValue(
-          new AxiosError('Service Unavailable', 'SERVICE_UNAVAILABLE', undefined, undefined, {
-            headers: {},
-            config: {
-              headers: new AxiosHeaders()
-            },
-            status: 503,
-            statusText: 'Service Unavailable',
-            data: null
-          })
-        );
-
-        const sabs = new SabsClient('http://localhost:3000');
-
-        try {
-          await sabs.build({
-            directoryHash: 'test',
-            meta: new ApplicationMetadata({ id: 'test', organizationId: 'test' }),
-            buildKey: 'test',
-            accessToken: 'test'
-          });
-        } catch (error) {
-          expect(error).toBeInstanceOf(Error);
-          expect(error.message).toBe('SABS API Error (503): Service Unavailable (503)');
-        }
-      });
-
-      test('handles undefined responseData', async () => {
-        const mockAxios = jest.spyOn(axios, 'request');
-        mockAxios.mockRejectedValue(
-          new AxiosError('Gateway Timeout', 'GATEWAY_TIMEOUT', undefined, undefined, {
-            headers: {},
-            config: {
-              headers: new AxiosHeaders()
-            },
-            status: 504,
-            statusText: 'Gateway Timeout',
-            data: undefined
-          })
-        );
-
-        const sabs = new SabsClient('http://localhost:3000');
-
-        try {
-          await sabs.build({
-            directoryHash: 'test',
-            meta: new ApplicationMetadata({ id: 'test', organizationId: 'test' }),
-            buildKey: 'test',
-            accessToken: 'test'
-          });
-        } catch (error) {
-          expect(error).toBeInstanceOf(Error);
-          expect(error.message).toBe('SABS API Error (504): Gateway Timeout (504)');
-        }
-      });
-
-      test('handles responseData object without message property', async () => {
-        const mockAxios = jest.spyOn(axios, 'request');
-        mockAxios.mockRejectedValue(
-          new AxiosError('Bad Request', 'BAD_REQUEST', undefined, undefined, {
-            headers: {},
-            config: {
-              headers: new AxiosHeaders()
-            },
-            status: 400,
-            statusText: 'Bad Request',
-            data: { error: 'validation_failed', details: ['field is required'] }
-          })
-        );
-
-        const sabs = new SabsClient('http://localhost:3000');
-
-        try {
-          await sabs.build({
-            directoryHash: 'test',
-            meta: new ApplicationMetadata({ id: 'test', organizationId: 'test' }),
-            buildKey: 'test',
-            accessToken: 'test'
-          });
-        } catch (error) {
-          expect(error).toBeInstanceOf(Error);
-          expect(error.message).toBe('SABS API Error (400): Bad Request (400)');
-        }
-      });
-
-      test('all errors have consistent HttpError interface', async () => {
-        const responseData = { code: 'TIMEOUT', retryAfter: 30 };
-        const mockAxios = jest.spyOn(axios, 'request');
-        mockAxios.mockRejectedValue(
-          new AxiosError('Request timeout', 'TIMEOUT', undefined, undefined, {
-            headers: {},
-            config: {
-              headers: new AxiosHeaders()
-            },
-            status: 500,
-            statusText: 'Internal Server Error',
-            data: responseData
-          })
-        );
-
-        const sabs = new SabsClient('http://localhost:3000');
-
-        try {
-          await sabs.build({
-            directoryHash: 'test',
-            meta: new ApplicationMetadata({ id: 'test', organizationId: 'test' }),
-            buildKey: 'test',
-            accessToken: 'test'
-          });
-        } catch (error) {
-          expect(error).toBeInstanceOf(Error);
-          expect(error.message).toBe('SABS API Error (500): Internal Server Error (500)');
-
-          // All error types now have consistent HttpError interface
-          expect('status' in error).toBe(true);
-          expect('title' in error).toBe(true);
-          if ('status' in error) {
-            expect(error.status).toBe(500);
-          }
-          if ('title' in error) {
-            expect(error.title).toBe('Internal server error');
-          }
-        }
-      });
-    });
-  });
-});