sailfork / t3code-github / apps/ server/ src/ orchestration-v2/ UserFacingErrors.test.ts

import { assert, describe, it } from "@effect/vitest";
import * as NodeServices from "@effect/platform-node/NodeServices";
import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";
import * as Effect from "effect/Effect";
import * as FileSystem from "effect/FileSystem";
import * as Path from "effect/Path";
import * as SqlClient from "effect/sql/SqlClient";
import { SqlError, classifySqliteError } from "effect/sql/SqlError";

import { toPersistenceSqlError } from "../persistence/Errors.ts";
import { userFacingDispatchErrorMessage } from "./UserFacingErrors.ts";

describe("userFacingDispatchErrorMessage", () => {
  it.effect("explains a real database open failure through dispatch and persistence wrappers", () =>
    Effect.gen(function* () {
      const fs = yield* FileSystem.FileSystem;
      const path = yield* Path.Path;
      const directory = yield* fs.makeTempDirectoryScoped({ prefix: "t3-database-error-" });
      const cause = yield* Effect.void.pipe(
        Effect.provide(
          NodeSqliteClient.layer({ filename: path.join(directory, "missing", "state.sqlite") }),
        ),
        Effect.flip,
      );
      const message = userFacingDispatchErrorMessage({
        message: "Failed to dispatch orchestration command message.dispatch (command-1).",
        cause: toPersistenceSqlError("OrchestrationEventStore.append:query")(cause),
      });

      assert.include(message, "server could not open a database file (SQLITE_CANTOPEN)");
      assert.include(message, "machine running the server");
      assert.include(message, "free disk space");
      assert.include(message, "data and temporary directories exist and are writable");
      assert.include(message, "then retry");
      assert.notInclude(message, directory);
    }).pipe(Effect.scoped, Effect.provide(NodeServices.layer)),
  );

  it.effect("explains a full database and allows a retry after capacity is restored", () =>
    Effect.gen(function* () {
      const sql = yield* SqlClient.SqlClient;
      yield* sql`CREATE TABLE entries (payload BLOB)`;
      yield* sql`PRAGMA max_page_count = 2`;
      const cause = yield* sql`INSERT INTO entries VALUES (zeroblob(16384))`.pipe(Effect.flip);
      const message = userFacingDispatchErrorMessage({ cause });

      assert.include(message, "database or disk is full (SQLITE_FULL)");
      assert.include(message, "Free space on the machine running the server, then retry");
      assert.include(message, "database size limit");

      yield* sql`PRAGMA max_page_count = 100`;
      yield* sql`INSERT INTO entries VALUES (zeroblob(16384))`;
      const rows = yield* sql<{ count: number }>`SELECT COUNT(*) AS count FROM entries`;
      assert.equal(rows[0]?.count, 1);
    }).pipe(Effect.provide(NodeSqliteClient.layer({ filename: ":memory:" }))),
  );

  it.effect("gives server permission guidance for a real read-only failure", () =>
    Effect.gen(function* () {
      const sql = yield* SqlClient.SqlClient;
      yield* sql`CREATE TABLE entries (payload TEXT)`;
      yield* sql`PRAGMA query_only = ON`;
      const cause = yield* sql`INSERT INTO entries VALUES ('private-message')`.pipe(Effect.flip);
      const message = userFacingDispatchErrorMessage(cause);

      assert.include(message, "server database is read-only (SQLITE_READONLY)");
      assert.include(message, "data directory is writable");
      assert.notInclude(message, "private-message");
    }).pipe(Effect.provide(NodeSqliteClient.layer({ filename: ":memory:" }))),
  );

  it("keeps unknown SQL failures contextual without exposing driver text or parameters", () => {
    const cause = Object.assign(new Error("private-query-data"), { errcode: 1 });
    const error = new SqlError({ reason: classifySqliteError(cause) });
    const message = userFacingDispatchErrorMessage({
      cause: toPersistenceSqlError("OrchestrationEventStore.append:query")(error),
    });

    assert.include(message, "server could not complete this database request");
    assert.include(message, "server logs");
    assert.notInclude(message, "private-query-data");
  });
});