bff-store 0.1.0

package/tests/server.test.ts

@@ -0,0 +1,158 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as http from 'http';
+import * as fs from 'fs';
+import * as path from 'path';
+import { startServer } from '../src/server';
+
+describe('server', () => {
+  let server: http.Server;
+  const testDir = path.join(__dirname, '../.test-server-data');
+
+  beforeEach(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true });
+    }
+    fs.mkdirSync(testDir, { recursive: true });
+  });
+
+  afterEach(async () => {
+    if (server) {
+      await new Promise<void>((resolve) => server.close(() => resolve()));
+    }
+  });
+
+  describe('health check', () => {
+    it('should return ok', async () => {
+      server = await startServer({
+        backend: 'jsonl',
+        jsonlDir: testDir,
+        port: 3849,
+      });
+
+      const response = await fetch('http://localhost:3849/health');
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.status).toBe('ok');
+    });
+  });
+
+  describe('storage operations', () => {
+    beforeEach(async () => {
+      server = await startServer({
+        backend: 'jsonl',
+        jsonlDir: testDir,
+        port: 3849,
+      });
+    });
+
+    it('should set and get a value', async () => {
+      await fetch('http://localhost:3849/storage/set/theme', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value: 'dark' }),
+      });
+
+      const response = await fetch('http://localhost:3849/storage/get/theme');
+      const data = await response.json();
+
+      expect(data.value).toBe('dark');
+    });
+
+    it('should delete a value', async () => {
+      await fetch('http://localhost:3849/storage/set/theme', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value: 'dark' }),
+      });
+
+      await fetch('http://localhost:3849/storage/delete/theme', {
+        method: 'DELETE',
+      });
+
+      const response = await fetch('http://localhost:3849/storage/get/theme');
+      const data = await response.json();
+
+      expect(data.value).toBeNull();
+    });
+
+    it('should return 404 for unknown paths', async () => {
+      const response = await fetch('http://localhost:3849/unknown');
+      expect(response.status).toBe(404);
+    });
+
+    it('should handle batch-get', async () => {
+      await fetch('http://localhost:3849/storage/set/key1', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value: 'value1' }),
+      });
+      await fetch('http://localhost:3849/storage/set/key2', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value: 'value2' }),
+      });
+
+      const response = await fetch('http://localhost:3849/storage/batch-get', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ keys: ['key1', 'key2'] }),
+      });
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.entries.key1).toBe('value1');
+      expect(data.entries.key2).toBe('value2');
+    });
+
+    it('should handle batch-set', async () => {
+      const response = await fetch('http://localhost:3849/storage/batch-set', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ entries: { key1: 'value1', key2: 'value2' } }),
+      });
+
+      expect(response.status).toBe(200);
+
+      const get1 = await fetch('http://localhost:3849/storage/get/key1');
+      const d1 = await get1.json();
+      expect(d1.value).toBe('value1');
+
+      const get2 = await fetch('http://localhost:3849/storage/get/key2');
+      const d2 = await get2.json();
+      expect(d2.value).toBe('value2');
+    });
+
+    it('should handle batch-get with entityId', async () => {
+      await fetch('http://localhost:3849/storage/set/user-key1?entityId=user-1', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ value: 'user1-value1' }),
+      });
+
+      const response = await fetch('http://localhost:3849/storage/batch-get?entityId=user-1', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ keys: ['user-key1'] }),
+      });
+      const data = await response.json();
+
+      expect(response.status).toBe(200);
+      expect(data.entries['user-key1']).toBe('user1-value1');
+    });
+
+    it('should handle batch-set with entityId', async () => {
+      const response = await fetch('http://localhost:3849/storage/batch-set?entityId=user-2', {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ entries: { 'user-key': 'user2-value' } }),
+      });
+
+      expect(response.status).toBe(200);
+
+      const get = await fetch('http://localhost:3849/storage/get/user-key?entityId=user-2');
+      const d = await get.json();
+      expect(d.value).toBe('user2-value');
+    });
+  });
+});

package/tests/storage/jsonl.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { jsonlStorage } from '../../src/storage/jsonl';
+
+describe('jsonlStorage', () => {
+  const testDir = path.join(__dirname, '../../.test-jsonl');
+
+  beforeEach(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true });
+    }
+  });
+
+  afterEach(() => {
+    if (fs.existsSync(testDir)) {
+      fs.rmSync(testDir, { recursive: true });
+    }
+  });
+
+  describe('without entityId set', () => {
+    it('should return null for get when entityId not set', async () => {
+      const adapter = jsonlStorage({ dir: testDir });
+      const result = await adapter.storage.get('key');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('with entityId set', () => {
+    it('should return null for non-existent key', async () => {
+      const adapter = jsonlStorage({ dir: testDir });
+      adapter.setEntityId('entity1');
+      const result = await adapter.storage.get('nonexistent');
+      expect(result).toBeNull();
+    });
+
+    it('should set and get a value', async () => {
+      const adapter = jsonlStorage({ dir: testDir });
+      adapter.setEntityId('entity1');
+      await adapter.storage.set('key', 'value');
+      const result = await adapter.storage.get('key');
+      expect(result).toBe('value');
+    });
+
+    it('should get the latest value', async () => {
+      const adapter = jsonlStorage({ dir: testDir });
+      adapter.setEntityId('entity1');
+
+      await adapter.storage.set('key', 'value1');
+      await adapter.storage.set('key', 'value2');
+      await adapter.storage.set('key', 'value3');
+
+      const result = await adapter.storage.get('key');
+      expect(result).toBe('value3');
+    });
+
+    it('should remove a key', async () => {
+      const adapter = jsonlStorage({ dir: testDir });
+      adapter.setEntityId('entity1');
+
+      await adapter.storage.set('key', 'value');
+      await adapter.storage.remove('key');
+
+      const result = await adapter.storage.get('key');
+      expect(result).toBeNull();
+    });
+
+    it('should handle multiple entityIds', async () => {
+      const adapter1 = jsonlStorage({ dir: testDir });
+      const adapter2 = jsonlStorage({ dir: testDir });
+
+      adapter1.setEntityId('entity1');
+      adapter2.setEntityId('entity2');
+
+      await adapter1.storage.set('key', 'value1');
+      await adapter2.storage.set('key', 'value2');
+
+      expect(await adapter1.storage.get('key')).toBe('value1');
+      expect(await adapter2.storage.get('key')).toBe('value2');
+    });
+
+    it('should sanitize key in filename', async () => {
+      const adapter = jsonlStorage({ dir: testDir });
+      adapter.setEntityId('entity1');
+
+      await adapter.storage.set('key with spaces', 'value');
+
+      const filePath = path.join(testDir, 'entity1', 'key_with_spaces.jsonl');
+      expect(fs.existsSync(filePath)).toBe(true);
+    });
+
+    it('should handle multiple types', async () => {
+      const adapter = jsonlStorage({ dir: testDir });
+      adapter.setEntityId('entity1');
+
+      await adapter.storage.set('string', 'hello');
+      await adapter.storage.set('number', 42);
+      await adapter.storage.set('boolean', true);
+      await adapter.storage.set('array', [1, 2, 3]);
+      await adapter.storage.set('object', { a: 1 });
+
+      expect(await adapter.storage.get('string')).toBe('hello');
+      expect(await adapter.storage.get('number')).toBe(42);
+      expect(await adapter.storage.get('boolean')).toBe(true);
+      expect(await adapter.storage.get('array')).toEqual([1, 2, 3]);
+      expect(await adapter.storage.get('object')).toEqual({ a: 1 });
+    });
+
+    describe('getMultiple', () => {
+      it('should return multiple values', async () => {
+        const adapter = jsonlStorage({ dir: testDir });
+        adapter.setEntityId('entity1');
+
+        await adapter.storage.set('key1', 'value1');
+        await adapter.storage.set('key2', 'value2');
+        await adapter.storage.set('key3', 'value3');
+
+        const result = await adapter.storage.getMultiple(['key1', 'key2', 'key3']);
+
+        expect(result.size).toBe(3);
+        expect(result.get('key1')).toBe('value1');
+        expect(result.get('key2')).toBe('value2');
+        expect(result.get('key3')).toBe('value3');
+      });
+    });
+
+    it('should have correct name', () => {
+      const adapter = jsonlStorage({ dir: testDir });
+      expect(adapter.name).toBe('jsonl');
+    });
+  });
+});

package/tests/storage/memory.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect } from 'vitest';
+import { memoryStorage } from '../../src/storage/memory';
+
+describe('memoryStorage', () => {
+  it('should return null for non-existent key', async () => {
+    const adapter = memoryStorage();
+    const result = await adapter.storage.get('nonexistent');
+    expect(result).toBeNull();
+  });
+
+  it('should set and get a value', async () => {
+    const adapter = memoryStorage();
+    await adapter.storage.set('key', 'value');
+    const result = await adapter.storage.get('key');
+    expect(result).toBe('value');
+  });
+
+  it('should overwrite existing value', async () => {
+    const adapter = memoryStorage();
+    await adapter.storage.set('key', 'value1');
+    await adapter.storage.set('key', 'value2');
+    const result = await adapter.storage.get('key');
+    expect(result).toBe('value2');
+  });
+
+  it('should remove a value', async () => {
+    const adapter = memoryStorage();
+    await adapter.storage.set('key', 'value');
+    await adapter.storage.remove('key');
+    const result = await adapter.storage.get('key');
+    expect(result).toBeNull();
+  });
+
+  it('should handle multiple types', async () => {
+    const adapter = memoryStorage();
+
+    await adapter.storage.set('string', 'hello');
+    await adapter.storage.set('number', 42);
+    await adapter.storage.set('boolean', true);
+    await adapter.storage.set('array', [1, 2, 3]);
+    await adapter.storage.set('object', { a: 1 });
+
+    expect(await adapter.storage.get('string')).toBe('hello');
+    expect(await adapter.storage.get('number')).toBe(42);
+    expect(await adapter.storage.get('boolean')).toBe(true);
+    expect(await adapter.storage.get('array')).toEqual([1, 2, 3]);
+    expect(await adapter.storage.get('object')).toEqual({ a: 1 });
+  });
+
+  describe('getMultiple', () => {
+    it('should return multiple values', async () => {
+      const adapter = memoryStorage();
+      await adapter.storage.set('key1', 'value1');
+      await adapter.storage.set('key2', 'value2');
+      await adapter.storage.set('key3', 'value3');
+
+      const result = await adapter.storage.getMultiple(['key1', 'key2', 'key3']);
+
+      expect(result.size).toBe(3);
+      expect(result.get('key1')).toBe('value1');
+      expect(result.get('key2')).toBe('value2');
+      expect(result.get('key3')).toBe('value3');
+    });
+
+    it('should skip non-existent keys', async () => {
+      const adapter = memoryStorage();
+      await adapter.storage.set('key1', 'value1');
+
+      const result = await adapter.storage.getMultiple(['key1', 'nonexistent']);
+
+      expect(result.size).toBe(1);
+      expect(result.get('key1')).toBe('value1');
+    });
+
+    it('should return empty map for empty input', async () => {
+      const adapter = memoryStorage();
+      const result = await adapter.storage.getMultiple([]);
+      expect(result.size).toBe(0);
+    });
+  });
+
+  describe('setMultiple', () => {
+    it('should set multiple values', async () => {
+      const adapter = memoryStorage();
+      const entries = new Map([
+        ['key1', 'value1'],
+        ['key2', 'value2'],
+      ]);
+
+      await adapter.storage.setMultiple(entries);
+
+      expect(await adapter.storage.get('key1')).toBe('value1');
+      expect(await adapter.storage.get('key2')).toBe('value2');
+    });
+  });
+
+  it('should have correct name', () => {
+    const adapter = memoryStorage();
+    expect(adapter.name).toBe('memory');
+  });
+});

package/tests/storage/mongodb.test.ts

@@ -0,0 +1,40 @@
+import { describe, it, expect } from 'vitest';
+import type { Storage, StorageAdapter } from '../../src/storage/base';
+
+describe('mongodbStorage interface contract', () => {
+  describe('Storage interface', () => {
+    it('should define complete storage interface', () => {
+      const storageInterface: Storage = {
+        get: async <T>(_key: string): Promise<T | null> => null,
+        set: async <T>(_key: string, _value: T): Promise<void> => {},
+        remove: async (_key: string): Promise<void> => {},
+        getMultiple: async <T>(_keys: string[]): Promise<Map<string, T>> => new Map(),
+        setMultiple: async <T>(_entries: Map<string, T>): Promise<void> => {},
+      };
+
+      expect(typeof storageInterface.get).toBe('function');
+      expect(typeof storageInterface.set).toBe('function');
+      expect(typeof storageInterface.remove).toBe('function');
+      expect(typeof storageInterface.getMultiple).toBe('function');
+      expect(typeof storageInterface.setMultiple).toBe('function');
+    });
+  });
+
+  describe('StorageAdapter interface', () => {
+    it('should define storage adapter with name and storage', () => {
+      const adapter: StorageAdapter = {
+        storage: {
+          get: async <T>(_key: string): Promise<T | null> => null,
+          set: async <T>(_key: string, _value: T): Promise<void> => {},
+          remove: async (_key: string): Promise<void> => {},
+        },
+        name: 'mongodb',
+      };
+
+      expect(adapter.name).toBe('mongodb');
+      expect(adapter.storage).toBeDefined();
+      expect(typeof adapter.storage.get).toBe('function');
+      expect(typeof adapter.storage.set).toBe('function');
+    });
+  });
+});

package/tests/storage/remoteStorage.test.ts

@@ -0,0 +1,126 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { remoteStorage } from '../../src/storage/adapters/remoteStorage';
+
+describe('remoteStorage', () => {
+  const originalFetch = globalThis.fetch;
+
+  beforeEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('basic creation', () => {
+    it('should create adapter with default baseUrl', () => {
+      const adapter = remoteStorage();
+      expect(adapter.name).toBe('remote');
+      expect(adapter.storage).toBeDefined();
+      expect(typeof adapter.storage.get).toBe('function');
+      expect(typeof adapter.storage.set).toBe('function');
+      expect(typeof adapter.storage.remove).toBe('function');
+    });
+
+    it('should create adapter with custom baseUrl', () => {
+      const adapter = remoteStorage({ baseUrl: 'http://custom:9999' });
+      expect(adapter.name).toBe('remote');
+      expect(adapter.storage).toBeDefined();
+    });
+
+    it('should implement setEntityId', () => {
+      const adapter = remoteStorage();
+      expect(typeof adapter.setEntityId).toBe('function');
+    });
+  });
+
+  describe('storage operations', () => {
+    beforeEach(() => {
+      globalThis.fetch = vi.fn();
+    });
+
+    afterEach(() => {
+      globalThis.fetch = originalFetch;
+    });
+
+    it('should call fetch for get', async () => {
+      const mockResponse = {
+        ok: true,
+        statusText: 'OK',
+        json: vi.fn().mockResolvedValue({ value: 'test-value' }),
+      };
+      (globalThis.fetch as any).mockResolvedValue(mockResponse);
+
+      const adapter = remoteStorage({ baseUrl: 'http://localhost:3847' });
+      const result = await adapter.storage.get('theme');
+
+      expect(globalThis.fetch).toHaveBeenCalledWith('http://localhost:3847/storage/get/theme');
+      expect(result).toBe('test-value');
+    });
+
+    it('should call fetch for set with POST', async () => {
+      const mockResponse = {
+        ok: true,
+        json: vi.fn().mockResolvedValue({ success: true }),
+      };
+      (globalThis.fetch as any).mockResolvedValue(mockResponse);
+
+      const adapter = remoteStorage();
+      await adapter.storage.set('theme', 'dark');
+
+      expect(globalThis.fetch).toHaveBeenCalledWith(
+        'http://localhost:3847/storage/set/theme',
+        expect.objectContaining({ method: 'POST' })
+      );
+    });
+
+    it('should call fetch for remove with DELETE', async () => {
+      const mockResponse = {
+        ok: true,
+        json: vi.fn().mockResolvedValue({ success: true }),
+      };
+      (globalThis.fetch as any).mockResolvedValue(mockResponse);
+
+      const adapter = remoteStorage();
+      await adapter.storage.remove('theme');
+
+      expect(globalThis.fetch).toHaveBeenCalledWith(
+        'http://localhost:3847/storage/delete/theme',
+        expect.objectContaining({ method: 'DELETE' })
+      );
+    });
+
+    it('should handle getMultiple', async () => {
+      const mockResponse = {
+        ok: true,
+        json: vi.fn().mockResolvedValue({
+          entries: { key1: 'value1', key2: 'value2' },
+        }),
+      };
+      (globalThis.fetch as any).mockResolvedValue(mockResponse);
+
+      const adapter = remoteStorage();
+      const result = await adapter.storage.getMultiple(['key1', 'key2']);
+
+      expect(globalThis.fetch).toHaveBeenCalledWith(
+        'http://localhost:3847/storage/batch-get',
+        expect.objectContaining({ method: 'POST' })
+      );
+      expect(result.get('key1')).toBe('value1');
+      expect(result.get('key2')).toBe('value2');
+    });
+
+    it('should handle setMultiple', async () => {
+      const mockResponse = {
+        ok: true,
+        json: vi.fn().mockResolvedValue({ success: true }),
+      };
+      (globalThis.fetch as any).mockResolvedValue(mockResponse);
+
+      const adapter = remoteStorage();
+      const entries = new Map([['key1', 'value1'], ['key2', 'value2']]);
+      await adapter.storage.setMultiple(entries);
+
+      expect(globalThis.fetch).toHaveBeenCalledWith(
+        'http://localhost:3847/storage/batch-set',
+        expect.objectContaining({ method: 'POST' })
+      );
+    });
+  });
+});