efarmz-slackbot-data 1.0.0

package/src/application/formatting/MonospaceTableRenderer.test.ts

@@ -0,0 +1,129 @@
+import { describe, it, expect } from "vitest";
+import MonospaceTableRenderer from "../formatting/MonospaceTableRenderer";
+import QueryResult from "@/domain/value-objects/QueryResult";
+
+describe("MonospaceTableRenderer", () => {
+  it("renders simple 2x2 table with proper alignment", () => {
+    const result = QueryResult.create(
+      ["id", "name"],
+      [
+        { id: 1, name: "Alice" },
+        { id: 2, name: "Bob" },
+      ]
+    );
+
+    const output = MonospaceTableRenderer.render(result);
+
+    expect(output).toContain("```");
+    expect(output).toContain("id  name");
+    expect(output).toContain("--  ----");
+    expect(output).toContain("1   Alice");
+    expect(output).toContain("2   Bob");
+  });
+
+  it("handles columns with different value widths", () => {
+    const result = QueryResult.create(
+      ["short", "much_longer_value"],
+      [
+        { short: "x", much_longer_value: "value" },
+        { short: "abc", much_longer_value: "v" },
+      ]
+    );
+
+    const output = MonospaceTableRenderer.render(result);
+
+    expect(output).toContain("```");
+    expect(output).toContain("short");
+    expect(output).toContain("much_longer_value");
+    expect(output).toMatch(/-----\s+-+/);
+  });
+
+  it("displays null values as empty", () => {
+    const result = QueryResult.create(
+      ["col1", "col2"],
+      [{ col1: "value", col2: null }]
+    );
+
+    const output = MonospaceTableRenderer.render(result);
+
+    expect(output).toContain("col1   col2");
+    expect(output).toContain("value");
+  });
+
+  it("truncates rows when maxRows is specified", () => {
+    const result = QueryResult.create(
+      ["id"],
+      [{ id: 1 }, { id: 2 }, { id: 3 }, { id: 4 }, { id: 5 }]
+    );
+
+    const output = MonospaceTableRenderer.render(result, 2);
+
+    expect(output).toMatch(/^1\s/m);
+    expect(output).toMatch(/^2\s/m);
+    expect(output).not.toMatch(/^3\s/m);
+    expect(output).toContain("... (3 lignes supplémentaires)");
+  });
+
+  it("uses correct singular for single remaining line", () => {
+    const result = QueryResult.create(
+      ["id"],
+      [{ id: 1 }, { id: 2 }]
+    );
+
+    const output = MonospaceTableRenderer.render(result, 1);
+
+    expect(output).toContain("1 ligne supplémentaire");
+    expect(output).not.toContain("lignes supplémentaires");
+  });
+
+  it("handles empty table gracefully", () => {
+    const result = QueryResult.create([], []);
+
+    const output = MonospaceTableRenderer.render(result);
+
+    expect(output).toContain("(empty table)");
+  });
+
+  it("handles single row table", () => {
+    const result = QueryResult.create(
+      ["name", "age"],
+      [{ name: "Alice", age: 30 }]
+    );
+
+    const output = MonospaceTableRenderer.render(result);
+
+    expect(output).toContain("name");
+    expect(output).toContain("age");
+    expect(output).toContain("Alice");
+    expect(output).toContain("30");
+  });
+
+  it("handles numeric and string values consistently", () => {
+    const result = QueryResult.create(
+      ["count", "description"],
+      [
+        { count: 42, description: "the answer" },
+        { count: 0, description: "" },
+      ]
+    );
+
+    const output = MonospaceTableRenderer.render(result);
+
+    expect(output).toContain("42");
+    expect(output).toContain("the answer");
+    expect(output).toContain("0");
+  });
+
+  it("includes header and separator in output", () => {
+    const result = QueryResult.create(
+      ["id", "name"],
+      [{ id: 1, name: "Test" }]
+    );
+
+    const output = MonospaceTableRenderer.render(result);
+    const lines = output.split("\n");
+
+    expect(lines[1]).toMatch(/^id\s+name$/);
+    expect(lines[2]).toMatch(/^--\s+----$/);
+  });
+});

package/src/application/formatting/MonospaceTableRenderer.ts

@@ -0,0 +1,58 @@
+import type { QueryResult } from "@/domain/value-objects/QueryResult";
+
+const render = (result: QueryResult, maxRows?: number): string => {
+  const { columns, rows, rowCount } = result;
+
+  if (columns.length === 0 || rows.length === 0) {
+    return `\`\`\`\n(empty table)\n\`\`\``;
+  }
+
+  const widths: number[] = columns.map((col) => {
+    const headerWidth = col.length;
+    const valueWidths = rows.map((row) => {
+      const val = row[col];
+      // eslint-disable-next-line @typescript-eslint/no-base-to-string
+      const str =
+        val === null || val === undefined ? `` : String(val);
+      return str.length;
+    });
+    return Math.max(headerWidth, ...valueWidths);
+  });
+
+  const header = columns
+    .map((col, i) => col.padEnd(widths[i] ?? 0))
+    .join(`  `);
+  const separator = widths.map((w) => `-`.repeat(w)).join(`  `);
+
+  const displayRows =
+    maxRows !== undefined ? rows.slice(0, maxRows) : rows;
+  const lines = displayRows.map((row) =>
+    columns
+      .map((col, i) => {
+        const val = row[col];
+        // eslint-disable-next-line @typescript-eslint/no-base-to-string
+        const str =
+          val === null || val === undefined ? `` : String(val);
+        return str.padEnd(widths[i] ?? 0);
+      })
+      .join(`  `)
+  );
+
+  let table = [header, separator, ...lines].join(`\n`);
+
+  if (maxRows !== undefined && rowCount > maxRows) {
+    const remaining = rowCount - maxRows;
+    const phrase =
+      remaining === 1
+        ? `ligne supplémentaire`
+        : `lignes supplémentaires`;
+    // eslint-disable-next-line @typescript-eslint/restrict-template-expressions
+    table += `\n... (${remaining} ${phrase})`;
+  }
+
+  return `\`\`\`\n${table}\n\`\`\``;
+};
+
+const MonospaceTableRenderer = { render };
+
+export default MonospaceTableRenderer;

package/src/application/formatting/RenderedResponse.ts

@@ -0,0 +1,7 @@
+type RenderedResponse = {
+  readonly text: string;
+  readonly csvBuffer?: Buffer;
+  readonly csvFilename?: string;
+};
+
+export default RenderedResponse;

package/src/application/formatting/ResponseRenderer.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect } from 'vitest';
+import ResponseRenderer from '../formatting/ResponseRenderer';
+import QueryResult from '@/domain/value-objects/QueryResult';
+
+describe(`ResponseRenderer`, () => {
+  const csvThreshold = 15;
+  const renderer = new ResponseRenderer(csvThreshold);
+
+  it(`returns finalText when queryResult is null`, () => {
+    const result = renderer.render({
+      finalText: `No data available`,
+      queryResult: null,
+      executedSqls: [],
+      flags: { showSql: false, debug: false, noContext: false },
+    });
+
+    expect(result.text).toBe(`No data available`);
+    expect(result.csvBuffer).toBeUndefined();
+    expect(result.csvFilename).toBeUndefined();
+  });
+
+  it(`returns "Aucun résultat." when rowCount is 0`, () => {
+    const queryResult = QueryResult.create([`id`, `name`], []);
+
+    const result = renderer.render({
+      finalText: `The question was:`,
+      queryResult,
+      executedSqls: [],
+      flags: { showSql: false, debug: false, noContext: false },
+    });
+
+    expect(result.text).toBe(`Aucun résultat.`);
+    expect(result.csvBuffer).toBeUndefined();
+    expect(result.csvFilename).toBeUndefined();
+  });
+
+  it(`renders scalar (1×1) value in bold`, () => {
+    const queryResult = QueryResult.create([`count`], [{ count: 42 }]);
+
+    const result = renderer.render({
+      finalText: `Result:`,
+      queryResult,
+      executedSqls: [],
+      flags: { showSql: false, debug: false, noContext: false },
+    });
+
+    expect(result.text).toBe(`**42**`);
+    expect(result.csvBuffer).toBeUndefined();
+    expect(result.csvFilename).toBeUndefined();
+  });
+
+  it(`renders table when rowCount ≤ csvThreshold`, () => {
+    const rows = Array.from({ length: 5 }, (_, i) => ({
+      id: i + 1,
+      name: `user${(i + 1).toString()}`,
+    }));
+    const queryResult = QueryResult.create([`id`, `name`], rows);
+
+    const result = renderer.render({
+      finalText: `Users:`,
+      queryResult,
+      executedSqls: [],
+      flags: { showSql: false, debug: false, noContext: false },
+    });
+
+    expect(result.text).toContain(`\`\`\``);
+    expect(result.text).toContain(`id`);
+    expect(result.text).toContain(`name`);
+    expect(result.csvBuffer).toBeUndefined();
+    expect(result.csvFilename).toBeUndefined();
+  });
+
+  it(`renders truncated table + csv when rowCount > csvThreshold`, () => {
+    const rows = Array.from({ length: 20 }, (_, i) => ({
+      id: i + 1,
+      name: `user${(i + 1).toString()}`,
+    }));
+    const queryResult = QueryResult.create([`id`, `name`], rows);
+
+    const result = renderer.render({
+      finalText: `Users:`,
+      queryResult,
+      executedSqls: [],
+      flags: { showSql: false, debug: false, noContext: false },
+    });
+
+    expect(result.text).toContain(`\`\`\``);
+    expect(result.text).toContain(`... (10 lignes supplémentaires)`);
+    expect(result.csvBuffer).toBeDefined();
+    expect(result.csvFilename).toMatch(/^result_\d+\.csv$/);
+  });
+
+  it(`appends SQL block when showSql flag is true`, () => {
+    const queryResult = QueryResult.create([`count`], [{ count: 42 }]);
+    const sql = `SELECT COUNT(*) as count FROM users`;
+
+    const result = renderer.render({
+      finalText: `Count:`,
+      queryResult,
+      executedSqls: [sql],
+      flags: { showSql: true, debug: false, noContext: false },
+    });
+
+    expect(result.text).toContain(`**42**`);
+    expect(result.text).toContain(`\`\`\`sql`);
+    expect(result.text).toContain(sql);
+  });
+
+  it(`appends multiple SQL blocks when multiple queries executed`, () => {
+    const queryResult = QueryResult.create([`count`], [{ count: 42 }]);
+    const sqls = [
+      `SELECT COUNT(*) FROM users`,
+      `SELECT * FROM orders LIMIT 10`,
+    ];
+
+    const result = renderer.render({
+      finalText: `Results:`,
+      queryResult,
+      executedSqls: sqls,
+      flags: { showSql: true, debug: false, noContext: false },
+    });
+
+    expect(result.text).toContain(sqls[0]);
+    expect(result.text).toContain(sqls[1]);
+    expect(result.text).toMatch(/```sql[\s\S]*```[\s\S]*```sql[\s\S]*```/);
+  });
+
+  it(`handles table with scalar when rowCount is 1 and columns is 1`, () => {
+    const queryResult = QueryResult.create([`total`], [{ total: 999 }]);
+
+    const result = renderer.render({
+      finalText: `Total orders:`,
+      queryResult,
+      executedSqls: [],
+      flags: { showSql: false, debug: false, noContext: false },
+    });
+
+    expect(result.text).toBe(`**999**`);
+  });
+
+  it(`respects custom csvThreshold`, () => {
+    const rendererSmallThreshold = new ResponseRenderer(3);
+    const rows = Array.from({ length: 5 }, (_, i) => ({
+      id: i + 1,
+      value: i * 10,
+    }));
+    const queryResult = QueryResult.create([`id`, `value`], rows);
+
+    const result = rendererSmallThreshold.render({
+      finalText: `Data:`,
+      queryResult,
+      executedSqls: [],
+      flags: { showSql: false, debug: false, noContext: false },
+    });
+
+    expect(result.csvBuffer).toBeDefined();
+    expect(result.csvFilename).toBeDefined();
+  });
+});

package/src/application/formatting/ResponseRenderer.ts

@@ -0,0 +1,39 @@
+import type { QueryResult } from "@/domain/value-objects/QueryResult";
+import type { QuestionFlagsType } from "@/domain/value-objects/QuestionFlags";
+import type RenderedResponse from "./RenderedResponse";
+import CsvRenderer from "./CsvRenderer";
+
+type RenderParams = {
+  readonly finalText: string;
+  readonly queryResult: QueryResult | null;
+  readonly executedSqls: readonly string[];
+  readonly flags: QuestionFlagsType;
+};
+
+class ResponseRenderer {
+  constructor(private readonly csvThreshold: number) {}
+
+  render(params: RenderParams): RenderedResponse {
+    const { finalText, queryResult, executedSqls, flags } = params;
+
+    let text = finalText;
+    let csvBuffer: Buffer | undefined;
+    let csvFilename: string | undefined;
+
+    if (queryResult !== null && queryResult.rowCount > this.csvThreshold) {
+      csvBuffer = CsvRenderer.render(queryResult);
+      csvFilename = `result_${Date.now()}.csv`;
+    }
+
+    if (flags.showSql && executedSqls.length > 0) {
+      const sqlBlock = executedSqls
+        .map((sql) => `\`\`\`sql\n${sql}\n\`\`\``)
+        .join(`\n`);
+      text = `${text}\n\n${sqlBlock}`;
+    }
+
+    return { text, csvBuffer, csvFilename };
+  }
+}
+
+export default ResponseRenderer;

package/src/application/formatting/ScalarRenderer.test.ts

@@ -0,0 +1,36 @@
+import { describe, it, expect } from "vitest";
+import ScalarRenderer from "../formatting/ScalarRenderer";
+
+describe(`ScalarRenderer`, () => {
+  it(`renders number as bold`, () => {
+    expect(ScalarRenderer.render(42)).toBe(`**42**`);
+  });
+
+  it(`renders string as bold`, () => {
+    expect(ScalarRenderer.render(`hello`)).toBe(`**hello**`);
+  });
+
+  it(`renders null as N/A`, () => {
+    expect(ScalarRenderer.render(null)).toBe(`**N/A**`);
+  });
+
+  it(`renders undefined as N/A`, () => {
+    expect(ScalarRenderer.render(undefined)).toBe(`**N/A**`);
+  });
+
+  it(`renders zero as bold`, () => {
+    expect(ScalarRenderer.render(0)).toBe(`**0**`);
+  });
+
+  it(`renders empty string as bold`, () => {
+    expect(ScalarRenderer.render(``)).toBe(`****`);
+  });
+
+  it(`renders boolean true as bold`, () => {
+    expect(ScalarRenderer.render(true)).toBe(`**true**`);
+  });
+
+  it(`renders boolean false as bold`, () => {
+    expect(ScalarRenderer.render(false)).toBe(`**false**`);
+  });
+});

package/src/application/formatting/ScalarRenderer.ts

@@ -0,0 +1,12 @@
+const render = (value: unknown): string => {
+  if (value === null || value === undefined) {
+    return `*N/A*`;
+  }
+  // eslint-disable-next-line @typescript-eslint/no-base-to-string
+  const str = typeof value === `string` ? value : String(value);
+  return `*${str}*`;
+};
+
+const ScalarRenderer = { render };
+
+export default ScalarRenderer;