@brimble/sandbox 0.1.0 → 0.1.1

package/test/unit/transport.test.ts

@@ -1,126 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-
-import { SDK_PACKAGE_VERSION } from '../../src/constants';
-import { AuthError, NotFoundError, RateLimitError, ValidationError } from '../../src/errors';
-import { HttpTransport } from '../../src/transport/http';
-
-function createJsonResponse(payload: unknown, status = 200, headers: Record<string, string> = {}): Response {
-  return new Response(JSON.stringify(payload), {
-    status,
-    headers: {
-      'content-type': 'application/json',
-      ...headers,
-    },
-  });
-}
-
-describe('HttpTransport', () => {
-  test('unwraps JSON response envelope data', async () => {
-    const fetchImpl = vi.fn(async () => createJsonResponse({ message: 'ok', data: { id: 'sandbox-1' } })) as typeof fetch;
-
-    const transport = new HttpTransport({
-      baseUrl: 'https://sandbox.brimble.io',
-      apiKey: 'test-key',
-      fetchImpl,
-    });
-
-    const result = await transport.requestJson<{ id: string }>({
-      endpoint: '/sandboxes/sandbox-1',
-      method: 'GET',
-    });
-
-    expect(result).toEqual({ id: 'sandbox-1' });
-  });
-
-  test('returns undefined for HTTP 204', async () => {
-    const fetchImpl = vi.fn(async () => new Response(null, { status: 204 })) as typeof fetch;
-
-    const transport = new HttpTransport({
-      baseUrl: 'https://sandbox.brimble.io',
-      apiKey: 'test-key',
-      fetchImpl,
-    });
-
-    const result = await transport.requestJson({
-      endpoint: '/sandboxes/sandbox-1',
-      method: 'DELETE',
-    });
-
-    expect(result).toBeUndefined();
-  });
-
-  test('sends SDK tracing and auth headers', async () => {
-    let seenAuthHeader: string | null = null;
-    let seenSourceHeader: string | null = null;
-    let seenSourceVersionHeader: string | null = null;
-
-    const fetchImpl = vi.fn(async (_url: URL | RequestInfo, init?: RequestInit) => {
-      const headers = new Headers(init?.headers);
-      seenAuthHeader = headers.get('x-brimble-key');
-      seenSourceHeader = headers.get('source');
-      seenSourceVersionHeader = headers.get('source-version');
-      return createJsonResponse({ message: 'ok', data: { regions: [] } });
-    }) as typeof fetch;
-
-    const transport = new HttpTransport({
-      baseUrl: 'https://sandbox.brimble.io',
-      apiKey: 'header-test-key',
-      fetchImpl,
-    });
-
-    await transport.requestJson({ endpoint: '/sandboxes/regions', method: 'GET' });
-
-    expect(seenAuthHeader).toBe('header-test-key');
-    expect(seenSourceHeader).toBe('sdk-package');
-    expect(seenSourceVersionHeader).toBe(SDK_PACKAGE_VERSION);
-  });
-
-  test('maps auth and validation errors to typed errors', async () => {
-    const authFetch = vi.fn(async () => createJsonResponse({ message: 'forbidden' }, 403)) as typeof fetch;
-    const validationFetch = vi.fn(async () => createJsonResponse({ message: 'bad input' }, 400)) as typeof fetch;
-
-    const authTransport = new HttpTransport({
-      baseUrl: 'https://sandbox.brimble.io',
-      apiKey: 'test-key',
-      fetchImpl: authFetch,
-    });
-
-    const validationTransport = new HttpTransport({
-      baseUrl: 'https://sandbox.brimble.io',
-      apiKey: 'test-key',
-      fetchImpl: validationFetch,
-    });
-
-    await expect(authTransport.requestJson({ endpoint: '/sandboxes', method: 'GET' })).rejects.toBeInstanceOf(AuthError);
-    await expect(validationTransport.requestJson({ endpoint: '/volumes', method: 'POST' })).rejects.toBeInstanceOf(ValidationError);
-  });
-
-  test('maps not-found and rate-limit responses to typed errors', async () => {
-    const notFoundFetch = vi.fn(async () => createJsonResponse({ message: 'missing' }, 404)) as typeof fetch;
-    const rateLimitFetch = vi.fn(async () => createJsonResponse({ message: 'slow down' }, 429, { 'retry-after': '3' })) as typeof fetch;
-
-    const notFoundTransport = new HttpTransport({
-      baseUrl: 'https://sandbox.brimble.io',
-      apiKey: 'test-key',
-      fetchImpl: notFoundFetch,
-    });
-
-    const rateLimitTransport = new HttpTransport({
-      baseUrl: 'https://sandbox.brimble.io',
-      apiKey: 'test-key',
-      fetchImpl: rateLimitFetch,
-    });
-
-    const notFoundError = await notFoundTransport
-      .requestJson({ endpoint: '/sandboxes/missing', method: 'GET' })
-      .catch((error) => error);
-    const rateLimitError = await rateLimitTransport
-      .requestJson({ endpoint: '/sandboxes', method: 'GET' })
-      .catch((error) => error);
-
-    expect(notFoundError).toBeInstanceOf(NotFoundError);
-    expect(notFoundError.endpoint).toBe('GET /sandboxes/missing');
-    expect(rateLimitError).toBeInstanceOf(RateLimitError);
-    expect(rateLimitError.retryAfterSeconds).toBe(3);
-  });
-});

package/test/unit/volumes.test.ts

@@ -1,122 +0,0 @@
-import { describe, expect, test, vi } from 'vitest';
-
-import { MIN_VOLUME_SIZE_GB } from '../../src/constants';
-import { VolumeType } from '../../src/enums';
-import { VolumesResource } from '../../src/resources/volumes';
-import { HttpTransport } from '../../src/transport/http';
-import type { Volume } from '../../src/types';
-
-const volumeFixture: Volume = {
-  id: 'vol-1',
-  name: 'workspace',
-  type: VolumeType.Sandbox,
-  team: null,
-  csi_volume_id: null,
-  size: 20,
-  region: {
-    id: 'region-1',
-    name: 'US East',
-    country: 'United States',
-    continent: 'North America',
-    provider: 'aws',
-    is_paid: false,
-  },
-  mount_path: null,
-  attached_sandbox_id: null,
-  attached_project_id: null,
-  last_attached_at: null,
-  created_at: null,
-  updated_at: null,
-};
-
-describe('VolumesResource', () => {
-  test('rejects non-sandbox volume types', () => {
-    const fetchImpl = vi.fn(async () => {
-      throw new Error('fetch should not be called for validation failures');
-    }) as typeof fetch;
-
-    const transport = new HttpTransport({
-      baseUrl: 'https://sandbox.brimble.io',
-      apiKey: 'test-key',
-      fetchImpl,
-    });
-
-    const volumes = new VolumesResource(transport);
-
-    expect(() =>
-      volumes.create({
-        name: 'invalid-volume',
-        sizeGB: 20,
-        region: 'region-1',
-        type: 'database' as unknown as VolumeType,
-      }),
-    ).toThrow('Only volume type "sandbox" is supported by this package.');
-  });
-
-  test('rejects volume sizes below minimum', () => {
-    const fetchImpl = vi.fn(async () => {
-      throw new Error('fetch should not be called for validation failures');
-    }) as typeof fetch;
-
-    const transport = new HttpTransport({
-      baseUrl: 'https://sandbox.brimble.io',
-      apiKey: 'test-key',
-      fetchImpl,
-    });
-
-    const volumes = new VolumesResource(transport);
-
-    expect(() =>
-      volumes.create({
-        name: 'too-small',
-        sizeGB: MIN_VOLUME_SIZE_GB - 1,
-        region: 'region-1',
-      }),
-    ).toThrow(`Volume size must be at least ${MIN_VOLUME_SIZE_GB}GB.`);
-  });
-
-  test('defaults volume type to sandbox when omitted', async () => {
-    let requestBody: unknown = null;
-
-    const fetchImpl = vi.fn(async (_url: URL | RequestInfo, init?: RequestInit) => {
-      if (typeof init?.body === 'string') {
-        requestBody = JSON.parse(init.body) as unknown;
-      }
-
-      return new Response(
-        JSON.stringify({
-          message: 'created',
-          data: volumeFixture,
-        }),
-        {
-          status: 200,
-          headers: {
-            'content-type': 'application/json',
-          },
-        },
-      );
-    }) as typeof fetch;
-
-    const transport = new HttpTransport({
-      baseUrl: 'https://sandbox.brimble.io',
-      apiKey: 'test-key',
-      fetchImpl,
-    });
-
-    const volumes = new VolumesResource(transport);
-
-    const created = await volumes.create({
-      name: 'workspace',
-      sizeGB: 20,
-      region: 'region-1',
-    });
-
-    expect(created.type).toBe(VolumeType.Sandbox);
-    expect(requestBody).toMatchObject({
-      name: 'workspace',
-      sizeGB: 20,
-      region: 'region-1',
-      type: VolumeType.Sandbox,
-    });
-  });
-});

package/tsconfig.json

@@ -1,16 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "CommonJS",
-    "moduleResolution": "node",
-    "lib": ["ES2022", "DOM"],
-    "declaration": true,
-    "outDir": "dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "resolveJsonModule": true,
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": ["dist", "node_modules"]
-}

package/vitest.config.ts

@@ -1,12 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['test/unit/**/*.test.ts'],
-    testTimeout: 15_000,
-    hookTimeout: 15_000,
-    restoreMocks: true,
-    clearMocks: true,
-  },
-});

package/vitest.integration.config.ts

@@ -1,15 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    environment: 'node',
-    include: ['test/integration/**/*.test.ts'],
-    testTimeout: 240_000,
-    hookTimeout: 240_000,
-    restoreMocks: true,
-    clearMocks: true,
-    sequence: {
-      concurrent: false,
-    },
-  },
-});