efarmz-slackbot-data 1.0.0

package/src/infrastructure/schemas/FileSystemSchemaCatalog.test.ts

@@ -0,0 +1,163 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import FileSystemSchemaCatalog from "./FileSystemSchemaCatalog.js";
+import SchemaLoadError from "@/domain/errors/SchemaLoadError.js";
+import {
+  mkdtempSync,
+  writeFileSync,
+  rmSync,
+  chmodSync,
+} from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+
+describe("FileSystemSchemaCatalog", () => {
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), `schema-test-`));
+  });
+
+  afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe("valid scenarios", () => {
+    it("loads and concatenates multiple markdown files", () => {
+      writeFileSync(join(tempDir, `schema1.md`), `Schema 1 content`);
+      writeFileSync(join(tempDir, `schema2.md`), `Schema 2 content`);
+
+      const catalog = new FileSystemSchemaCatalog(tempDir);
+      const documentation = catalog.getDocumentation();
+
+      expect(documentation).toContain(`--- schema1.md ---`);
+      expect(documentation).toContain(`Schema 1 content`);
+      expect(documentation).toContain(`--- schema2.md ---`);
+      expect(documentation).toContain(`Schema 2 content`);
+      expect(documentation.indexOf(`schema1.md`)).toBeLessThan(
+        documentation.indexOf(`schema2.md`),
+      );
+    });
+
+    it("separates files with double newlines", () => {
+      writeFileSync(join(tempDir, `a.md`), `Content A`);
+      writeFileSync(join(tempDir, `b.md`), `Content B`);
+
+      const catalog = new FileSystemSchemaCatalog(tempDir);
+      const documentation = catalog.getDocumentation();
+
+      expect(documentation).toMatch(/Content A\n\n--- b\.md ---/);
+    });
+
+    it("returns empty string for directory with no markdown files", () => {
+      writeFileSync(join(tempDir, `readme.txt`), `Not a markdown`);
+      writeFileSync(join(tempDir, `data.json`), `{"key": "value"}`);
+
+      const catalog = new FileSystemSchemaCatalog(tempDir);
+      expect(catalog.getDocumentation()).toBe(``);
+    });
+
+    it("returns empty string for empty directory", () => {
+      const catalog = new FileSystemSchemaCatalog(tempDir);
+      expect(catalog.getDocumentation()).toBe(``);
+    });
+
+    it("sorts files alphabetically", () => {
+      writeFileSync(join(tempDir, `zebra.md`), `Z content`);
+      writeFileSync(join(tempDir, `apple.md`), `A content`);
+      writeFileSync(join(tempDir, `banana.md`), `B content`);
+
+      const catalog = new FileSystemSchemaCatalog(tempDir);
+      const documentation = catalog.getDocumentation();
+
+      const appleIdx = documentation.indexOf(`apple.md`);
+      const bananaIdx = documentation.indexOf(`banana.md`);
+      const zebraIdx = documentation.indexOf(`zebra.md`);
+
+      expect(appleIdx).toBeLessThan(bananaIdx);
+      expect(bananaIdx).toBeLessThan(zebraIdx);
+    });
+
+    it("memoizes documentation (same result on repeated calls)", () => {
+      writeFileSync(join(tempDir, `schema.md`), `Content`);
+
+      const catalog = new FileSystemSchemaCatalog(tempDir);
+      const result1 = catalog.getDocumentation();
+      const result2 = catalog.getDocumentation();
+
+      expect(result1).toBe(result2);
+      expect(result1).toBe(catalog.getDocumentation());
+    });
+
+    it("handles markdown files with newlines and special characters", () => {
+      const complexContent = `# Schema
+
+\`\`\`sql
+SELECT * FROM users
+WHERE email LIKE '%@example.com%'
+\`\`\`
+
+## Description
+This is a test schema.`;
+      writeFileSync(join(tempDir, `complex.md`), complexContent);
+
+      const catalog = new FileSystemSchemaCatalog(tempDir);
+      const documentation = catalog.getDocumentation();
+
+      expect(documentation).toContain(complexContent);
+    });
+  });
+
+  describe("error scenarios", () => {
+    it("throws SchemaLoadError when directory does not exist", () => {
+      const nonexistentDir = join(tempDir, `does-not-exist`);
+
+      expect(() => {
+        new FileSystemSchemaCatalog(nonexistentDir);
+      }).toThrow(SchemaLoadError);
+    });
+
+    it("SchemaLoadError contains directory name and reason", () => {
+      const nonexistentDir = join(tempDir, `missing`);
+
+      try {
+        new FileSystemSchemaCatalog(nonexistentDir);
+      } catch (error) {
+        expect(error).toBeInstanceOf(SchemaLoadError);
+        if (error instanceof SchemaLoadError) {
+          expect(error.schemaName).toBe(nonexistentDir);
+          expect(error.reason).toBeTruthy();
+        }
+      }
+    });
+
+    it("throws SchemaLoadError when a markdown file cannot be read", () => {
+      const mdFile = join(tempDir, `unreadable.md`);
+      writeFileSync(mdFile, `Content`);
+
+      // Remove read permissions
+      chmodSync(mdFile, 0o000);
+
+      try {
+        expect(() => {
+          new FileSystemSchemaCatalog(tempDir);
+        }).toThrow(SchemaLoadError);
+      } finally {
+        // Restore permissions for cleanup
+        chmodSync(mdFile, 0o644);
+      }
+    });
+
+    it("has correct error code", () => {
+      const nonexistentDir = join(tempDir, `missing`);
+
+      try {
+        new FileSystemSchemaCatalog(nonexistentDir);
+      } catch (error) {
+        expect(error).toBeInstanceOf(SchemaLoadError);
+        if (error instanceof SchemaLoadError) {
+          expect(error.code).toBe(`SCHEMA_LOAD_ERROR`);
+        }
+      }
+    });
+  });
+});

package/src/infrastructure/schemas/FileSystemSchemaCatalog.ts

@@ -0,0 +1,35 @@
+import { readdirSync, readFileSync } from "fs";
+import { join } from "path";
+import type SchemaCatalog from "@/domain/ports/SchemaCatalog.js";
+import SchemaLoadError from "@/domain/errors/SchemaLoadError.js";
+
+class FileSystemSchemaCatalog implements SchemaCatalog {
+  private readonly documentation: string;
+
+  constructor(schemasDir: string) {
+    try {
+      const files = readdirSync(schemasDir)
+        .filter((f) => f.endsWith(`.md`))
+        .sort();
+
+      const contents = files.map((file) => {
+        const filePath = join(schemasDir, file);
+        const content = readFileSync(filePath, `utf-8`);
+        return `--- ${file} ---\n${content}`;
+      });
+
+      this.documentation = contents.join(`\n\n`);
+    } catch (error) {
+      throw new SchemaLoadError(
+        schemasDir,
+        error instanceof Error ? error.message : String(error),
+      );
+    }
+  }
+
+  getDocumentation(): string {
+    return this.documentation;
+  }
+}
+
+export default FileSystemSchemaCatalog;

package/src/infrastructure/schemas/index.ts

@@ -0,0 +1,4 @@
+import FileSystemSchemaCatalog from "./FileSystemSchemaCatalog.js";
+
+export { FileSystemSchemaCatalog };
+export default FileSystemSchemaCatalog;

package/src/infrastructure/slack/BoltSlackMessenger.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect, vi } from "vitest";
+import BoltSlackMessenger from "./BoltSlackMessenger.js";
+import ThreadId from "@/domain/value-objects/ThreadId.js";
+
+describe(`BoltSlackMessenger`, () => {
+  it(`should post message to channel and thread`, async () => {
+    const mockClient = {
+      chat: {
+        postMessage: vi.fn(),
+      },
+    } as any;
+
+    const messenger = new BoltSlackMessenger(mockClient);
+    const threadId = ThreadId.create(`C123`, `1234567890.000001`);
+
+    await messenger.post(threadId, `Hello world`);
+
+    expect(mockClient.chat.postMessage).toHaveBeenCalledWith({
+      channel: `C123`,
+      thread_ts: `1234567890.000001`,
+      text: `Hello world`,
+    });
+  });
+
+  it(`should post message and upload CSV file`, async () => {
+    const mockClient = {
+      chat: {
+        postMessage: vi.fn(),
+      },
+      files: {
+        uploadV2: vi.fn(),
+      },
+    } as any;
+
+    const messenger = new BoltSlackMessenger(mockClient);
+    const threadId = ThreadId.create(`C123`, `1234567890.000001`);
+    const csvBuffer = Buffer.from(`col1,col2\nval1,val2`);
+
+    await messenger.postCsv(
+      threadId,
+      `Results`,
+      csvBuffer,
+      `results.csv`,
+    );
+
+    expect(mockClient.chat.postMessage).toHaveBeenCalledWith({
+      channel: `C123`,
+      thread_ts: `1234567890.000001`,
+      text: `Results`,
+    });
+
+    expect(mockClient.files.uploadV2).toHaveBeenCalledWith({
+      channel_id: `C123`,
+      thread_ts: `1234567890.000001`,
+      filename: `results.csv`,
+      file: csvBuffer,
+    });
+  });
+});

package/src/infrastructure/slack/BoltSlackMessenger.ts

@@ -0,0 +1,36 @@
+import type { WebClient } from "@slack/web-api";
+import type SlackMessenger from "@/domain/ports/SlackMessenger.js";
+import type ThreadId from "@/domain/value-objects/ThreadId.js";
+
+class BoltSlackMessenger implements SlackMessenger {
+  constructor(private readonly client: WebClient) {}
+
+  async post(threadId: ThreadId, text: string): Promise<void> {
+    await this.client.chat.postMessage({
+      channel: threadId.channelId,
+      thread_ts: threadId.threadTs,
+      text,
+    });
+  }
+
+  async postCsv(
+    threadId: ThreadId,
+    text: string,
+    csvBuffer: Buffer,
+    filename: string,
+  ): Promise<void> {
+    await this.client.chat.postMessage({
+      channel: threadId.channelId,
+      thread_ts: threadId.threadTs,
+      text,
+    });
+    await this.client.files.uploadV2({
+      channel_id: threadId.channelId,
+      thread_ts: threadId.threadTs,
+      filename,
+      file: csvBuffer,
+    });
+  }
+}
+
+export default BoltSlackMessenger;

package/src/infrastructure/slack/SlackAdminLogger.test.ts

@@ -0,0 +1,54 @@
+import { describe, it, expect, vi } from "vitest";
+import SlackAdminLogger from "./SlackAdminLogger.js";
+import type { AdminLogEntry } from "@/domain/ports/AdminLogger.js";
+
+describe(`SlackAdminLogger`, () => {
+  it(`should log query to admin channel when configured`, async () => {
+    const mockClient = {
+      chat: {
+        postMessage: vi.fn(),
+      },
+    } as any;
+
+    const logger = new SlackAdminLogger(mockClient, `C_ADMIN`);
+    const entry: AdminLogEntry = {
+      userId: `U123`,
+      question: `How many users?`,
+      sqls: [`SELECT COUNT(*) FROM users`],
+      rowCount: 42,
+      durationMs: 123,
+      inputTokens: 100,
+      outputTokens: 50,
+    };
+
+    await logger.logQuery(entry);
+
+    expect(mockClient.chat.postMessage).toHaveBeenCalledWith({
+      channel: `C_ADMIN`,
+      text: expect.stringContaining(`U123`),
+    });
+  });
+
+  it(`should not log when admin channel is not configured`, async () => {
+    const mockClient = {
+      chat: {
+        postMessage: vi.fn(),
+      },
+    } as any;
+
+    const logger = new SlackAdminLogger(mockClient, null);
+    const entry: AdminLogEntry = {
+      userId: `U123`,
+      question: `How many users?`,
+      sqls: [`SELECT COUNT(*) FROM users`],
+      rowCount: 42,
+      durationMs: 123,
+      inputTokens: 100,
+      outputTokens: 50,
+    };
+
+    await logger.logQuery(entry);
+
+    expect(mockClient.chat.postMessage).not.toHaveBeenCalled();
+  });
+});

package/src/infrastructure/slack/SlackAdminLogger.ts

@@ -0,0 +1,27 @@
+import type { WebClient } from "@slack/web-api";
+import type AdminLogger from "@/domain/ports/AdminLogger.js";
+import type { AdminLogEntry } from "@/domain/ports/AdminLogger.js";
+
+class SlackAdminLogger implements AdminLogger {
+  constructor(
+    private readonly client: WebClient,
+    private readonly adminChannelId: string | null,
+  ) {}
+
+  async logQuery(entry: AdminLogEntry): Promise<void> {
+    if (!this.adminChannelId) return;
+
+    const text = `*Query from <@${entry.userId}>*\n\`\`\`\n${entry.sqls[0] ?? ``}\n\`\`\`\nRows: ${entry.rowCount} | Duration: ${entry.durationMs}ms | Tokens: ${entry.inputTokens}+${entry.outputTokens}`;
+
+    try {
+      await this.client.chat.postMessage({
+        channel: this.adminChannelId,
+        text,
+      });
+    } catch (err) {
+      console.error(`[SlackAdminLogger] Failed to post to admin channel:`, err);
+    }
+  }
+}
+
+export default SlackAdminLogger;

package/src/infrastructure/slack/SlackApp.ts

@@ -0,0 +1,9 @@
+import slack from "@slack/bolt";
+
+function createSlackApp(token: string, signingSecret: string) {
+  const receiver = new slack.ExpressReceiver({ signingSecret });
+  const app = new slack.App({ token, receiver });
+  return { app, receiver };
+}
+
+export default createSlackApp;

package/src/infrastructure/slack/handlers/AppMentionHandler.ts

@@ -0,0 +1,52 @@
+import type { App } from "@slack/bolt";
+import type AnswerQuestion from "@/application/usecases/AnswerQuestion.js";
+import ParseQuestion from "@/application/usecases/ParseQuestion.js";
+import type Logger from "@/domain/ports/Logger.js";
+import ThreadId from "@/domain/value-objects/ThreadId.js";
+
+const eventCache = new Map<string, number>();
+const EVENT_CACHE_TTL = 5 * 60 * 1000;
+
+function registerAppMentionHandler(
+  app: App,
+  answerQuestion: AnswerQuestion,
+  logger: Logger,
+): void {
+  app.event(
+    `app_mention`,
+    async (payload: any): Promise<void> => {
+      const { event, ack } = payload;
+      await ack();
+
+      const eventId = event.event_ts;
+      if (eventCache.has(eventId)) return;
+
+      eventCache.set(eventId, Date.now());
+
+      for (const [key, timestamp] of eventCache) {
+        if (Date.now() - timestamp > EVENT_CACHE_TTL) {
+          eventCache.delete(key);
+        }
+      }
+
+      setImmediate(async () => {
+        try {
+          const userId = event.user;
+          if (!userId) return;
+
+          const threadId = ThreadId.create(
+            event.channel,
+            event.thread_ts ?? event.ts,
+          );
+          const question = ParseQuestion.execute(event.text);
+
+          await answerQuestion.execute(question, threadId, userId);
+        } catch (error) {
+          logger.error(`app_mention handler error`, { error });
+        }
+      });
+    },
+  );
+}
+
+export default registerAppMentionHandler;

package/src/infrastructure/slack/handlers/DirectMessageHandler.ts

@@ -0,0 +1,65 @@
+import type { App } from "@slack/bolt";
+import type AnswerQuestion from "@/application/usecases/AnswerQuestion.js";
+import ParseQuestion from "@/application/usecases/ParseQuestion.js";
+import type Logger from "@/domain/ports/Logger.js";
+import ThreadId from "@/domain/value-objects/ThreadId.js";
+
+const eventCache = new Map<string, number>();
+const EVENT_CACHE_TTL = 5 * 60 * 1000;
+
+interface SimpleMessageEvent {
+  type: string;
+  user?: string;
+  bot_id?: string;
+  channel_type?: string;
+  channel: string;
+  ts: string;
+  thread_ts?: string;
+  text?: string;
+  event_ts: string;
+}
+
+function registerDirectMessageHandler(
+  app: App,
+  answerQuestion: AnswerQuestion,
+  logger: Logger,
+): void {
+  app.message(async (payload: any): Promise<void> => {
+    const { event } = payload;
+    const messageEvent = event as SimpleMessageEvent;
+
+    if (!messageEvent.user || messageEvent.bot_id) return;
+
+    if (messageEvent.channel_type !== `im`) return;
+
+    const eventId = messageEvent.event_ts;
+    if (eventCache.has(eventId)) return;
+
+    eventCache.set(eventId, Date.now());
+
+    for (const [key, timestamp] of eventCache) {
+      if (Date.now() - timestamp > EVENT_CACHE_TTL) {
+        eventCache.delete(key);
+      }
+    }
+
+    setImmediate(async () => {
+      try {
+        const userId = messageEvent.user;
+        if (!userId || !messageEvent.text) return;
+
+        const threadId = ThreadId.create(
+          messageEvent.channel,
+          messageEvent.thread_ts ?? messageEvent.ts,
+        );
+        const question = ParseQuestion.execute(messageEvent.text);
+
+        await answerQuestion.execute(question, threadId, userId);
+      } catch (error) {
+        logger.error(`direct_message handler error`, { error });
+      }
+    });
+  });
+}
+
+export default registerDirectMessageHandler;

package/src/infrastructure/slack/index.ts

@@ -0,0 +1,5 @@
+export { default as createSlackApp } from "./SlackApp.js";
+export { default as BoltSlackMessenger } from "./BoltSlackMessenger.js";
+export { default as SlackAdminLogger } from "./SlackAdminLogger.js";
+export { default as registerAppMentionHandler } from "./handlers/AppMentionHandler.js";
+export { default as registerDirectMessageHandler } from "./handlers/DirectMessageHandler.js";