nebula-cms 0.1.0

package/tests/client/js/storage/fsa.test.ts

@@ -0,0 +1,284 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+//////////////////////////////
+// FsaAdapter tests
+//
+// The File System Access API is not available in Node.js, so we build a
+// minimal in-memory mock of FileSystemDirectoryHandle / FileSystemFileHandle
+// that mirrors the FSA contract expected by FsaAdapter.
+//////////////////////////////
+
+import { FsaAdapter } from '../../../../src/client/js/storage/fsa';
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+/**
+ * Writable mock that stores text and returns it via text().
+ */
+interface MockFile {
+  _content: string;
+  text(): Promise<string>;
+}
+
+/**
+ * Creates a minimal File mock.
+ * @param {string} content - The file content
+ * @return {MockFile} A mock File object
+ */
+function makeFile(content: string): MockFile {
+  return {
+    _content: content,
+    text: async () => content,
+  };
+}
+
+/**
+ * Creates a mock FileSystemWritableFileStream.
+ * @param {MockFileHandle} owner - The handle that owns this stream
+ * @return {object} A mock writable stream
+ */
+function makeWritable(owner: MockFileHandle) {
+  return {
+    write: vi.fn(async (data: string) => {
+      owner._content = data;
+    }),
+    close: vi.fn(async () => undefined),
+  };
+}
+
+/**
+ * Mock FileSystemFileHandle backed by an in-memory string.
+ */
+class MockFileHandle {
+  kind = 'file' as const;
+  _content: string;
+
+  /**
+   * @param {string} content - Initial file content
+   */
+  constructor(content = '') {
+    this._content = content;
+  }
+
+  /**
+   * Returns the mock File for this handle.
+   * @return {Promise<MockFile>} The file object
+   */
+  async getFile(): Promise<MockFile> {
+    return makeFile(this._content);
+  }
+
+  /**
+   * Returns a writable stream for this handle.
+   * @return {Promise<ReturnType<typeof makeWritable>>} The writable stream
+   */
+  async createWritable() {
+    return makeWritable(this);
+  }
+}
+
+/**
+ * Builds a mock FileSystemDirectoryHandle that holds a flat map of name → entry.
+ * @param {Record<string, MockFileHandle | MockDirHandle>} children - The directory's children
+ * @return {MockDirHandle} A mock directory handle
+ */
+class MockDirHandle {
+  kind = 'directory' as const;
+  private children: Map<string, MockFileHandle | MockDirHandle>;
+
+  /**
+   * @param {Record<string, MockFileHandle | MockDirHandle>} entries - Initial children map
+   */
+  constructor(entries: Record<string, MockFileHandle | MockDirHandle> = {}) {
+    this.children = new Map(Object.entries(entries));
+  }
+
+  /**
+   * Returns a child directory handle by name.
+   * @param {string} name - The directory name
+   * @return {Promise<MockDirHandle>} The directory handle
+   */
+  async getDirectoryHandle(name: string): Promise<MockDirHandle> {
+    const entry = this.children.get(name);
+    if (!entry || entry.kind !== 'directory') {
+      throw new DOMException(`${name} not found`, 'NotFoundError');
+    }
+    return entry as MockDirHandle;
+  }
+
+  /**
+   * Returns a child file handle, optionally creating it.
+   * @param {string} name - The file name
+   * @param {{ create?: boolean }} options - Options object
+   * @return {Promise<MockFileHandle>} The file handle
+   */
+  async getFileHandle(
+    name: string,
+    options?: { create?: boolean },
+  ): Promise<MockFileHandle> {
+    if (!this.children.has(name)) {
+      if (options?.create) {
+        const newHandle = new MockFileHandle('');
+        this.children.set(name, newHandle);
+        return newHandle;
+      }
+      throw new DOMException(`${name} not found`, 'NotFoundError');
+    }
+    return this.children.get(name) as MockFileHandle;
+  }
+
+  /**
+   * Removes a child entry by name.
+   * @param {string} name - The entry name to remove
+   * @return {Promise<void>}
+   */
+  async removeEntry(name: string): Promise<void> {
+    if (!this.children.has(name)) {
+      throw new DOMException(`${name} not found`, 'NotFoundError');
+    }
+    this.children.delete(name);
+  }
+
+  /**
+   * Async generator that yields [name, entry] pairs for all children.
+   * @return {AsyncIterable<[string, MockFileHandle | MockDirHandle]>}
+   */
+  async *entries(): AsyncIterable<[string, MockFileHandle | MockDirHandle]> {
+    for (const [name, entry] of this.children) {
+      yield [name, entry];
+    }
+  }
+}
+
+// ── Fixtures ─────────────────────────────────────────────────────────────────
+
+/**
+ * Builds a root handle pre-populated with src/content/posts containing
+ * two .md files, one .mdx file, and a directory entry (to be skipped).
+ * @return {MockDirHandle} The mock root handle
+ */
+function makeRoot(): MockDirHandle {
+  const postsDir = new MockDirHandle({
+    'hello.md': new MockFileHandle('---\ntitle: Hello\n---\n'),
+    'world.md': new MockFileHandle('---\ntitle: World\n---\n'),
+    'page.mdx': new MockFileHandle('---\ntitle: Page\n---\n'),
+    subdir: new MockDirHandle(),
+  });
+  const contentDir = new MockDirHandle({ posts: postsDir });
+  const srcDir = new MockDirHandle({ content: contentDir });
+  return new MockDirHandle({ src: srcDir });
+}
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('FsaAdapter', () => {
+  let root: MockDirHandle;
+  let adapter: FsaAdapter;
+
+  beforeEach(() => {
+    root = makeRoot();
+    adapter = new FsaAdapter(root as unknown as FileSystemDirectoryHandle);
+  });
+
+  describe('listFiles', () => {
+    it('returns all .md and .mdx files with their content', async () => {
+      const files = await adapter.listFiles('posts', ['.md', '.mdx']);
+      const names = files.map((f) => f.filename).sort();
+      expect(names).toEqual(['hello.md', 'page.mdx', 'world.md']);
+    });
+
+    it('returns the correct content for each file', async () => {
+      const files = await adapter.listFiles('posts', ['.md', '.mdx']);
+      const hello = files.find((f) => f.filename === 'hello.md');
+      expect(hello?.content).toBe('---\ntitle: Hello\n---\n');
+    });
+
+    it('skips directory entries', async () => {
+      const files = await adapter.listFiles('posts', ['.md', '.mdx']);
+      const names = files.map((f) => f.filename);
+      expect(names).not.toContain('subdir');
+    });
+
+    it('returns an empty array for an empty collection directory', async () => {
+      const emptyDir = new MockDirHandle();
+      const contentDir = new MockDirHandle({ empty: emptyDir });
+      const srcDir = new MockDirHandle({ content: contentDir });
+      const emptyRoot = new MockDirHandle({ src: srcDir });
+      const emptyAdapter = new FsaAdapter(
+        emptyRoot as unknown as FileSystemDirectoryHandle,
+      );
+      const files = await emptyAdapter.listFiles('empty', ['.md', '.mdx']);
+      expect(files).toEqual([]);
+    });
+
+    it('filters by the given extensions', async () => {
+      const mdOnly = await adapter.listFiles('posts', ['.md']);
+      const names = mdOnly.map((f) => f.filename).sort();
+      expect(names).toEqual(['hello.md', 'world.md']);
+      expect(names).not.toContain('page.mdx');
+    });
+
+    it('returns nothing when no files match the extensions', async () => {
+      const files = await adapter.listFiles('posts', ['.yaml']);
+      expect(files).toEqual([]);
+    });
+  });
+
+  describe('readFile', () => {
+    it('returns the file content for a known file', async () => {
+      const content = await adapter.readFile('posts', 'hello.md');
+      expect(content).toBe('---\ntitle: Hello\n---\n');
+    });
+
+    it('throws when the file does not exist', async () => {
+      await expect(adapter.readFile('posts', 'missing.md')).rejects.toThrow();
+    });
+  });
+
+  describe('writeFile', () => {
+    it('writes content to an existing file', async () => {
+      await adapter.writeFile('posts', 'hello.md', 'new content');
+      const content = await adapter.readFile('posts', 'hello.md');
+      expect(content).toBe('new content');
+    });
+
+    it('creates a new file when it does not exist', async () => {
+      await adapter.writeFile('posts', 'brand-new.md', 'fresh content');
+      const content = await adapter.readFile('posts', 'brand-new.md');
+      expect(content).toBe('fresh content');
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('removes an existing file from the collection', async () => {
+      await adapter.deleteFile('posts', 'hello.md');
+      const files = await adapter.listFiles('posts', ['.md', '.mdx']);
+      const names = files.map((f) => f.filename);
+      expect(names).not.toContain('hello.md');
+    });
+
+    it('throws when the file does not exist', async () => {
+      await expect(
+        adapter.deleteFile('posts', 'nonexistent.md'),
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('writeFiles', () => {
+    it('writes all files sequentially', async () => {
+      await adapter.writeFiles([
+        { collection: 'posts', filename: 'hello.md', content: 'updated hello' },
+        { collection: 'posts', filename: 'world.md', content: 'updated world' },
+      ]);
+      const hello = await adapter.readFile('posts', 'hello.md');
+      const world = await adapter.readFile('posts', 'world.md');
+      expect(hello).toBe('updated hello');
+      expect(world).toBe('updated world');
+    });
+
+    it('is a no-op for an empty array', async () => {
+      // Should resolve without throwing
+      await expect(adapter.writeFiles([])).resolves.toBeUndefined();
+    });
+  });
+});

package/tests/client/js/storage/github.test.ts

@@ -0,0 +1,349 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+
+//////////////////////////////
+// GitHubAdapter tests
+//
+// All network calls are intercepted by replacing globalThis.fetch with a
+// vi.fn() that returns pre-built Response objects. Each test group
+// configures fetch to respond to the specific API endpoints exercised
+// by the method under test.
+//////////////////////////////
+
+import { GitHubAdapter } from '../../../../src/client/js/storage/github';
+
+// ── Helpers ───────────────────────────────────────────────────────────────────
+
+/**
+ * Creates a minimal Response-like object for use in fetch mocks.
+ * @param {unknown} body - The response body (will be JSON-serialized if object)
+ * @param {number} status - HTTP status code
+ * @param {{ text?: boolean }} opts - When text is true, body is treated as a raw string
+ * @return {Response} A mock Response instance
+ */
+function mockResponse(
+  body: unknown,
+  status = 200,
+  opts: { text?: boolean } = {},
+): Response {
+  const bodyStr = opts.text ? (body as string) : JSON.stringify(body);
+  return new Response(bodyStr, {
+    status,
+    headers: { 'Content-Type': opts.text ? 'text/plain' : 'application/json' },
+  });
+}
+
+// ── Setup ─────────────────────────────────────────────────────────────────────
+
+let fetchMock: ReturnType<typeof vi.fn>;
+
+beforeEach(() => {
+  fetchMock = vi.fn();
+  globalThis.fetch = fetchMock;
+});
+
+afterEach(() => {
+  vi.restoreAllMocks();
+});
+
+// ── Tests ─────────────────────────────────────────────────────────────────────
+
+describe('GitHubAdapter', () => {
+  const TOKEN = 'ghp_test_token';
+  const REPO = 'owner/my-repo';
+
+  describe('validate', () => {
+    it('stores the default branch returned by the repo endpoint', async () => {
+      fetchMock.mockResolvedValueOnce(
+        mockResponse({ default_branch: 'develop' }),
+      );
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await adapter.validate();
+      // Confirm the branch is used in subsequent calls by inspecting listFiles
+      fetchMock.mockResolvedValueOnce(mockResponse([]));
+      await adapter.listFiles('posts', ['.md', '.mdx']);
+      const listURL = fetchMock.mock.calls[1][0] as string;
+      expect(listURL).toContain('ref=develop');
+    });
+
+    it('throws for a 401 response', async () => {
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 401));
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await expect(adapter.validate()).rejects.toThrow('Invalid or expired');
+    });
+
+    it('throws for a 403 response', async () => {
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 403));
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await expect(adapter.validate()).rejects.toThrow('lacks repository');
+    });
+
+    it('throws for a 404 response', async () => {
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 404));
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await expect(adapter.validate()).rejects.toThrow('not found');
+    });
+
+    it('throws a generic error for other non-ok statuses', async () => {
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 500));
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await expect(adapter.validate()).rejects.toThrow('GitHub API error: 500');
+    });
+  });
+
+  describe('listFiles', () => {
+    it('returns empty array when the collection path returns 404', async () => {
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 404));
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      const files = await adapter.listFiles('posts', ['.md', '.mdx']);
+      expect(files).toEqual([]);
+    });
+
+    it('returns only files matching the given extensions', async () => {
+      // Directory listing response
+      fetchMock.mockResolvedValueOnce(
+        mockResponse([
+          {
+            name: 'hello.md',
+            download_url: 'https://raw.github.com/hello.md',
+          },
+          {
+            name: 'world.mdx',
+            download_url: 'https://raw.github.com/world.mdx',
+          },
+          {
+            name: 'image.png',
+            download_url: 'https://raw.github.com/image.png',
+          },
+        ]),
+      );
+      // readFile calls for hello.md and world.mdx
+      fetchMock.mockResolvedValueOnce(
+        mockResponse('# Hello', 200, { text: true }),
+      );
+      fetchMock.mockResolvedValueOnce(
+        mockResponse('# World', 200, { text: true }),
+      );
+
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      const files = await adapter.listFiles('posts', ['.md', '.mdx']);
+      const names = files.map((f) => f.filename).sort();
+      expect(names).toEqual(['hello.md', 'world.mdx']);
+    });
+
+    it('filters to only the requested extensions', async () => {
+      fetchMock.mockResolvedValueOnce(
+        mockResponse([
+          {
+            name: 'hello.md',
+            download_url: 'https://raw.github.com/hello.md',
+          },
+          {
+            name: 'world.mdx',
+            download_url: 'https://raw.github.com/world.mdx',
+          },
+          {
+            name: 'data.yaml',
+            download_url: 'https://raw.github.com/data.yaml',
+          },
+        ]),
+      );
+      // Only .yaml file should be fetched
+      fetchMock.mockResolvedValueOnce(
+        mockResponse('key: value', 200, { text: true }),
+      );
+
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      const files = await adapter.listFiles('posts', ['.yaml']);
+      expect(files).toHaveLength(1);
+      expect(files[0].filename).toBe('data.yaml');
+    });
+
+    it('throws when the listing request fails with a non-404 error', async () => {
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 500));
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await expect(adapter.listFiles('posts', ['.md', '.mdx'])).rejects.toThrow(
+        'Failed to list files',
+      );
+    });
+  });
+
+  describe('deleteFile', () => {
+    it('sends a DELETE request with the current SHA', async () => {
+      // GET to retrieve the current SHA
+      fetchMock.mockResolvedValueOnce(
+        mockResponse({ sha: 'file-sha-123', name: 'old.md' }),
+      );
+      // DELETE succeeds
+      fetchMock.mockResolvedValueOnce(mockResponse({ commit: {} }));
+
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await adapter.deleteFile('posts', 'old.md');
+
+      // Verify the DELETE call
+      const deleteCall = fetchMock.mock.calls[1];
+      expect(deleteCall[1].method).toBe('DELETE');
+      const deleteBody = JSON.parse(deleteCall[1].body as string);
+      expect(deleteBody.sha).toBe('file-sha-123');
+      expect(deleteBody.message).toContain('old.md');
+    });
+
+    it('throws when the file does not exist', async () => {
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 404));
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await expect(adapter.deleteFile('posts', 'missing.md')).rejects.toThrow(
+        'File not found for deletion',
+      );
+    });
+
+    it('throws when the DELETE request fails', async () => {
+      fetchMock.mockResolvedValueOnce(
+        mockResponse({ sha: 'sha-abc', name: 'target.md' }),
+      );
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 422));
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await expect(adapter.deleteFile('posts', 'target.md')).rejects.toThrow(
+        'Failed to delete',
+      );
+    });
+  });
+
+  describe('readFile', () => {
+    it('returns the raw file content', async () => {
+      fetchMock.mockResolvedValueOnce(
+        mockResponse('---\ntitle: Test\n---\n', 200, { text: true }),
+      );
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      const content = await adapter.readFile('posts', 'test.md');
+      expect(content).toBe('---\ntitle: Test\n---\n');
+    });
+
+    it('sends the raw+json Accept header', async () => {
+      fetchMock.mockResolvedValueOnce(
+        mockResponse('content', 200, { text: true }),
+      );
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await adapter.readFile('posts', 'test.md');
+      const headers = fetchMock.mock.calls[0][1].headers as Record<
+        string,
+        string
+      >;
+      expect(headers['Accept']).toBe('application/vnd.github.raw+json');
+    });
+
+    it('throws when the file is not found', async () => {
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 404));
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await expect(adapter.readFile('posts', 'missing.md')).rejects.toThrow(
+        'Failed to read',
+      );
+    });
+  });
+
+  describe('writeFile', () => {
+    it('sends a PUT request without sha for a new file', async () => {
+      // GET returns 404 (file doesn't exist yet)
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 404));
+      // PUT succeeds
+      fetchMock.mockResolvedValueOnce(mockResponse({ content: {} }));
+
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await adapter.writeFile('posts', 'new.md', '# New');
+
+      const putCall = fetchMock.mock.calls[1];
+      const putBody = JSON.parse(putCall[1].body as string);
+      expect(putBody.sha).toBeUndefined();
+      expect(putBody.message).toContain('new.md');
+    });
+
+    it('sends a PUT request with sha for an existing file', async () => {
+      // GET returns existing file with sha
+      fetchMock.mockResolvedValueOnce(
+        mockResponse({ sha: 'abc123', name: 'existing.md' }),
+      );
+      // PUT succeeds
+      fetchMock.mockResolvedValueOnce(mockResponse({ content: {} }));
+
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await adapter.writeFile('posts', 'existing.md', 'updated');
+
+      const putBody = JSON.parse(fetchMock.mock.calls[1][1].body as string);
+      expect(putBody.sha).toBe('abc123');
+    });
+
+    it('throws when the PUT request fails', async () => {
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 404));
+      fetchMock.mockResolvedValueOnce(
+        mockResponse('error text', 422, { text: true }),
+      );
+
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await expect(adapter.writeFile('posts', 'bad.md', 'x')).rejects.toThrow(
+        'Failed to write',
+      );
+    });
+
+    it('base64-encodes the content', async () => {
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 404));
+      fetchMock.mockResolvedValueOnce(mockResponse({ content: {} }));
+
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await adapter.writeFile('posts', 'check.md', 'hello');
+
+      const putBody = JSON.parse(fetchMock.mock.calls[1][1].body as string);
+      // 'hello' base64 encodes to 'aGVsbG8='
+      expect(putBody.content).toBe('aGVsbG8=');
+    });
+  });
+
+  describe('writeFiles', () => {
+    it('is a no-op for an empty array', async () => {
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await expect(adapter.writeFiles([])).resolves.toBeUndefined();
+      expect(fetchMock).not.toHaveBeenCalled();
+    });
+
+    it('delegates to writeFile for a single-file array', async () => {
+      // GET (check sha) + PUT
+      fetchMock.mockResolvedValueOnce(mockResponse({}, 404));
+      fetchMock.mockResolvedValueOnce(mockResponse({ content: {} }));
+
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await adapter.writeFiles([
+        { collection: 'posts', filename: 'one.md', content: 'body' },
+      ]);
+      // Two calls: GET for sha check, PUT for write
+      expect(fetchMock).toHaveBeenCalledTimes(2);
+    });
+
+    it('uses the Git Trees API for multiple files', async () => {
+      // GET /git/ref/heads/main
+      fetchMock.mockResolvedValueOnce(
+        mockResponse({ object: { sha: 'commit-sha' } }),
+      );
+      // GET /git/commits/commit-sha
+      fetchMock.mockResolvedValueOnce(
+        mockResponse({ tree: { sha: 'tree-sha' } }),
+      );
+      // POST /git/trees
+      fetchMock.mockResolvedValueOnce(mockResponse({ sha: 'new-tree-sha' }));
+      // POST /git/commits
+      fetchMock.mockResolvedValueOnce(mockResponse({ sha: 'new-commit-sha' }));
+      // PATCH /git/refs/heads/main
+      fetchMock.mockResolvedValueOnce(mockResponse({ ref: 'refs/heads/main' }));
+
+      const adapter = new GitHubAdapter(TOKEN, REPO);
+      await adapter.writeFiles([
+        { collection: 'posts', filename: 'a.md', content: 'A' },
+        { collection: 'posts', filename: 'b.md', content: 'B' },
+      ]);
+
+      // Should have made 5 API calls
+      expect(fetchMock).toHaveBeenCalledTimes(5);
+      // The tree POST should contain both file paths
+      const treeBody = JSON.parse(fetchMock.mock.calls[2][1].body as string);
+      const paths = treeBody.tree.map((t: { path: string }) => t.path);
+      expect(paths).toContain('src/content/posts/a.md');
+      expect(paths).toContain('src/content/posts/b.md');
+    });
+  });
+});