@mesadev/sdk 0.2.2 → 0.3.2

package/tests/unit/client.test.ts

@@ -1,281 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { DepotClient } from '../../src/client';
-import { DepotError } from '../../src/errors';
-import { createDepot } from '../../src/index';
-import { Repo } from '../../src/repo';
-import {
-  errorResponse,
-  expectFetchCalledWith,
-  mockFetch,
-  mockFetchResponse,
-  mockResponses,
-  setupFetchMock,
-} from '../test-utils';
-
-setupFetchMock();
-
-describe('DepotClient', () => {
-  describe('constructor', () => {
-    test('createDepot returns a DepotClient', () => {
-      const client = createDepot({ apiKey: 'dp_live_test123', org: 'acme' });
-      expect(client).toBeInstanceOf(DepotClient);
-    });
-
-    test('uses default base URL', () => {
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      const cloneUrl = client.getCloneUrl('acme', 'my-repo');
-      expect(cloneUrl).toBe('https://dp_live_test123@depot.mesa.dev/acme/my-repo.git');
-    });
-
-    test('uses custom base URL', () => {
-      const client = new DepotClient({
-        apiKey: 'dp_live_test123',
-        org: 'acme',
-        baseUrl: 'https://custom.depot.dev',
-      });
-      const cloneUrl = client.getCloneUrl('acme', 'my-repo');
-      expect(cloneUrl).toBe('https://dp_live_test123@custom.depot.dev/acme/my-repo.git');
-    });
-
-    test('strips protocol from clone URL', () => {
-      const client = new DepotClient({
-        apiKey: 'dp_live_test123',
-        org: 'acme',
-        baseUrl: 'http://localhost:3001',
-      });
-      const cloneUrl = client.getCloneUrl('acme', 'my-repo');
-      expect(cloneUrl).toBe('https://dp_live_test123@localhost:3001/acme/my-repo.git');
-    });
-  });
-
-  describe('createRepo', () => {
-    test('creates a repository and returns Repo instance', async () => {
-      const mockRepo = mockResponses.repo({ name: 'new-repo' });
-      mockFetchResponse({ status: 201, body: mockRepo });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      const repo = await client.createRepo({ name: 'new-repo' });
-
-      expect(repo).toBeInstanceOf(Repo);
-      expect(repo.name).toBe('new-repo');
-      expect(repo.defaultBranch).toBe('main');
-      expectFetchCalledWith('/api/v1/acme/repos', { method: 'POST' });
-    });
-
-    test('sends custom default branch', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.default_branch).toBe('master');
-        return { status: 201, body: mockResponses.repo({ default_branch: 'master' }) };
-      });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      const repo = await client.createRepo({ name: 'new-repo', defaultBranch: 'master' });
-
-      expect(repo.defaultBranch).toBe('master');
-    });
-
-    test('throws DepotError on failure', async () => {
-      mockFetchResponse(errorResponse('REPO_EXISTS', 'Repository already exists', 409));
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-
-      await expect(client.createRepo({ name: 'existing-repo' })).rejects.toThrow(DepotError);
-
-      try {
-        await client.createRepo({ name: 'existing-repo' });
-      } catch (err) {
-        expect(err).toBeInstanceOf(DepotError);
-        expect((err as DepotError).code).toBe('REPO_EXISTS');
-      }
-    });
-  });
-
-  describe('getRepo', () => {
-    test('fetches repository by name', async () => {
-      mockFetchResponse({ body: mockResponses.repo({ name: 'my-repo' }) });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      const repo = await client.getRepo('my-repo');
-
-      expect(repo).toBeInstanceOf(Repo);
-      expect(repo.name).toBe('my-repo');
-      expectFetchCalledWith('/api/v1/acme/my-repo');
-    });
-
-    test('encodes special characters in repo name', async () => {
-      mockFetchResponse({ body: mockResponses.repo({ name: 'my/repo' }) });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      await client.getRepo('my/repo');
-
-      expectFetchCalledWith('/api/v1/acme/my%2Frepo');
-    });
-
-    test('throws REPO_NOT_FOUND on 404', async () => {
-      mockFetchResponse(errorResponse('REPO_NOT_FOUND', 'Repository not found', 404));
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-
-      try {
-        await client.getRepo('nonexistent');
-        expect.unreachable('Should have thrown');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DepotError);
-        expect((err as DepotError).code).toBe('REPO_NOT_FOUND');
-      }
-    });
-  });
-
-  describe('listRepos', () => {
-    test('returns array of Repo instances', async () => {
-      mockFetchResponse({
-        body: mockResponses.repoList([mockResponses.repo({ name: 'repo-1' }), mockResponses.repo({ name: 'repo-2' })]),
-      });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      const result = await client.listRepos();
-
-      expect(result.repos).toHaveLength(2);
-      expect(result.repos[0]).toBeInstanceOf(Repo);
-      expect(result.repos[0].name).toBe('repo-1');
-      expect(result.repos[1].name).toBe('repo-2');
-      expect(result.nextCursor).toBeNull();
-      expect(result.hasMore).toBe(false);
-    });
-
-    test('returns empty array when no repos exist', async () => {
-      mockFetchResponse({ body: mockResponses.repoList([]) });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      const result = await client.listRepos();
-
-      expect(result.repos).toHaveLength(0);
-    });
-  });
-
-  describe('deleteRepo', () => {
-    test('deletes repository by name', async () => {
-      mockFetchResponse({ status: 200, body: {} });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      await client.deleteRepo('my-repo');
-
-      expectFetchCalledWith('/api/v1/acme/my-repo', { method: 'DELETE' });
-    });
-
-    test('throws on not found', async () => {
-      mockFetchResponse(errorResponse('REPO_NOT_FOUND', 'Repository not found', 404));
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-
-      await expect(client.deleteRepo('nonexistent')).rejects.toThrow(DepotError);
-    });
-  });
-
-  describe('API Key operations', () => {
-    test('createApiKey creates a new key', async () => {
-      mockFetchResponse({
-        status: 201,
-        body: mockResponses.apiKey({ name: 'CI Key', scopes: ['git:read', 'git:write'] }),
-      });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      const apiKey = await client.createApiKey({ name: 'CI Key', scopes: ['git:read', 'git:write'] });
-
-      expect(apiKey.name).toBe('CI Key');
-      expect(apiKey.scopes).toEqual(['git:read', 'git:write']);
-      expect(apiKey.key).toBe('dp_live_testkey123');
-      expectFetchCalledWith('/api/v1/api-keys', { method: 'POST' });
-    });
-
-    test('createApiKey with defaults', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.name).toBeUndefined();
-        expect(body.scopes).toBeUndefined();
-        return { status: 201, body: mockResponses.apiKey() };
-      });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      await client.createApiKey();
-    });
-
-    test('listApiKeys returns array of keys', async () => {
-      mockFetchResponse({ body: mockResponses.apiKeyList() });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      const keys = await client.listApiKeys();
-
-      expect(keys).toHaveLength(1);
-      expect(keys[0].id).toBe('key_123');
-      expect(keys[0].key).toBeUndefined(); // key is not returned on list
-    });
-
-    test('revokeApiKey deletes the key', async () => {
-      mockFetchResponse({ status: 200, body: {} });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      await client.revokeApiKey('key_123');
-
-      expectFetchCalledWith('/api/v1/api-keys/key_123', { method: 'DELETE' });
-    });
-  });
-
-  describe('error handling', () => {
-    test('handles network errors', async () => {
-      mockFetch(() => {
-        throw new Error('Network error');
-      });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-
-      try {
-        await client.listRepos();
-        expect.unreachable('Should have thrown');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DepotError);
-        expect((err as DepotError).code).toBe('NETWORK_ERROR');
-      }
-    });
-
-    test('handles invalid JSON response', async () => {
-      mockFetch(() => ({
-        status: 500,
-        headers: { 'Content-Type': 'application/json' },
-        text: '{ this is not valid JSON',
-      }));
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-
-      try {
-        await client.listRepos();
-        expect.unreachable('Should have thrown');
-      } catch (err) {
-        expect(err).toBeInstanceOf(DepotError);
-      }
-    });
-
-    test('includes authorization header in all requests', async () => {
-      mockFetch((_url, init) => {
-        const headers = init?.headers as Record<string, string>;
-        expect(headers.Authorization).toBe('Bearer dp_live_test123');
-        return { body: mockResponses.repoList() };
-      });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      await client.listRepos();
-    });
-
-    test('includes content-type header for JSON bodies', async () => {
-      mockFetch((_url, init) => {
-        const headers = init?.headers as Record<string, string>;
-        expect(headers['Content-Type']).toBe('application/json');
-        return { status: 201, body: mockResponses.repo({ name: 'new-repo' }) };
-      });
-
-      const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-      await client.createRepo({ name: 'new-repo' });
-    });
-  });
-});

package/tests/unit/commit-builder.test.ts

@@ -1,280 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { DepotClient } from '../../src/client';
-import { CommitBuilder } from '../../src/commit-builder';
-import { expectFetchCalledWith, mockFetch, mockFetchResponse, mockResponses, setupFetchMock } from '../test-utils';
-
-setupFetchMock();
-
-// Helper to create a CommitBuilder for testing
-function createTestCommitBuilder(
-  options: {
-    repoName?: string;
-    branch?: string;
-    message?: string;
-    author?: { name: string; email: string };
-    baseSha?: string;
-  } = {}
-) {
-  const client = new DepotClient({ apiKey: 'dp_live_test123', org: 'acme' });
-  return new CommitBuilder(client, 'acme', options.repoName ?? 'test-repo', {
-    branch: options.branch ?? 'main',
-    message: options.message ?? 'Test commit',
-    author: options.author ?? { name: 'Test User', email: 'test@example.com' },
-    baseSha: options.baseSha,
-  });
-}
-
-describe('CommitBuilder', () => {
-  describe('addFile', () => {
-    test('adds string content with utf-8 encoding', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.files).toHaveLength(1);
-        expect(body.files[0]).toEqual({
-          path: 'README.md',
-          content: '# Hello World',
-          encoding: 'utf-8',
-        });
-        return { status: 201, body: mockResponses.commit() };
-      });
-
-      const builder = createTestCommitBuilder();
-      await builder.addFile('README.md', '# Hello World').send();
-    });
-
-    test('adds Buffer content with base64 encoding', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.files).toHaveLength(1);
-        expect(body.files[0].path).toBe('image.png');
-        expect(body.files[0].encoding).toBe('base64');
-        // Buffer.from([0x89, 0x50, 0x4e, 0x47]) is PNG header
-        expect(body.files[0].content).toBe(Buffer.from([0x89, 0x50, 0x4e, 0x47]).toString('base64'));
-        return { status: 201, body: mockResponses.commit() };
-      });
-
-      const builder = createTestCommitBuilder();
-      await builder.addFile('image.png', Buffer.from([0x89, 0x50, 0x4e, 0x47])).send();
-    });
-
-    test('supports chaining', () => {
-      const builder = createTestCommitBuilder();
-      const result = builder.addFile('file1.txt', 'content1');
-
-      expect(result).toBe(builder);
-    });
-
-    test('allows multiple files', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.files).toHaveLength(3);
-        expect(body.files[0].path).toBe('file1.txt');
-        expect(body.files[1].path).toBe('file2.txt');
-        expect(body.files[2].path).toBe('file3.txt');
-        return { status: 201, body: mockResponses.commit() };
-      });
-
-      const builder = createTestCommitBuilder();
-      await builder
-        .addFile('file1.txt', 'content1')
-        .addFile('file2.txt', 'content2')
-        .addFile('file3.txt', 'content3')
-        .send();
-    });
-  });
-
-  describe('deleteFile', () => {
-    test('adds delete action', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.files).toHaveLength(1);
-        expect(body.files[0]).toEqual({
-          path: 'old-file.txt',
-          action: 'delete',
-        });
-        return { status: 201, body: mockResponses.commit() };
-      });
-
-      const builder = createTestCommitBuilder();
-      await builder.deleteFile('old-file.txt').send();
-    });
-
-    test('supports chaining', () => {
-      const builder = createTestCommitBuilder();
-      const result = builder.deleteFile('file.txt');
-
-      expect(result).toBe(builder);
-    });
-
-    test('can mix add and delete operations', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.files).toHaveLength(3);
-        expect(body.files[0]).toEqual({ path: 'new.txt', content: 'new content', encoding: 'utf-8' });
-        expect(body.files[1]).toEqual({ path: 'old.txt', action: 'delete' });
-        expect(body.files[2]).toEqual({ path: 'updated.txt', content: 'updated', encoding: 'utf-8' });
-        return { status: 201, body: mockResponses.commit() };
-      });
-
-      const builder = createTestCommitBuilder();
-      await builder.addFile('new.txt', 'new content').deleteFile('old.txt').addFile('updated.txt', 'updated').send();
-    });
-  });
-
-  describe('send', () => {
-    test('sends commit to correct endpoint', async () => {
-      mockFetchResponse({ status: 201, body: mockResponses.commit() });
-
-      const builder = createTestCommitBuilder({ repoName: 'my-repo' });
-      await builder.addFile('test.txt', 'content').send();
-
-      expectFetchCalledWith('/api/v1/acme/my-repo/commits', { method: 'POST' });
-    });
-
-    test('encodes repo name in URL', async () => {
-      mockFetchResponse({ status: 201, body: mockResponses.commit() });
-
-      const builder = createTestCommitBuilder({ repoName: 'my/special-repo' });
-      await builder.addFile('test.txt', 'content').send();
-
-      expectFetchCalledWith('/api/v1/acme/my%2Fspecial-repo/commits');
-    });
-
-    test('sends branch and message', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.branch).toBe('feature/test');
-        expect(body.message).toBe('Add new feature');
-        return { status: 201, body: mockResponses.commit() };
-      });
-
-      const builder = createTestCommitBuilder({
-        branch: 'feature/test',
-        message: 'Add new feature',
-      });
-      await builder.addFile('test.txt', 'content').send();
-    });
-
-    test('sends author information', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.author).toEqual({
-          name: 'Jane Doe',
-          email: 'jane@example.com',
-        });
-        return { status: 201, body: mockResponses.commit() };
-      });
-
-      const builder = createTestCommitBuilder({
-        author: { name: 'Jane Doe', email: 'jane@example.com' },
-      });
-      await builder.addFile('test.txt', 'content').send();
-    });
-
-    test('sends baseSha when provided', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.base_sha).toBe('abc123def456');
-        return { status: 201, body: mockResponses.commit() };
-      });
-
-      const builder = createTestCommitBuilder({ baseSha: 'abc123def456' });
-      await builder.addFile('test.txt', 'content').send();
-    });
-
-    test('omits baseSha when not provided', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.base_sha).toBeUndefined();
-        return { status: 201, body: mockResponses.commit() };
-      });
-
-      const builder = createTestCommitBuilder();
-      await builder.addFile('test.txt', 'content').send();
-    });
-
-    test('returns commit result', async () => {
-      mockFetchResponse({
-        status: 201,
-        body: mockResponses.commit({
-          sha: 'newcommit123',
-          branch: 'develop',
-          message: 'My commit message',
-        }),
-      });
-
-      const builder = createTestCommitBuilder();
-      const result = await builder.addFile('test.txt', 'content').send();
-
-      expect(result.sha).toBe('newcommit123');
-      expect(result.branch).toBe('develop');
-      expect(result.message).toBe('My commit message');
-    });
-
-    test('can send empty commit (no files)', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-        expect(body.files).toEqual([]);
-        return { status: 201, body: mockResponses.commit() };
-      });
-
-      const builder = createTestCommitBuilder();
-      await builder.send();
-    });
-  });
-
-  describe('full workflow', () => {
-    test('complete commit workflow', async () => {
-      mockFetch((_url, init) => {
-        const body = JSON.parse(init?.body as string);
-
-        expect(body.branch).toBe('main');
-        expect(body.message).toBe('Update documentation');
-        expect(body.author).toEqual({ name: 'Bot', email: 'bot@example.com' });
-
-        expect(body.files).toHaveLength(4);
-
-        // README update
-        expect(body.files[0].path).toBe('README.md');
-        expect(body.files[0].content).toBe('# Updated README');
-        expect(body.files[0].encoding).toBe('utf-8');
-
-        // New config file
-        expect(body.files[1].path).toBe('config.json');
-        expect(body.files[1].encoding).toBe('utf-8');
-
-        // Binary file
-        expect(body.files[2].path).toBe('logo.png');
-        expect(body.files[2].encoding).toBe('base64');
-
-        // Delete old file
-        expect(body.files[3].path).toBe('old-readme.txt');
-        expect(body.files[3].action).toBe('delete');
-
-        return {
-          status: 201,
-          body: {
-            sha: 'commit123',
-            branch: 'main',
-            message: 'Update documentation',
-          },
-        };
-      });
-
-      const builder = createTestCommitBuilder({
-        branch: 'main',
-        message: 'Update documentation',
-        author: { name: 'Bot', email: 'bot@example.com' },
-      });
-
-      const result = await builder
-        .addFile('README.md', '# Updated README')
-        .addFile('config.json', JSON.stringify({ version: '1.0' }))
-        .addFile('logo.png', Buffer.from([0x89, 0x50, 0x4e, 0x47]))
-        .deleteFile('old-readme.txt')
-        .send();
-
-      expect(result.sha).toBe('commit123');
-    });
-  });
-});