sailfork / t3code-github / apps/ server/ src/ persistence/ Errors.test.ts

import { assert, it } from "@effect/vitest";
import * as NodeSqliteClient from "@t3tools/shared/nodeSqliteClient";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import * as SqlClient from "effect/sql/SqlClient";

import { PersistenceDecodeError, toPersistenceSqlError } from "./Errors.ts";

const decodeRuntimePayload = Schema.decodeUnknownEffect(
  Schema.Struct({
    runtimePayload: Schema.Struct({
      attempt: Schema.Number,
    }),
  }),
);

it.effect("names a real SQLite condition without copying query data", () =>
  Effect.gen(function* () {
    const sql = yield* SqlClient.SqlClient;
    const payload = "sql-private-sentinel";
    yield* sql`CREATE TABLE error_test (private_column TEXT PRIMARY KEY)`;
    yield* sql`INSERT INTO error_test VALUES (${payload})`;
    const cause = yield* Effect.flip(sql`INSERT INTO error_test VALUES (${payload})`);
    const error = toPersistenceSqlError("OrchestrationCommandReceiptRepository.upsert:query")(
      cause,
    );

    assert.equal(error.detail, "SQLITE(1555) constraint failed");
    assert.equal(error.cause, cause);
    assert.notInclude(error.message, payload);
    assert.notInclude(error.message, "private_column");
  }).pipe(Effect.provide(NodeSqliteClient.layer({ filename: ":memory:" }))),
);

it("reads the condition through a wrapping driver error", () => {
  const driver = Object.assign(new Error("locked"), { errcode: 5, errstr: "database is locked" });
  const error = toPersistenceSqlError("AuthSessionRepository.list:query")(
    new Error("Failed to prepare statement", { cause: driver }),
  );

  assert.equal(error.detail, "SQLITE(5) database is locked");
});

it.effect("maps schema errors without copying rejected payloads into diagnostics", () =>
  Effect.gen(function* () {
    const rejectedPayload = "runtime-payload-secret-sentinel";
    const cause = yield* Effect.flip(
      decodeRuntimePayload({
        runtimePayload: {
          attempt: rejectedPayload,
        },
      }),
    );
    const error = PersistenceDecodeError.fromSchemaError(
      "ProviderSessionRuntimeRepository.list:decodeRows",
      cause,
    );

    assert.equal(error.operation, "ProviderSessionRuntimeRepository.list:decodeRows");
    assert.equal(error.cause, cause);
    assert.notInclude(error.issue, rejectedPayload);
    assert.notInclude(error.message, rejectedPayload);
    assert.include(error.issue, "InvalidType");
  }),
);