bluera-knowledge 0.9.21

package/src/services/store.service.test.ts

@@ -0,0 +1,474 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { StoreService } from './store.service.js';
+import { rm, mkdtemp } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+describe('StoreService', () => {
+  let storeService: StoreService;
+  let tempDir: string;
+
+  beforeEach(async () => {
+    tempDir = await mkdtemp(join(tmpdir(), 'store-test-'));
+    storeService = new StoreService(tempDir);
+    await storeService.initialize();
+  });
+
+  afterEach(async () => {
+    await rm(tempDir, { recursive: true, force: true });
+  });
+
+  it('creates a file store', async () => {
+    const result = await storeService.create({
+      name: 'My Files',
+      type: 'file',
+      path: tempDir,
+    });
+
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.name).toBe('My Files');
+      expect(result.data.type).toBe('file');
+    }
+  });
+
+  it('lists all stores', async () => {
+    const dir1 = await mkdtemp(join(tmpdir(), 'store1-'));
+    const dir2 = await mkdtemp(join(tmpdir(), 'store2-'));
+    await storeService.create({ name: 'Store 1', type: 'file', path: dir1 });
+    await storeService.create({ name: 'Store 2', type: 'file', path: dir2 });
+
+    const stores = await storeService.list();
+    expect(stores).toHaveLength(2);
+
+    await rm(dir1, { recursive: true, force: true });
+    await rm(dir2, { recursive: true, force: true });
+  });
+
+  it('gets store by ID', async () => {
+    const createResult = await storeService.create({
+      name: 'Test Store',
+      type: 'file',
+      path: tempDir,
+    });
+
+    if (!createResult.success) throw new Error('Create failed');
+
+    const store = await storeService.get(createResult.data.id);
+    expect(store?.name).toBe('Test Store');
+  });
+
+  it('gets store by name', async () => {
+    await storeService.create({
+      name: 'Named Store',
+      type: 'file',
+      path: tempDir,
+    });
+
+    const store = await storeService.getByName('Named Store');
+    expect(store?.name).toBe('Named Store');
+  });
+
+  it('deletes a store', async () => {
+    const createResult = await storeService.create({
+      name: 'To Delete',
+      type: 'file',
+      path: tempDir,
+    });
+
+    if (!createResult.success) throw new Error('Create failed');
+
+    const deleteResult = await storeService.delete(createResult.data.id);
+    expect(deleteResult.success).toBe(true);
+
+    const stores = await storeService.list();
+    expect(stores).toHaveLength(0);
+  });
+
+  describe('create file store', () => {
+    it('creates file store with description', async () => {
+      const result = await storeService.create({
+        name: 'Described Files',
+        type: 'file',
+        path: tempDir,
+        description: 'My file collection'
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.description).toBe('My file collection');
+      }
+    });
+
+    it('creates file store with tags', async () => {
+      const result = await storeService.create({
+        name: 'Tagged Files',
+        type: 'file',
+        path: tempDir,
+        tags: ['important', 'work']
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.tags).toEqual(['important', 'work']);
+      }
+    });
+
+    it('returns error when path not provided for file store', async () => {
+      const result = await storeService.create({
+        name: 'No Path',
+        type: 'file'
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.message).toContain('Path is required');
+      }
+    });
+
+    it('returns error when path does not exist', async () => {
+      const result = await storeService.create({
+        name: 'Bad Path',
+        type: 'file',
+        path: '/nonexistent/path'
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.message).toContain('Directory does not exist');
+      }
+    });
+  });
+
+  describe('create repo store', () => {
+    it('creates repo store with path', async () => {
+      const result = await storeService.create({
+        name: 'My Repo',
+        type: 'repo',
+        path: tempDir
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.type).toBe('repo');
+        expect(result.data.path).toBe(tempDir);
+      }
+    });
+
+    it('creates repo store with branch', async () => {
+      const result = await storeService.create({
+        name: 'Branched Repo',
+        type: 'repo',
+        path: tempDir,
+        branch: 'develop'
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.branch).toBe('develop');
+      }
+    });
+
+    it('returns error when neither path nor URL provided for repo', async () => {
+      const result = await storeService.create({
+        name: 'No Path No URL',
+        type: 'repo'
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.message).toContain('Path or URL required');
+      }
+    });
+  });
+
+  describe('create web store', () => {
+    it('creates web store with URL', async () => {
+      const result = await storeService.create({
+        name: 'My Website',
+        type: 'web',
+        url: 'https://example.com'
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.type).toBe('web');
+        expect(result.data.url).toBe('https://example.com');
+      }
+    });
+
+    it('creates web store with depth', async () => {
+      const result = await storeService.create({
+        name: 'Deep Site',
+        type: 'web',
+        url: 'https://example.com',
+        depth: 3
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.depth).toBe(3);
+      }
+    });
+
+    it('uses default depth of 1 when not specified', async () => {
+      const result = await storeService.create({
+        name: 'Default Depth',
+        type: 'web',
+        url: 'https://example.com'
+      });
+
+      expect(result.success).toBe(true);
+      if (result.success) {
+        expect(result.data.depth).toBe(1);
+      }
+    });
+
+    it('returns error when URL not provided for web store', async () => {
+      const result = await storeService.create({
+        name: 'No URL',
+        type: 'web'
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.message).toContain('URL is required');
+      }
+    });
+  });
+
+  describe('duplicate name handling', () => {
+    it('returns error when creating store with duplicate name', async () => {
+      const dir1 = await mkdtemp(join(tmpdir(), 'dup1-'));
+      const dir2 = await mkdtemp(join(tmpdir(), 'dup2-'));
+
+      await storeService.create({
+        name: 'Duplicate',
+        type: 'file',
+        path: dir1
+      });
+
+      const result = await storeService.create({
+        name: 'Duplicate',
+        type: 'file',
+        path: dir2
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.message).toContain('already exists');
+      }
+
+      await rm(dir1, { recursive: true, force: true });
+      await rm(dir2, { recursive: true, force: true });
+    });
+  });
+
+  describe('list with filter', () => {
+    it('lists only file stores when type filter is file', async () => {
+      const fileDir = await mkdtemp(join(tmpdir(), 'file1-'));
+      const repoDir = await mkdtemp(join(tmpdir(), 'repo1-'));
+      await storeService.create({ name: 'File 1', type: 'file', path: fileDir });
+      await storeService.create({ name: 'Repo 1', type: 'repo', path: repoDir });
+      await storeService.create({ name: 'Web 1', type: 'web', url: 'https://example.com' });
+
+      const stores = await storeService.list('file');
+      expect(stores).toHaveLength(1);
+      expect(stores[0].type).toBe('file');
+
+      await rm(fileDir, { recursive: true, force: true });
+      await rm(repoDir, { recursive: true, force: true });
+    });
+
+    it('lists only repo stores when type filter is repo', async () => {
+      const fileDir = await mkdtemp(join(tmpdir(), 'file1-'));
+      const repoDir = await mkdtemp(join(tmpdir(), 'repo1-'));
+      await storeService.create({ name: 'File 1', type: 'file', path: fileDir });
+      await storeService.create({ name: 'Repo 1', type: 'repo', path: repoDir });
+      await storeService.create({ name: 'Web 1', type: 'web', url: 'https://example.com' });
+
+      const stores = await storeService.list('repo');
+      expect(stores).toHaveLength(1);
+      expect(stores[0].type).toBe('repo');
+
+      await rm(fileDir, { recursive: true, force: true });
+      await rm(repoDir, { recursive: true, force: true });
+    });
+
+    it('lists only web stores when type filter is web', async () => {
+      const fileDir = await mkdtemp(join(tmpdir(), 'file1-'));
+      const repoDir = await mkdtemp(join(tmpdir(), 'repo1-'));
+      await storeService.create({ name: 'File 1', type: 'file', path: fileDir });
+      await storeService.create({ name: 'Repo 1', type: 'repo', path: repoDir });
+      await storeService.create({ name: 'Web 1', type: 'web', url: 'https://example.com' });
+
+      const stores = await storeService.list('web');
+      expect(stores).toHaveLength(1);
+      expect(stores[0].type).toBe('web');
+
+      await rm(fileDir, { recursive: true, force: true });
+      await rm(repoDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('getByIdOrName', () => {
+    it('finds store by ID', async () => {
+      const createResult = await storeService.create({
+        name: 'Test Store',
+        type: 'file',
+        path: tempDir
+      });
+
+      if (!createResult.success) throw new Error('Create failed');
+
+      const store = await storeService.getByIdOrName(createResult.data.id);
+      expect(store?.name).toBe('Test Store');
+    });
+
+    it('finds store by name', async () => {
+      await storeService.create({
+        name: 'Test Store',
+        type: 'file',
+        path: tempDir
+      });
+
+      const store = await storeService.getByIdOrName('Test Store');
+      expect(store?.name).toBe('Test Store');
+    });
+
+    it('returns undefined when store not found', async () => {
+      const store = await storeService.getByIdOrName('nonexistent');
+      expect(store).toBeUndefined();
+    });
+  });
+
+  describe('update store', () => {
+    it('updates store name', async () => {
+      const createResult = await storeService.create({
+        name: 'Original Name',
+        type: 'file',
+        path: tempDir
+      });
+
+      if (!createResult.success) throw new Error('Create failed');
+
+      const updateResult = await storeService.update(createResult.data.id, {
+        name: 'Updated Name'
+      });
+
+      expect(updateResult.success).toBe(true);
+      if (updateResult.success) {
+        expect(updateResult.data.name).toBe('Updated Name');
+      }
+    });
+
+    it('updates store description', async () => {
+      const createResult = await storeService.create({
+        name: 'Test Store',
+        type: 'file',
+        path: tempDir
+      });
+
+      if (!createResult.success) throw new Error('Create failed');
+
+      const updateResult = await storeService.update(createResult.data.id, {
+        description: 'New description'
+      });
+
+      expect(updateResult.success).toBe(true);
+      if (updateResult.success) {
+        expect(updateResult.data.description).toBe('New description');
+      }
+    });
+
+    it('updates store tags', async () => {
+      const createResult = await storeService.create({
+        name: 'Test Store',
+        type: 'file',
+        path: tempDir
+      });
+
+      if (!createResult.success) throw new Error('Create failed');
+
+      const updateResult = await storeService.update(createResult.data.id, {
+        tags: ['new', 'tags']
+      });
+
+      expect(updateResult.success).toBe(true);
+      if (updateResult.success) {
+        expect(updateResult.data.tags).toEqual(['new', 'tags']);
+      }
+    });
+
+    it('updates updatedAt timestamp', async () => {
+      const createResult = await storeService.create({
+        name: 'Test Store',
+        type: 'file',
+        path: tempDir
+      });
+
+      if (!createResult.success) throw new Error('Create failed');
+      const originalUpdatedAt = createResult.data.updatedAt;
+
+      // Wait a bit to ensure timestamp is different
+      await new Promise(resolve => setTimeout(resolve, 10));
+
+      const updateResult = await storeService.update(createResult.data.id, {
+        name: 'Updated'
+      });
+
+      expect(updateResult.success).toBe(true);
+      if (updateResult.success) {
+        expect(updateResult.data.updatedAt.getTime()).toBeGreaterThan(originalUpdatedAt.getTime());
+      }
+    });
+
+    it('returns error when updating nonexistent store', async () => {
+      const result = await storeService.update('nonexistent-id' as any, {
+        name: 'Updated'
+      });
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.message).toContain('Store not found');
+      }
+    });
+  });
+
+  describe('delete store', () => {
+    it('returns error when deleting nonexistent store', async () => {
+      const result = await storeService.delete('nonexistent-id' as any);
+
+      expect(result.success).toBe(false);
+      if (!result.success) {
+        expect(result.error.message).toContain('Store not found');
+      }
+    });
+  });
+
+  describe('persistence', () => {
+    it('persists stores across service instances', async () => {
+      const storeDir = await mkdtemp(join(tmpdir(), 'persist-'));
+      await storeService.create({
+        name: 'Persistent Store',
+        type: 'file',
+        path: storeDir
+      });
+
+      // Create new service instance with same data dir
+      const newService = new StoreService(tempDir);
+      await newService.initialize();
+
+      const stores = await newService.list();
+      expect(stores).toHaveLength(1);
+      expect(stores[0].name).toBe('Persistent Store');
+
+      await rm(storeDir, { recursive: true, force: true });
+    });
+
+    it('initializes with empty stores when no registry file exists', async () => {
+      const stores = await storeService.list();
+      expect(stores).toHaveLength(0);
+    });
+  });
+});

package/src/services/store.service.ts

@@ -0,0 +1,225 @@
+import { readFile, writeFile, mkdir, stat } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import type { Store, FileStore, RepoStore, WebStore, StoreType } from '../types/store.js';
+import type { StoreId } from '../types/brands.js';
+import { createStoreId } from '../types/brands.js';
+import type { Result } from '../types/result.js';
+import { ok, err } from '../types/result.js';
+import { cloneRepository } from '../plugin/git-clone.js';
+
+export interface CreateStoreInput {
+  name: string;
+  type: StoreType;
+  path?: string | undefined;
+  url?: string | undefined;
+  description?: string | undefined;
+  tags?: string[] | undefined;
+  branch?: string | undefined;
+  depth?: number | undefined;
+}
+
+interface StoreRegistry {
+  stores: Store[];
+}
+
+export class StoreService {
+  private readonly dataDir: string;
+  private registry: StoreRegistry = { stores: [] };
+
+  constructor(dataDir: string) {
+    this.dataDir = dataDir;
+  }
+
+  async initialize(): Promise<void> {
+    await mkdir(this.dataDir, { recursive: true });
+    await this.loadRegistry();
+  }
+
+  async create(input: CreateStoreInput): Promise<Result<Store>> {
+    const existing = await this.getByName(input.name);
+    if (existing !== undefined) {
+      return err(new Error(`Store with name "${input.name}" already exists`));
+    }
+
+    const id = createStoreId(randomUUID());
+    const now = new Date();
+
+    let store: Store;
+
+    switch (input.type) {
+      case 'file': {
+        if (input.path === undefined) {
+          return err(new Error('Path is required for file stores'));
+        }
+        // Normalize path to absolute path (security: prevents path confusion)
+        const normalizedPath = resolve(input.path);
+        // Validate directory exists
+        try {
+          const stats = await stat(normalizedPath);
+          if (!stats.isDirectory()) {
+            return err(new Error(`Path is not a directory: ${normalizedPath}`));
+          }
+        } catch {
+          return err(new Error(`Directory does not exist: ${normalizedPath}`));
+        }
+        store = {
+          type: 'file',
+          id,
+          name: input.name,
+          path: normalizedPath,
+          description: input.description,
+          tags: input.tags,
+          status: 'ready',
+          createdAt: now,
+          updatedAt: now,
+        } satisfies FileStore;
+        break;
+      }
+
+      case 'repo': {
+        let repoPath = input.path;
+
+        // If URL provided, clone it
+        if (input.url !== undefined) {
+          const cloneDir = join(this.dataDir, 'repos', id);
+          const result = await cloneRepository({
+            url: input.url,
+            targetDir: cloneDir,
+            ...(input.branch !== undefined ? { branch: input.branch } : {}),
+            depth: input.depth ?? 1
+          });
+
+          if (!result.success) {
+            return err(result.error);
+          }
+          repoPath = result.data;
+        }
+
+        if (repoPath === undefined) {
+          return err(new Error('Path or URL required for repo stores'));
+        }
+
+        // Normalize path to absolute path (security: prevents path confusion)
+        const normalizedRepoPath = resolve(repoPath);
+
+        store = {
+          type: 'repo',
+          id,
+          name: input.name,
+          path: normalizedRepoPath,
+          url: input.url,
+          branch: input.branch,
+          description: input.description,
+          tags: input.tags,
+          status: 'ready',
+          createdAt: now,
+          updatedAt: now,
+        } satisfies RepoStore;
+        break;
+      }
+
+      case 'web':
+        if (input.url === undefined) {
+          return err(new Error('URL is required for web stores'));
+        }
+        store = {
+          type: 'web',
+          id,
+          name: input.name,
+          url: input.url,
+          depth: input.depth ?? 1,
+          description: input.description,
+          tags: input.tags,
+          status: 'ready',
+          createdAt: now,
+          updatedAt: now,
+        } satisfies WebStore;
+        break;
+    }
+
+    this.registry.stores.push(store);
+    await this.saveRegistry();
+
+    return ok(store);
+  }
+
+  async list(type?: StoreType): Promise<Store[]> {
+    if (type !== undefined) {
+      return Promise.resolve(this.registry.stores.filter((s) => s.type === type));
+    }
+    return Promise.resolve([...this.registry.stores]);
+  }
+
+  async get(id: StoreId): Promise<Store | undefined> {
+    return Promise.resolve(this.registry.stores.find((s) => s.id === id));
+  }
+
+  async getByName(name: string): Promise<Store | undefined> {
+    return Promise.resolve(this.registry.stores.find((s) => s.name === name));
+  }
+
+  async getByIdOrName(idOrName: string): Promise<Store | undefined> {
+    return Promise.resolve(this.registry.stores.find((s) => s.id === idOrName || s.name === idOrName));
+  }
+
+  async update(id: StoreId, updates: Partial<Pick<Store, 'name' | 'description' | 'tags'>>): Promise<Result<Store>> {
+    const index = this.registry.stores.findIndex((s) => s.id === id);
+    if (index === -1) {
+      return err(new Error(`Store not found: ${id}`));
+    }
+
+    const store = this.registry.stores[index];
+    if (store === undefined) {
+      return err(new Error(`Store not found: ${id}`));
+    }
+
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const updated = {
+      ...store,
+      ...updates,
+      updatedAt: new Date(),
+    } as Store;
+
+    this.registry.stores[index] = updated;
+    await this.saveRegistry();
+
+    return ok(updated);
+  }
+
+  async delete(id: StoreId): Promise<Result<void>> {
+    const index = this.registry.stores.findIndex((s) => s.id === id);
+    if (index === -1) {
+      return err(new Error(`Store not found: ${id}`));
+    }
+
+    this.registry.stores.splice(index, 1);
+    await this.saveRegistry();
+
+    return ok(undefined);
+  }
+
+  private async loadRegistry(): Promise<void> {
+    const registryPath = join(this.dataDir, 'stores.json');
+    try {
+      const content = await readFile(registryPath, 'utf-8');
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      const data = JSON.parse(content) as { stores: Store[] };
+      this.registry = {
+        stores: data.stores.map((s) => ({
+          ...s,
+          id: createStoreId(s.id),
+          createdAt: new Date(s.createdAt),
+          updatedAt: new Date(s.updatedAt),
+        })),
+      };
+    } catch {
+      this.registry = { stores: [] };
+    }
+  }
+
+  private async saveRegistry(): Promise<void> {
+    const registryPath = join(this.dataDir, 'stores.json');
+    await writeFile(registryPath, JSON.stringify(this.registry, null, 2));
+  }
+}