nebula-cms 0.1.0 → 0.1.4

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

@@ -1,115 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-//////////////////////////////
-// adapter.ts type-export tests
-//
-// adapter.ts is a pure type/interface file — there is no runtime code to
-// exercise. These tests confirm that the named exports are importable and
-// that the module resolves without errors, providing a compile-time
-// regression guard.
-//////////////////////////////
-
-import type {
-  FileEntry,
-  FileWrite,
-  StorageAdapter,
-  StorageRequest,
-  StorageResponse,
-} from '../../../../src/client/js/storage/adapter';
-
-describe('adapter type exports', () => {
-  it('FileEntry type is usable as a value shape', () => {
-    // Constructing a conformant object validates the type at compile time
-    const entry: FileEntry = { filename: 'post.md', content: '# Hello' };
-    expect(entry.filename).toBe('post.md');
-    expect(entry.content).toBe('# Hello');
-  });
-
-  it('FileWrite type is usable as a value shape', () => {
-    const write: FileWrite = {
-      collection: 'posts',
-      filename: 'post.md',
-      content: '# Hello',
-    };
-    expect(write.collection).toBe('posts');
-  });
-
-  it('StorageAdapter interface shape has the expected method names', () => {
-    // Verify the interface contract can be satisfied by a plain object
-    const adapter: StorageAdapter = {
-      listFiles: async () => [],
-      readFile: async () => '',
-      writeFile: async () => undefined,
-      writeFiles: async () => undefined,
-      deleteFile: async () => undefined,
-    };
-    expect(typeof adapter.listFiles).toBe('function');
-    expect(typeof adapter.readFile).toBe('function');
-    expect(typeof adapter.writeFile).toBe('function');
-    expect(typeof adapter.writeFiles).toBe('function');
-    expect(typeof adapter.deleteFile).toBe('function');
-  });
-
-  it('StorageRequest union members resolve without type errors', () => {
-    const init: StorageRequest = {
-      type: 'init',
-      backend: { type: 'github', token: 'tok', repo: 'owner/repo' },
-    };
-    const list: StorageRequest = {
-      type: 'listFiles',
-      collection: 'posts',
-      extensions: ['.md', '.mdx'],
-    };
-    const read: StorageRequest = {
-      type: 'readFile',
-      collection: 'posts',
-      filename: 'a.md',
-    };
-    const write: StorageRequest = {
-      type: 'writeFile',
-      collection: 'posts',
-      filename: 'a.md',
-      content: 'body',
-    };
-    const writeMany: StorageRequest = {
-      type: 'writeFiles',
-      files: [{ collection: 'posts', filename: 'a.md', content: 'body' }],
-    };
-    const del: StorageRequest = {
-      type: 'deleteFile',
-      collection: 'posts',
-      filename: 'old.md',
-    };
-    const teardown: StorageRequest = { type: 'teardown' };
-
-    expect(init.type).toBe('init');
-    expect(list.type).toBe('listFiles');
-    expect(read.type).toBe('readFile');
-    expect(write.type).toBe('writeFile');
-    expect(writeMany.type).toBe('writeFiles');
-    expect(del.type).toBe('deleteFile');
-    expect(teardown.type).toBe('teardown');
-  });
-
-  it('StorageResponse union members resolve without type errors', () => {
-    const ok: StorageResponse = { type: 'init', ok: true };
-    const fail: StorageResponse = {
-      type: 'init',
-      ok: false,
-      error: 'bad token',
-    };
-    const delOk: StorageResponse = { type: 'deleteFile', ok: true };
-    const delFail: StorageResponse = {
-      type: 'deleteFile',
-      ok: false,
-      error: 'not found',
-    };
-    const portConn: StorageResponse = { type: 'port-connected' };
-
-    expect(ok.type).toBe('init');
-    expect(fail.ok).toBe(false);
-    expect(delOk.type).toBe('deleteFile');
-    expect(delFail.ok).toBe(false);
-    expect(portConn.type).toBe('port-connected');
-  });
-});

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

@@ -1,250 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-
-//////////////////////////////
-// StorageClient tests
-//
-// StorageClient wraps a MessagePort with request/response correlation.
-// We simulate the port with a plain EventTarget + a manual postMessage spy
-// so we can fire synthetic message events and verify that calls are
-// matched back to their originating promise.
-//////////////////////////////
-
-import { StorageClient } from '../../../../src/client/js/storage/client';
-import type { StorageResponse } from '../../../../src/client/js/storage/adapter';
-import { makeClientMockPort as makeMockPort } from './mock-port';
-
-// ── Tests ─────────────────────────────────────────────────────────────────────
-
-describe('StorageClient', () => {
-  let postSpy: ReturnType<typeof vi.fn>;
-  let respond: (data: StorageResponse & { _id?: string }) => void;
-  let client: StorageClient;
-
-  beforeEach(() => {
-    const mock = makeMockPort();
-    postSpy = mock.postSpy;
-    respond = mock.respond;
-    client = new StorageClient(mock.port);
-  });
-
-  it('calls port.start() in the constructor', () => {
-    const mock = makeMockPort();
-    // start() is called during construction
-    new StorageClient(mock.port);
-    expect(
-      (mock.port.start as ReturnType<typeof vi.fn>).mock.calls.length,
-    ).toBe(1);
-  });
-
-  describe('init', () => {
-    it('sends an init message and resolves when a matching ok response arrives', async () => {
-      const promise = client.init({
-        type: 'init',
-        backend: { type: 'github', token: 'tok', repo: 'owner/repo' },
-      });
-
-      // Grab the _id from the sent message
-      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
-      respond({ type: 'init', ok: true, _id: sentMsg._id } as any);
-
-      await expect(promise).resolves.toBeUndefined();
-    });
-
-    it('rejects when the worker responds with ok: false', async () => {
-      const promise = client.init({
-        type: 'init',
-        backend: { type: 'github', token: 'tok', repo: 'owner/repo' },
-      });
-
-      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
-      respond({
-        type: 'init',
-        ok: false,
-        error: 'bad credentials',
-        _id: sentMsg._id,
-      } as any);
-
-      await expect(promise).rejects.toThrow('bad credentials');
-    });
-  });
-
-  describe('listFiles', () => {
-    it('resolves with the files array from the worker response', async () => {
-      const files = [{ filename: 'a.md', content: 'A' }];
-      const promise = client.listFiles('posts', ['.md', '.mdx']);
-
-      const sentMsg = postSpy.mock.calls[0][0] as {
-        _id: string;
-        type: string;
-        collection: string;
-        extensions: string[];
-      };
-      expect(sentMsg.type).toBe('listFiles');
-      expect(sentMsg.collection).toBe('posts');
-      expect(sentMsg.extensions).toEqual(['.md', '.mdx']);
-
-      respond({
-        type: 'listFiles',
-        ok: true,
-        files,
-        _id: sentMsg._id,
-      } as any);
-
-      const result = await promise;
-      expect(result).toEqual(files);
-    });
-
-    it('rejects on error response', async () => {
-      const promise = client.listFiles('posts', ['.md', '.mdx']);
-      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
-      respond({
-        type: 'listFiles',
-        ok: false,
-        error: 'storage error',
-        _id: sentMsg._id,
-      } as any);
-      await expect(promise).rejects.toThrow('storage error');
-    });
-  });
-
-  describe('deleteFile', () => {
-    it('resolves when the worker responds with ok: true', async () => {
-      const promise = client.deleteFile('posts', 'old.md');
-      const sentMsg = postSpy.mock.calls[0][0] as {
-        _id: string;
-        type: string;
-        collection: string;
-        filename: string;
-      };
-      expect(sentMsg.type).toBe('deleteFile');
-      expect(sentMsg.collection).toBe('posts');
-      expect(sentMsg.filename).toBe('old.md');
-      respond({ type: 'deleteFile', ok: true, _id: sentMsg._id } as any);
-      await expect(promise).resolves.toBeUndefined();
-    });
-
-    it('rejects on error response', async () => {
-      const promise = client.deleteFile('posts', 'missing.md');
-      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
-      respond({
-        type: 'deleteFile',
-        ok: false,
-        error: 'File not found',
-        _id: sentMsg._id,
-      } as any);
-      await expect(promise).rejects.toThrow('File not found');
-    });
-  });
-
-  describe('readFile', () => {
-    it('resolves with the content from the worker response', async () => {
-      const promise = client.readFile('posts', 'hello.md');
-
-      const sentMsg = postSpy.mock.calls[0][0] as {
-        _id: string;
-        collection: string;
-        filename: string;
-      };
-      expect(sentMsg.collection).toBe('posts');
-      expect(sentMsg.filename).toBe('hello.md');
-
-      respond({
-        type: 'readFile',
-        ok: true,
-        content: '# Hello',
-        _id: sentMsg._id,
-      } as any);
-
-      const result = await promise;
-      expect(result).toBe('# Hello');
-    });
-  });
-
-  describe('writeFile', () => {
-    it('resolves when the worker responds with ok: true', async () => {
-      const promise = client.writeFile('posts', 'test.md', 'body');
-      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
-      respond({ type: 'writeFile', ok: true, _id: sentMsg._id } as any);
-      await expect(promise).resolves.toBeUndefined();
-    });
-  });
-
-  describe('writeFiles', () => {
-    it('sends the files array and resolves on ok response', async () => {
-      const files = [
-        { collection: 'posts', filename: 'a.md', content: 'A' },
-        { collection: 'posts', filename: 'b.md', content: 'B' },
-      ];
-      const promise = client.writeFiles(files);
-
-      const sentMsg = postSpy.mock.calls[0][0] as {
-        _id: string;
-        type: string;
-        files: typeof files;
-      };
-      expect(sentMsg.type).toBe('writeFiles');
-      expect(sentMsg.files).toEqual(files);
-
-      respond({ type: 'writeFiles', ok: true, _id: sentMsg._id } as any);
-      await expect(promise).resolves.toBeUndefined();
-    });
-  });
-
-  describe('teardown', () => {
-    it('sends a teardown message and resolves on ok response', async () => {
-      const promise = client.teardown();
-      const sentMsg = postSpy.mock.calls[0][0] as {
-        _id: string;
-        type: string;
-      };
-      expect(sentMsg.type).toBe('teardown');
-      respond({ type: 'teardown', ok: true, _id: sentMsg._id } as any);
-      await expect(promise).resolves.toBeUndefined();
-    });
-  });
-
-  describe('message correlation', () => {
-    it('ignores broadcast messages without an _id', async () => {
-      // port-connected has no _id and should not reject any pending promise
-      const promise = client.listFiles('posts', ['.md', '.mdx']);
-      respond({ type: 'port-connected' } as any);
-      // Promise should still be pending — resolve it now with a proper response
-      const sentMsg = postSpy.mock.calls[0][0] as { _id: string };
-      respond({
-        type: 'listFiles',
-        ok: true,
-        files: [],
-        _id: sentMsg._id,
-      } as any);
-      await expect(promise).resolves.toEqual([]);
-    });
-
-    it('increments _id for each request so concurrent calls are independent', async () => {
-      const p1 = client.listFiles('posts', ['.md', '.mdx']);
-      const p2 = client.readFile('posts', 'a.md');
-
-      const msg1 = postSpy.mock.calls[0][0] as { _id: string };
-      const msg2 = postSpy.mock.calls[1][0] as { _id: string };
-      expect(msg1._id).not.toBe(msg2._id);
-
-      // Resolve in reverse order to prove there's no ordering dependency
-      respond({
-        type: 'readFile',
-        ok: true,
-        content: 'content',
-        _id: msg2._id,
-      } as any);
-      respond({
-        type: 'listFiles',
-        ok: true,
-        files: [{ filename: 'x.md', content: 'x' }],
-        _id: msg1._id,
-      } as any);
-
-      const list = await p1;
-      const read = await p2;
-      expect(list[0].filename).toBe('x.md');
-      expect(read).toBe('content');
-    });
-  });
-});

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

@@ -1,59 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-//////////////////////////////
-// openDB tests
-//
-// Uses fake-indexeddb (polyfilled via the setup file) to exercise the
-// actual IDB open/upgrade logic in a Node.js environment.
-//////////////////////////////
-
-import { openDB } from '../../../../src/client/js/storage/db';
-
-describe('openDB', () => {
-  it('resolves to an IDBDatabase instance', async () => {
-    const db = await openDB();
-    expect(db).toBeDefined();
-    expect(typeof db.transaction).toBe('function');
-  });
-
-  it('creates a "handles" object store', async () => {
-    const db = await openDB();
-    expect(db.objectStoreNames.contains('handles')).toBe(true);
-  });
-
-  it('creates a "drafts" object store', async () => {
-    const db = await openDB();
-    expect(db.objectStoreNames.contains('drafts')).toBe(true);
-  });
-
-  it('returns a usable database that can perform readwrite transactions on "handles"', async () => {
-    const db = await openDB();
-    // A successful transaction confirms the store was created with correct configuration
-    await new Promise<void>((resolve, reject) => {
-      const tx = db.transaction('handles', 'readwrite');
-      tx.objectStore('handles').put({ test: true }, 'probe-key');
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
-    });
-  });
-
-  it('returns a usable database that can perform readwrite transactions on "drafts"', async () => {
-    const db = await openDB();
-    // The drafts store uses { keyPath: 'id' }, so the object must include an id field
-    await new Promise<void>((resolve, reject) => {
-      const tx = db.transaction('drafts', 'readwrite');
-      tx.objectStore('drafts').put({ id: 'probe-draft', data: 'x' });
-      tx.oncomplete = () => resolve();
-      tx.onerror = () => reject(tx.error);
-    });
-  });
-
-  it('subsequent calls return a database with the same stores', async () => {
-    const db1 = await openDB();
-    const db2 = await openDB();
-    expect(db2.objectStoreNames.contains('handles')).toBe(true);
-    expect(db2.objectStoreNames.contains('drafts')).toBe(true);
-    db1.close();
-    db2.close();
-  });
-});