efarmz-slackbot-data 1.0.0

package/src/infrastructure/persistence/InMemoryConversationRepository.test.ts

@@ -0,0 +1,325 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import InMemoryConversationRepository from "./InMemoryConversationRepository.js";
+import Conversation from "@/domain/entities/Conversation.js";
+import ThreadId from "@/domain/value-objects/ThreadId.js";
+
+describe(`InMemoryConversationRepository`, () => {
+  let repository: InMemoryConversationRepository;
+  const maxThreads = 3;
+  const ttlMs = 1000;
+
+  beforeEach(() => {
+    repository = new InMemoryConversationRepository(maxThreads, ttlMs);
+    vi.useFakeTimers();
+  });
+
+  afterEach(() => {
+    vi.useRealTimers();
+  });
+
+  describe(`CRUD operations`, () => {
+    it(`should save and retrieve a conversation`, async () => {
+      const threadId = ThreadId.create(`C123`, `1234567890.123456`);
+      const conversation = Conversation.create(threadId);
+
+      await repository.save(conversation);
+      const retrieved = await repository.get(threadId);
+
+      expect(retrieved).toEqual(conversation);
+    });
+
+    it(`should return null for non-existent conversation`, async () => {
+      const threadId = ThreadId.create(`C999`, `9999999999.999999`);
+
+      const retrieved = await repository.get(threadId);
+
+      expect(retrieved).toBeNull();
+    });
+
+    it(`should purge a conversation`, async () => {
+      const threadId = ThreadId.create(`C123`, `1234567890.123456`);
+      const conversation = Conversation.create(threadId);
+
+      await repository.save(conversation);
+      await repository.purge(threadId);
+      const retrieved = await repository.get(threadId);
+
+      expect(retrieved).toBeNull();
+    });
+
+    it(`should update conversation on save`, async () => {
+      const threadId = ThreadId.create(`C123`, `1234567890.123456`);
+      let conversation = Conversation.create(threadId);
+
+      await repository.save(conversation);
+
+      // Create a message and append it
+      const updatedConversation = conversation;
+
+      await repository.save(updatedConversation);
+      const retrieved = await repository.get(threadId);
+
+      expect(retrieved).toEqual(updatedConversation);
+    });
+  });
+
+  describe(`TTL expiration`, () => {
+    it(`should return null if TTL expired on get`, async () => {
+      const threadId = ThreadId.create(`C123`, `1234567890.123456`);
+      const conversation = Conversation.create(threadId);
+
+      await repository.save(conversation);
+
+      vi.advanceTimersByTime(ttlMs + 1);
+
+      const retrieved = await repository.get(threadId);
+
+      expect(retrieved).toBeNull();
+    });
+
+    it(`should delete expired entry from cache on get`, async () => {
+      const threadId = ThreadId.create(`C123`, `1234567890.123456`);
+      const conversation = Conversation.create(threadId);
+
+      await repository.save(conversation);
+
+      vi.advanceTimersByTime(ttlMs + 1);
+
+      await repository.get(threadId);
+
+      const retrievedAgain = await repository.get(threadId);
+
+      expect(retrievedAgain).toBeNull();
+    });
+
+    it(`should update lastAccess on read before TTL expires`, async () => {
+      const threadId = ThreadId.create(`C123`, `1234567890.123456`);
+      const conversation = Conversation.create(threadId);
+
+      await repository.save(conversation);
+
+      vi.advanceTimersByTime(ttlMs / 2);
+
+      const retrieved1 = await repository.get(threadId);
+
+      expect(retrieved1).toEqual(conversation);
+
+      vi.advanceTimersByTime(ttlMs / 2);
+
+      const retrieved2 = await repository.get(threadId);
+
+      expect(retrieved2).toEqual(conversation);
+
+      vi.advanceTimersByTime(ttlMs + 1);
+
+      const retrieved3 = await repository.get(threadId);
+
+      expect(retrieved3).toBeNull();
+    });
+
+    it(`should handle multiple entries with different TTL states`, async () => {
+      const threadId1 = ThreadId.create(`C1`, `111111111.111111`);
+      const threadId2 = ThreadId.create(`C2`, `222222222.222222`);
+      const threadId3 = ThreadId.create(`C3`, `333333333.333333`);
+
+      const conv1 = Conversation.create(threadId1);
+      const conv2 = Conversation.create(threadId2);
+      const conv3 = Conversation.create(threadId3);
+
+      await repository.save(conv1);
+
+      vi.advanceTimersByTime(300);
+
+      await repository.save(conv2);
+
+      vi.advanceTimersByTime(300);
+
+      await repository.save(conv3);
+
+      vi.advanceTimersByTime(500);
+
+      const retrieved1 = await repository.get(threadId1);
+      expect(retrieved1).toBeNull();
+
+      const retrieved2 = await repository.get(threadId2);
+      expect(retrieved2).toEqual(conv2);
+
+      const retrieved3 = await repository.get(threadId3);
+      expect(retrieved3).toEqual(conv3);
+    });
+  });
+
+  describe(`LRU eviction`, () => {
+    it(`should evict LRU entry when cache is full`, async () => {
+      const threadId1 = ThreadId.create(`C1`, `111111111.111111`);
+      const threadId2 = ThreadId.create(`C2`, `222222222.222222`);
+      const threadId3 = ThreadId.create(`C3`, `333333333.333333`);
+      const threadId4 = ThreadId.create(`C4`, `444444444.444444`);
+
+      const conv1 = Conversation.create(threadId1);
+      const conv2 = Conversation.create(threadId2);
+      const conv3 = Conversation.create(threadId3);
+      const conv4 = Conversation.create(threadId4);
+
+      await repository.save(conv1);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv2);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv3);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv4);
+
+      const retrieved1 = await repository.get(threadId1);
+      expect(retrieved1).toBeNull();
+
+      const retrieved2 = await repository.get(threadId2);
+      expect(retrieved2).toEqual(conv2);
+
+      const retrieved3 = await repository.get(threadId3);
+      expect(retrieved3).toEqual(conv3);
+
+      const retrieved4 = await repository.get(threadId4);
+      expect(retrieved4).toEqual(conv4);
+    });
+
+    it(`should evict correct LRU entry among multiple items`, async () => {
+      const threadId1 = ThreadId.create(`C1`, `111111111.111111`);
+      const threadId2 = ThreadId.create(`C2`, `222222222.222222`);
+      const threadId3 = ThreadId.create(`C3`, `333333333.333333`);
+      const threadId4 = ThreadId.create(`C4`, `444444444.444444`);
+
+      const conv1 = Conversation.create(threadId1);
+      const conv2 = Conversation.create(threadId2);
+      const conv3 = Conversation.create(threadId3);
+      const conv4 = Conversation.create(threadId4);
+
+      await repository.save(conv1);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv2);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv3);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.get(threadId1);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv4);
+
+      const retrieved2 = await repository.get(threadId2);
+      expect(retrieved2).toBeNull();
+    });
+
+    it(`should not evict when saving existing entry`, async () => {
+      const threadId1 = ThreadId.create(`C1`, `111111111.111111`);
+      const threadId2 = ThreadId.create(`C2`, `222222222.222222`);
+      const threadId3 = ThreadId.create(`C3`, `333333333.333333`);
+
+      const conv1 = Conversation.create(threadId1);
+      const conv2 = Conversation.create(threadId2);
+      const conv3 = Conversation.create(threadId3);
+
+      await repository.save(conv1);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv2);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv3);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv1);
+
+      const retrieved1 = await repository.get(threadId1);
+      expect(retrieved1).toEqual(conv1);
+
+      const retrieved2 = await repository.get(threadId2);
+      expect(retrieved2).toEqual(conv2);
+
+      const retrieved3 = await repository.get(threadId3);
+      expect(retrieved3).toEqual(conv3);
+    });
+
+    it(`should handle cache at capacity with all items active`, async () => {
+      const threadIds = [
+        ThreadId.create(`C1`, `111111111.111111`),
+        ThreadId.create(`C2`, `222222222.222222`),
+        ThreadId.create(`C3`, `333333333.333333`),
+        ThreadId.create(`C4`, `444444444.444444`),
+      ];
+
+      const conversations = threadIds.map((tid) => Conversation.create(tid));
+
+      for (const conv of conversations.slice(0, 3)) {
+        await repository.save(conv);
+        vi.advanceTimersByTime(100);
+      }
+
+      await repository.save(conversations[3]!);
+
+      const retrieved0 = await repository.get(threadIds[0]!);
+      expect(retrieved0).toBeNull();
+
+      for (let i = 1; i < 4; i++) {
+        const retrieved = await repository.get(threadIds[i]!);
+        expect(retrieved).toEqual(conversations[i]!);
+      }
+    });
+  });
+
+  describe(`combined TTL and LRU`, () => {
+    it(`should handle TTL expiration with LRU eviction`, async () => {
+      const threadId1 = ThreadId.create(`C1`, `111111111.111111`);
+      const threadId2 = ThreadId.create(`C2`, `222222222.222222`);
+      const threadId3 = ThreadId.create(`C3`, `333333333.333333`);
+      const threadId4 = ThreadId.create(`C4`, `444444444.444444`);
+
+      const conv1 = Conversation.create(threadId1);
+      const conv2 = Conversation.create(threadId2);
+      const conv3 = Conversation.create(threadId3);
+      const conv4 = Conversation.create(threadId4);
+
+      await repository.save(conv1);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv2);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv3);
+
+      vi.advanceTimersByTime(100);
+
+      await repository.save(conv4);
+
+      vi.advanceTimersByTime(850);
+
+      const retrieved1 = await repository.get(threadId1);
+      expect(retrieved1).toBeNull();
+
+      const retrieved2 = await repository.get(threadId2);
+      expect(retrieved2).toBeNull();
+
+      const retrieved3 = await repository.get(threadId3);
+      expect(retrieved3).toEqual(conv3);
+
+      const retrieved4 = await repository.get(threadId4);
+      expect(retrieved4).toEqual(conv4);
+    });
+  });
+});

package/src/infrastructure/persistence/InMemoryConversationRepository.ts

@@ -0,0 +1,69 @@
+import type ConversationRepository from "@/domain/ports/ConversationRepository.js";
+import type ThreadId from "@/domain/value-objects/ThreadId.js";
+import type Conversation from "@/domain/entities/Conversation.js";
+
+interface CacheEntry {
+  conversation: Conversation;
+  lastAccess: number;
+}
+
+class InMemoryConversationRepository implements ConversationRepository {
+  private readonly cache = new Map<string, CacheEntry>();
+
+  constructor(
+    private readonly maxThreads: number,
+    private readonly ttlMs: number,
+  ) {}
+
+  async get(threadId: ThreadId): Promise<Conversation | null> {
+    const key = threadId.toString();
+    const entry = this.cache.get(key);
+
+    if (!entry) {
+      return null;
+    }
+
+    if (Date.now() - entry.lastAccess > this.ttlMs) {
+      this.cache.delete(key);
+      return null;
+    }
+
+    entry.lastAccess = Date.now();
+    return entry.conversation;
+  }
+
+  async save(conversation: Conversation): Promise<void> {
+    const key = conversation.threadId.toString();
+
+    if (!this.cache.has(key) && this.cache.size >= this.maxThreads) {
+      this.evictLRU();
+    }
+
+    this.cache.set(key, {
+      conversation,
+      lastAccess: Date.now(),
+    });
+  }
+
+  async purge(threadId: ThreadId): Promise<void> {
+    this.cache.delete(threadId.toString());
+  }
+
+  private evictLRU(): void {
+    let oldestKey: string | null = null;
+    let oldestTime = Infinity;
+
+    for (const [key, entry] of this.cache) {
+      if (entry.lastAccess < oldestTime) {
+        oldestTime = entry.lastAccess;
+        oldestKey = key;
+      }
+    }
+
+    if (oldestKey) {
+      this.cache.delete(oldestKey);
+    }
+  }
+}
+
+export default InMemoryConversationRepository;

package/src/infrastructure/persistence/PostgresPoolFactory.ts

@@ -0,0 +1,11 @@
+import { Pool } from "pg";
+
+function createPool(databaseUrl: string): Pool {
+  return new Pool({
+    connectionString: databaseUrl,
+    idleTimeoutMillis: 30000,
+    connectionTimeoutMillis: 5000,
+  });
+}
+
+export default createPool;

package/src/infrastructure/persistence/PostgresSqlExecutor.test.ts

@@ -0,0 +1,130 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import type { Pool } from "pg";
+import PostgresSqlExecutor from "./PostgresSqlExecutor.js";
+import SqlQuery from "@/domain/value-objects/SqlQuery.js";
+import SqlExecutionError from "@/domain/errors/SqlExecutionError.js";
+
+describe(`PostgresSqlExecutor`, () => {
+  let mockQueryFn: ReturnType<typeof vi.fn>;
+  let mockReleaseFn: ReturnType<typeof vi.fn>;
+  let mockConnectFn: ReturnType<typeof vi.fn>;
+  let executor: PostgresSqlExecutor;
+
+  beforeEach(() => {
+    mockQueryFn = vi.fn();
+    mockReleaseFn = vi.fn();
+    mockConnectFn = vi.fn().mockResolvedValue({
+      query: mockQueryFn,
+      release: mockReleaseFn,
+    });
+
+    const mockPool = {
+      connect: mockConnectFn,
+    } as unknown as Pool;
+
+    executor = new PostgresSqlExecutor(mockPool, 5000);
+  });
+
+  afterEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it(`should execute query and return QueryResult`, async () => {
+    const mockValidator = {
+      validate: (sql: string) => sql,
+    };
+    const query = SqlQuery.create(`SELECT * FROM users`, mockValidator);
+
+    mockQueryFn.mockResolvedValueOnce({ fields: [], rows: [] });
+    mockQueryFn.mockResolvedValueOnce({
+      fields: [
+        { name: `id` },
+        { name: `email` },
+      ],
+      rows: [
+        { id: `1`, email: `test@example.com` },
+      ],
+    });
+
+    const result = await executor.execute(query);
+
+    expect(result.columns).toEqual([`id`, `email`]);
+    expect(result.rows).toEqual([{ id: `1`, email: `test@example.com` }]);
+    expect(result.rowCount).toBe(1);
+  });
+
+  it(`should set statement_timeout before executing query`, async () => {
+    const mockValidator = {
+      validate: (sql: string) => sql,
+    };
+    const query = SqlQuery.create(`SELECT 1`, mockValidator);
+
+    mockQueryFn.mockResolvedValueOnce({ fields: [], rows: [] });
+    mockQueryFn.mockResolvedValueOnce({
+      fields: [{ name: `1` }],
+      rows: [{ "1": 1 }],
+    });
+
+    await executor.execute(query);
+
+    const calls = mockQueryFn.mock.calls;
+    expect(calls[0]?.[0]).toBe(`SET statement_timeout = 5000`);
+    expect(calls[1]?.[0]).toBe(`SELECT 1`);
+  });
+
+  it(`should release client in finally block`, async () => {
+    const mockValidator = {
+      validate: (sql: string) => sql,
+    };
+    const query = SqlQuery.create(`SELECT 1`, mockValidator);
+
+    mockQueryFn.mockResolvedValueOnce({ fields: [], rows: [] });
+    mockQueryFn.mockResolvedValueOnce({
+      fields: [{ name: `1` }],
+      rows: [{ "1": 1 }],
+    });
+
+    await executor.execute(query);
+
+    expect(mockReleaseFn.mock.calls.length).toBe(1);
+  });
+
+  it(`should release client even when query fails`, async () => {
+    const mockValidator = {
+      validate: (sql: string) => sql,
+    };
+    const query = SqlQuery.create(`SELECT * FROM nonexistent`, mockValidator);
+
+    mockQueryFn.mockResolvedValueOnce({ fields: [], rows: [] });
+    mockQueryFn.mockRejectedValueOnce(
+      new Error(`table "nonexistent" does not exist`),
+    );
+
+    await expect(executor.execute(query)).rejects.toThrow(SqlExecutionError);
+
+    expect(mockReleaseFn.mock.calls.length).toBe(1);
+  });
+
+  it(`should wrap PG errors in SqlExecutionError`, async () => {
+    const mockValidator = {
+      validate: (sql: string) => sql,
+    };
+    const query = SqlQuery.create(`SELECT * FROM invalid`, mockValidator);
+
+    const pgError = new Error(`syntax error at or near "invalid"`);
+    mockQueryFn.mockResolvedValueOnce({ fields: [], rows: [] });
+    mockQueryFn.mockRejectedValueOnce(pgError);
+
+    try {
+      await executor.execute(query);
+      throw new Error(`Expected SqlExecutionError to be thrown`);
+    } catch (error) {
+      if (!(error instanceof SqlExecutionError)) {
+        throw error;
+      }
+      expect(error.code).toBe(`SQL_EXECUTION_ERROR`);
+      expect(error.sql).toBe(`SELECT * FROM invalid`);
+      expect(error.pgError).toBe(`syntax error at or near "invalid"`);
+    }
+  });
+});

package/src/infrastructure/persistence/PostgresSqlExecutor.ts

@@ -0,0 +1,34 @@
+import type { Pool } from "pg";
+import type SqlExecutor from "@/domain/ports/SqlExecutor.js";
+import type SqlQuery from "@/domain/value-objects/SqlQuery.js";
+import QueryResult from "@/domain/value-objects/QueryResult.js";
+import SqlExecutionError from "@/domain/errors/SqlExecutionError.js";
+
+class PostgresSqlExecutor implements SqlExecutor {
+  constructor(
+    private readonly pool: Pool,
+    private readonly timeoutMs: number,
+  ) {}
+
+  async execute(query: SqlQuery): Promise<QueryResult> {
+    const client = await this.pool.connect();
+    try {
+      const timeoutStr = String(this.timeoutMs);
+      await client.query(`SET statement_timeout = ${timeoutStr}`);
+      const result = await client.query(query.raw);
+      return QueryResult.create(
+        result.fields.map((f) => f.name),
+        result.rows as Record<string, unknown>[],
+      );
+    } catch (error) {
+      throw new SqlExecutionError(
+        query.raw,
+        error instanceof Error ? error.message : String(error),
+      );
+    } finally {
+      client.release();
+    }
+  }
+}
+
+export default PostgresSqlExecutor;

package/src/infrastructure/persistence/index.ts

@@ -0,0 +1,3 @@
+export { default as PostgresPoolFactory } from "./PostgresPoolFactory.js";
+export { default as PostgresSqlExecutor } from "./PostgresSqlExecutor.js";
+export { default as InMemoryConversationRepository } from "./InMemoryConversationRepository.js";