nebula-cms 0.1.3 → 0.1.4

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

@@ -1,284 +0,0 @@
-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

@@ -1,349 +0,0 @@
-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');
-    });
-  });
-});