// `UserStoreError` is the public failure of every cloud user-store call, and it// used to carry NOTHING: no operation, no reason, no message. Sentry grouped// every store failure — a connect timeout, a missing table, a constraint// violation — into one titleless issue, and the only cause detail (the// pretty-printed Effect cause stuffed into a Sentry `extra`) is scrubbed// server-side, so the issue was undiagnosable from Sentry alone.//// This pins the two safe classification fields it must carry instead:// `operation` (already in hand at the call site) and `reason` (classified from// the driver cause the way `statusFromWorkOSCause` classifies WorkOS causes).import { createServer, type Server, type Socket } from "node:net"; import { describe, expect, it } from "@effect/vitest";import { Effect, Layer, Result } from "effect";import postgres from "postgres"; import { UserStoreService } from "./context";import { ServiceAdapterError, userStoreReasonFromCause, type UserStoreError } from "./errors";import { DbService } from "../db/db"; // A socket that completes the TCP handshake and then says nothing — exactly// what a wedged Hyperdrive/Postgres endpoint looks like to postgres.js, and the// only way to obtain the driver's REAL connect-timeout error object rather than// a hand-written imitation of it.const blackHolePort = async (): Promise<{  readonly port: number;  readonly close: () => Promise<void>;}> => {  const sockets = new Set<Socket>();  const server: Server = createServer((socket) => {    sockets.add(socket);    socket.on("close", () => sockets.delete(socket));  });  await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));  const address = server.address();  // oxlint-disable-next-line executor/no-error-constructor, executor/no-try-catch-or-throw -- boundary: the fixture cannot run without a bound port  if (address === null || typeof address === "string") throw new Error("no port");  return {    port: address.port,    close: () =>      new Promise<void>((resolve) => {        // The timed-out client leaves its half-open socket attached; without        // dropping it first, `close` waits for a peer that will never speak.        for (const socket of sockets) socket.destroy();        server.close(() => resolve());      }),  };}; const realConnectTimeoutError = async (): Promise<unknown> => {  const hole = await blackHolePort();  const sql = postgres(`postgresql://postgres:postgres@127.0.0.1:${hole.port}/postgres`, {    max: 1,    connect_timeout: 1,    fetch_types: false,    onnotice: () => undefined,  });  // oxlint-disable-next-line executor/no-try-catch-or-throw -- boundary: capturing the driver's own thrown error IS the fixture  try {    await sql`select 1`;    // oxlint-disable-next-line executor/no-error-constructor, executor/no-try-catch-or-throw -- boundary: the fixture is unusable if the socket answered    throw new Error("expected the connect to time out");  } catch (error) {    return error;  } finally {    // oxlint-disable-next-line executor/no-promise-catch -- boundary: best-effort teardown of a connection that never opened    await sql.end({ timeout: 0 }).catch(() => undefined);    await hole.close();  }}; // Drizzle re-throws driver failures wrapped in its own error with the failing// SQL in the message and the driver error in `.cause` — the shape production// actually reports (`Failed query: select … -> write CONNECT_TIMEOUT …`).const wrappedLikeDrizzle = (cause: unknown): Error =>  // oxlint-disable-next-line executor/no-error-constructor -- boundary: reproducing the driver wrapper shape the store really fails with  Object.assign(new Error('Failed query: select "id" from "organizations" where "id" = $1'), {    cause,  }); const stubDb = Layer.succeed(DbService)({ db: {} as never }); const failingStoreCall = (  operation: string,  failure: unknown,): Effect.Effect<Result.Result<never, UserStoreError>> =>  Effect.gen(function* () {    const users = yield* UserStoreService;    // oxlint-disable-next-line executor/no-promise-reject -- boundary: the store adapter lifts a REJECTING promise; rejecting is the fixture    return yield* users.use(operation, () => Promise.reject(failure));  }).pipe(    Effect.provide(UserStoreService.Live.pipe(Layer.provide(stubDb))),    Effect.result,  ) as Effect.Effect<Result.Result<never, UserStoreError>>; describe("UserStoreError classification", () => {  it("classifies the driver cause chain", async () => {    const driverError = await realConnectTimeoutError();     expect(userStoreReasonFromCause(wrappedLikeDrizzle(driverError))).toBe("connect_timeout");    expect(      userStoreReasonFromCause(new ServiceAdapterError({ cause: wrappedLikeDrizzle(driverError) })),    ).toBe("connect_timeout");    expect(      userStoreReasonFromCause(        // oxlint-disable-next-line executor/no-error-constructor -- boundary: a SQLSTATE failure shape        Object.assign(new Error('relation "organizations" does not exist'), { code: "42P01" }),      ),    ).toBe("query");    // oxlint-disable-next-line executor/no-error-constructor -- boundary: a failure with nothing to classify    expect(userStoreReasonFromCause(new Error("something else"))).toBe("unknown");  }, 20_000);   it("carries operation, reason and a stable message on the public error", async () => {    const driverError = await realConnectTimeoutError();     const result = await Effect.runPromise(      failingStoreCall("getOrganization", wrappedLikeDrizzle(driverError)),    );     expect(Result.isFailure(result)).toBe(true);    if (!Result.isFailure(result)) return;    expect(result.failure.operation).toBe("getOrganization");    expect(result.failure.reason).toBe("connect_timeout");    expect(result.failure.message).toContain("getOrganization");    expect(result.failure.message).toContain("connect_timeout");  }, 20_000);});