@thomasfosterau/effect-drizzle-ext 0.0.0-stage → 0.1.0

package/dist/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","names":[],"sources":["../src/errors.ts"],"mappings":";;;;;;;;;;;iBAqGiB;;WAEN;;WAEA;;WAEA,YAAY,OAAO;;WAEnB,OAAO,OAAO;;WAEd,QAAQ,OAAO;;WAEf,QAAQ,OAAO;;WAEf,QAAQ,OAAO;;;;;;;;;;;;qBAuFb,cAAW,mBAAqB,OAAO,OAAO;;;;;;;;;;;;qBAc9C,wBAAwB;;;;;;;;qBAQxB,4BAA4B;;;;;;;qBAW5B,yBAAyB;;;;;;;qBAOzB,uBAAuB;;;;;;;qBAOvB,2BAA2B;;;;;;;;qBAa3B,6BAA6B;;;;;;;;qBAS7B,yBAAyB;;;;;;YAS1B,sBACR,kBACA,sBACA,mBACA,iBACA;;;;;YAMQ,kBAAkB,sBAAsB,uBAAuB;;;;;;;;qBAmE9D,gBAAa,mBAAqB,OAAO,OAAO;;;;;;;;;;;qBA4ChD,oBAAiB;;;;;qBASjB,wBAAqB;;;;;;;qBAUrB,gCAA6B;;;;;;;;;qBAkB7B,2BACV,IAAI,IAAI,IAAE,IAAM,WAAW,wBAAwB,OAAO,OAAO,IAAI,IAAI,SACzE,GAAG,GAAG,GAAC,MAAQ,OAAO,OAAO,GAAG,GAAG,OAAK,OAAO,OAAO,IAAI,IAAI,IAAI,IAAI,IAAI;;;;;;;;;qBAgBhE,uBACV,IAAI,IAAI,IAAE,IAAM,WAAW,oBAAoB,OAAO,OAAO,IAAI,IAAI,SACrE,GAAG,GAAG,GAAC,MAAQ,OAAO,OAAO,GAAG,GAAG,OAAK,OAAO,OAAO,IAAI,IAAI,IAAI,IAAI,IAAI"}

package/dist/errors.js

@@ -0,0 +1,287 @@
+import * as Array from "effect/Array";
+import * as Option from "effect/Option";
+import * as Predicate from "effect/Predicate";
+import * as Record from "effect/Record";
+import * as Schema from "effect/Schema";
+import * as Effect from "effect/Effect";
+// src/errors.ts
+/**
+* @copyright Thomas Foster
+*
+* Typed Postgres error classification.
+*
+* Effect already classifies SQLSTATE: `@effect/sql-pg` maps a driver error
+* into `SqlError.reason` (`UniqueViolation{constraint}`, `ConstraintError`,
+* `DeadlockError`, `SerializationError`, `ConnectionError`, …). It keeps the
+* violated constraint for `23505` only — every other `23xxx` becomes a bare
+* `ConstraintError` with no constraint / table / column — and drizzle then
+* wraps the whole thing inside `EffectDrizzleQueryError.cause`, which is an
+* Effect `Cause`, not the driver error. So the facts a caller needs to say
+* *which* constraint failed are still in the graph, just not on the failure
+* it is handed.
+*
+* This module recovers them: {@link findPgError} walks the error graph for the
+* driver's Postgres error (the node carrying a SQLSTATE `code`; under
+* `@effect/sql-pg` an `Error` carrying the server's ErrorResponse fields) and
+* reads its `code` / `constraint` / `table` / `column` / `detail` / `schema`,
+* and {@link classifyError} turns those facts into one of seven tagged errors
+* a consumer can `catchTag`.
+*
+* Nothing here is thrown: these are runtime query failures and they travel in
+* the Effect error channel. (Construction-time failures are the thrown
+* `DerivationError` in `./derive`.)
+*
+* The module imports neither `drizzle-orm` nor `@effect/sql-pg`, at runtime or
+* as types: it recognises those shapes structurally, so it works the same on a
+* bare `SqlError`, a bare Postgres error and the drizzle-wrapped shape, and
+* a consumer holding any of them classifies it without pulling a driver into
+* the bundle.
+*
+* @module errors
+*/
+/** SQLSTATE `23505` — unique (or primary key) constraint violated. */
+const UNIQUE_VIOLATION = "23505";
+/** SQLSTATE `23503` — foreign key constraint violated. */
+const FOREIGN_KEY_VIOLATION = "23503";
+/** SQLSTATE `23502` — NOT NULL constraint violated. */
+const NOT_NULL_VIOLATION = "23502";
+/** SQLSTATE `23514` — CHECK constraint violated. */
+const CHECK_VIOLATION = "23514";
+/** SQLSTATE `23P01` — EXCLUDE constraint violated. */
+const EXCLUSION_VIOLATION = "23P01";
+/** SQLSTATE `40001` — serialization failure; the transaction may be retried. */
+const SERIALIZATION_FAILURE = "40001";
+/** SQLSTATE `40P01` — deadlock detected; the transaction may be retried. */
+const DEADLOCK_DETECTED = "40P01";
+/**
+* The stable Postgres message fragment for a unique violation, kept as a
+* belt-and-suspenders fallback for {@link isUniqueViolation} (see its note).
+*/
+const PG_UNIQUE_VIOLATION_MESSAGE = "duplicate key value violates unique constraint";
+/**
+* The shape of a Postgres SQLSTATE: five uppercase alphanumerics (`23505`,
+* `23P01`, `40001`). This is what tells the driver error apart from a wrapper
+* that carries a `code` of its own — an `SqlError` or a Node `ErrnoException`
+* both have a `code`, neither looks like this — so the walk descends past
+* them instead of stopping at the first `code` it meets.
+*/
+const PG_SQLSTATE = /^[0-9A-Z]{5}$/;
+/** How deep into the error graph to search for the driver error. */
+const MAX_ERROR_DEPTH = 8;
+/** Reads a string-valued property off an error node as an `Option`. */
+const readString = (node, key) => {
+	const value = node[key];
+	return Predicate.isString(value) ? Option.some(value) : Option.none();
+};
+/**
+* The SQLSTATE a node declares, under either `code` (node-postgres) or
+* `sqlState` (the field name other drivers and some wrappers use), and only
+* when it actually looks like a SQLSTATE.
+*/
+const sqlStateOf = (node) => Option.filter(Option.orElse(readString(node, "code"), () => readString(node, "sqlState")), (code) => PG_SQLSTATE.test(code));
+/** The driver error's facts, when this node *is* the driver error. */
+const pgErrorFactsOf = (node) => Option.map(sqlStateOf(node), (code) => ({
+	code,
+	message: Option.getOrElse(readString(node, "message"), () => ""),
+	constraint: readString(node, "constraint"),
+	table: readString(node, "table"),
+	column: readString(node, "column"),
+	detail: readString(node, "detail"),
+	schema: readString(node, "schema")
+}));
+/** True when `error` is a fresh object worth descending into (within depth, not yet visited). */
+const isSearchable = (error, depth, seen) => Predicate.isObjectOrArray(error) && depth < MAX_ERROR_DEPTH && !seen.has(error);
+/**
+* The child error nodes reachable from a node: its `.cause` (read explicitly,
+* as it is often a NON-enumerable field on `SqlError` and on drizzle's
+* `EffectDrizzleQueryError`) plus its enumerable values, with arrays flattened
+* (an Effect `Cause`'s `reasons`).
+*/
+const childErrorNodes = (node) => [node["cause"], ...Array.flatMap(Record.values(node), (value) => Array.isArray(value) ? value : [value])];
+/**
+* Bounded, cycle-guarded depth-first search of an error graph for the first
+* node `match` accepts.
+*
+* A failed write reaches a caller deeply wrapped, and NOT on a simple `.cause`
+* chain: drizzle's `EffectDrizzleQueryError` holds an Effect `Cause` under a
+* (non-enumerable) `.cause`, and the driver's Postgres error carrying the SQLSTATE
+* sits inside that Cause's `reasons`. Hence a search over the whole reachable
+* graph — reading `.cause` explicitly (for the non-enumerable wrappers) and
+* sweeping enumerable values / arrays (for the Cause `reasons`) — rather than
+* a cause chain.
+*/
+const searchErrorGraph = (cause, match, depth, seen) => {
+	if (!isSearchable(cause, depth, seen)) return Option.none();
+	seen.add(cause);
+	return Option.orElse(match(cause), () => Array.findFirst(childErrorNodes(cause), (child) => searchErrorGraph(child, match, depth + 1, seen)));
+};
+/**
+* The driver's Postgres error facts, recovered from anywhere in `error`'s graph:
+* a bare Postgres error, a bare `SqlError` (whose `reason` holds the driver
+* error as its `cause`), or drizzle's `EffectDrizzleQueryError` wrapping an
+* Effect `Cause` that holds the `SqlError`. `Option.none()` when the graph
+* holds no node declaring a SQLSTATE, including for a non-object input.
+*
+* The walk is bounded (depth 8) and cycle-guarded, so a self-referential or
+* pathologically deep graph terminates.
+*/
+const findPgError = (error) => searchErrorGraph(error, pgErrorFactsOf, 0, /* @__PURE__ */ new Set());
+/**
+* SQLSTATE `23505`: a unique or primary key constraint was violated.
+* `cause` is the value classification started from, so the wrapping graph
+* (drizzle's query text and params, the `SqlError`) survives the recovery.
+*/
+var UniqueViolation = class extends Schema.TaggedError()("UniqueViolation", {
+	constraint: Schema.Option(Schema.String),
+	table: Schema.Option(Schema.String),
+	detail: Schema.Option(Schema.String),
+	cause: Schema.Defect()
+}) {};
+/** SQLSTATE `23503`: a foreign key constraint was violated. `cause` as in {@link UniqueViolation}. */
+var ForeignKeyViolation = class extends Schema.TaggedError()("ForeignKeyViolation", {
+	constraint: Schema.Option(Schema.String),
+	table: Schema.Option(Schema.String),
+	detail: Schema.Option(Schema.String),
+	cause: Schema.Defect()
+}) {};
+/** SQLSTATE `23502`: a NOT NULL constraint was violated. `column` names the offending column. */
+var NotNullViolation = class extends Schema.TaggedError()("NotNullViolation", {
+	column: Schema.Option(Schema.String),
+	table: Schema.Option(Schema.String),
+	cause: Schema.Defect()
+}) {};
+/** SQLSTATE `23514`: a CHECK constraint was violated — including the bounds checks `./derive` writes. */
+var CheckViolation = class extends Schema.TaggedError()("CheckViolation", {
+	constraint: Schema.Option(Schema.String),
+	table: Schema.Option(Schema.String),
+	cause: Schema.Defect()
+}) {};
+/** SQLSTATE `23P01`: an EXCLUDE constraint was violated. */
+var ExclusionViolation = class extends Schema.TaggedError()("ExclusionViolation", {
+	constraint: Schema.Option(Schema.String),
+	table: Schema.Option(Schema.String),
+	cause: Schema.Defect()
+}) {};
+/**
+* SQLSTATE `40001`: the transaction lost a serialization conflict. Retryable:
+* the same transaction re-run from the top may commit.
+*/
+var SerializationFailure = class extends Schema.TaggedError()("SerializationFailure", { cause: Schema.Defect() }) {};
+/**
+* SQLSTATE `40P01`: the transaction was chosen as a deadlock victim.
+* Retryable, like {@link SerializationFailure}.
+*/
+var DeadlockDetected = class extends Schema.TaggedError()("DeadlockDetected", { cause: Schema.Defect() }) {};
+/** Builds the `23505` classification; shared by `classifyError` and `catchUniqueViolation`. */
+const makeUniqueViolation = (facts, cause) => new UniqueViolation({
+	constraint: facts.constraint,
+	table: facts.table,
+	detail: facts.detail,
+	cause
+});
+/**
+* SQLSTATE → constraint-family constructor. A table rather than a `switch`:
+* the SQLSTATE is the key the whole module dispatches on, and a lookup that
+* misses is exactly the `Option.none()` an unclassified code should produce.
+*/
+const CONSTRAINT_VIOLATION_BY_CODE = {
+	[UNIQUE_VIOLATION]: makeUniqueViolation,
+	[FOREIGN_KEY_VIOLATION]: (facts, cause) => new ForeignKeyViolation({
+		constraint: facts.constraint,
+		table: facts.table,
+		detail: facts.detail,
+		cause
+	}),
+	[NOT_NULL_VIOLATION]: (facts, cause) => new NotNullViolation({
+		column: facts.column,
+		table: facts.table,
+		cause
+	}),
+	[CHECK_VIOLATION]: (facts, cause) => new CheckViolation({
+		constraint: facts.constraint,
+		table: facts.table,
+		cause
+	}),
+	[EXCLUSION_VIOLATION]: (facts, cause) => new ExclusionViolation({
+		constraint: facts.constraint,
+		table: facts.table,
+		cause
+	})
+};
+/** SQLSTATE → retryable-transaction-failure constructor; a table, as above. */
+const TRANSACTION_FAILURE_BY_CODE = {
+	[SERIALIZATION_FAILURE]: (cause) => new SerializationFailure({ cause }),
+	[DEADLOCK_DETECTED]: (cause) => new DeadlockDetected({ cause })
+};
+/** The constraint-family classification for these facts, if the SQLSTATE is one of the five. */
+const makeConstraintViolation = (facts, cause) => Option.map(Record.get(CONSTRAINT_VIOLATION_BY_CODE, facts.code), (make) => make(facts, cause));
+/** The retryable-transaction classification for these facts, if the SQLSTATE is one of the two. */
+const makeTransactionFailure = (facts, cause) => Option.map(Record.get(TRANSACTION_FAILURE_BY_CODE, facts.code), (make) => make(cause));
+/**
+* Classifies any value into one of the seven tagged errors, by finding the
+* driver's Postgres error in its graph ({@link findPgError}) and dispatching on the
+* SQLSTATE. `Option.none()` when the graph holds no driver error, or holds one
+* whose SQLSTATE is outside the classified families (a syntax error, a
+* connection failure — `SqlError.reason` already covers those well).
+*/
+const classifyError = (error) => Option.flatMap(findPgError(error), (facts) => Option.orElse(makeConstraintViolation(facts, error), () => makeTransactionFailure(facts, error)));
+/** The `23505` classification for `error`, if that is what it is. */
+const uniqueViolationOf = (cause) => Option.map(Option.filter(findPgError(cause), (facts) => facts.code === UNIQUE_VIOLATION), (facts) => makeUniqueViolation(facts, cause));
+/** The constraint-family classification for `error`, if that is what it is. */
+const constraintViolationOf = (cause) => Option.flatMap(findPgError(cause), (facts) => makeConstraintViolation(facts, cause));
+/** True when a node declares `23505` by SQLSTATE, or by the stable Postgres message fragment. */
+const uniqueViolationNode = (node) => {
+	const code = Option.orElse(readString(node, "code"), () => readString(node, "sqlState"));
+	if (Option.contains(code, UNIQUE_VIOLATION)) return Option.some(true);
+	return Option.isSome(Option.filter(readString(node, "message"), (message) => message.includes(PG_UNIQUE_VIOLATION_MESSAGE))) ? Option.some(true) : Option.none();
+};
+/**
+* True when `error` is (or wraps) a unique-constraint violation.
+*
+* Kept as its own predicate, with its own walk, for adoption parity: this is
+* the name and the semantics the consuming applications already call, and the
+* semantics include a fallback the typed classification deliberately does not
+* have — matching the stable Postgres message fragment when no `code` survived the
+* wrapping. It also matches a `23505` declared under a `code` that is not
+* SQLSTATE-shaped, which {@link classifyError} skips.
+*/
+const isUniqueViolation = (error) => Option.isSome(searchErrorGraph(error, uniqueViolationNode, 0, /* @__PURE__ */ new Set()));
+/**
+* True when `error` is (or wraps) an integrity-constraint violation — one of
+* the five `23xxx` classes {@link classifyError} recognises.
+*/
+const isConstraintViolation = (error) => Option.isSome(constraintViolationOf(error));
+/**
+* True when `error` is (or wraps) a transaction failure that re-running the
+* whole transaction may clear: a serialization failure (`40001`) or a deadlock
+* (`40P01`). Retrying a {@link ConstraintViolation} is pointless; retrying
+* these is the documented remedy.
+*/
+const isRetryableTransactionFailure = (error) => Option.isSome(Option.filter(findPgError(error), (facts) => facts.code === SERIALIZATION_FAILURE || facts.code === DEADLOCK_DETECTED));
+/**
+* Recovers from a constraint violation in the error channel, leaving every
+* other failure untouched — the failure is re-failed unchanged, with its
+* original type, so a handler for one Postgres conflict does not swallow the
+* rest of the channel.
+*
+* Data-last only: `self.pipe(catchConstraintViolation(handler))`.
+*/
+const catchConstraintViolation = (f) => (self) => Effect.catch(self, (error) => Option.match(constraintViolationOf(error), {
+	onNone: () => Effect.fail(error),
+	onSome: f
+}));
+/**
+* {@link catchConstraintViolation} narrowed to `23505`: recovers only a unique
+* violation, passing everything else — including other constraint violations —
+* through unchanged. This is the duplicate-key conflict a consumer maps to a
+* domain "already exists".
+*
+* Data-last only: `self.pipe(catchUniqueViolation(handler))`.
+*/
+const catchUniqueViolation = (f) => (self) => Effect.catch(self, (error) => Option.match(uniqueViolationOf(error), {
+	onNone: () => Effect.fail(error),
+	onSome: f
+}));
+export { CheckViolation, DeadlockDetected, ExclusionViolation, ForeignKeyViolation, NotNullViolation, SerializationFailure, UniqueViolation, catchConstraintViolation, catchUniqueViolation, classifyError, findPgError, isConstraintViolation, isRetryableTransactionFailure, isUniqueViolation };
+
+//# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.js","names":[],"sources":["../src/errors.ts"],"mappings":"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"}