@effect/sql-pg 4.0.0-rc.112 → 4.0.0-rc.113

package/src/internal/connection.ts

@@ -0,0 +1,26 @@
+import type * as Effect from "effect/Effect"
+import type * as Scope from "effect/Scope"
+import type { SqlError } from "effect/unstable/sql/SqlError"
+
+/** @internal */
+export const internalsKey = "~@effect/sql-pg/PgConnection/internals" as const
+
+/** @internal */
+export interface ConnectionInternals {
+  /** The pool item identity: the unpinned base connection. */
+  readonly base: object
+  readonly deadError: () => SqlError | undefined
+  /** Fired once when the connection dies outside its own scope release. */
+  readonly fatalHooks: Set<() => void>
+  /**
+   * Installed by a multiplexed pool so that pinning the session also takes it
+   * out of shared circulation for as long as the pin lasts. Every route to an
+   * exclusive session goes through `pin`, including `stream` and `listen`, so
+   * this is the one place that covers them all.
+   */
+  reserve?: Effect.Effect<void, never, Scope.Scope> | undefined
+}
+
+/** @internal */
+export const connectionInternals = (connection: object): ConnectionInternals =>
+  (connection as Record<typeof internalsKey, ConnectionInternals>)[internalsKey]

package/src/internal/sqlError.ts

@@ -0,0 +1,75 @@
+import {
+  AuthenticationError,
+  AuthorizationError,
+  ConnectionError,
+  ConstraintError,
+  DeadlockError,
+  LockTimeoutError,
+  SerializationError,
+  SqlError,
+  type SqlErrorReason,
+  SqlSyntaxError,
+  StatementTimeoutError,
+  UniqueViolation,
+  UnknownError
+} from "effect/unstable/sql/SqlError"
+
+interface ErrorProps {
+  readonly cause: unknown
+  readonly message: string
+  readonly operation: string
+}
+
+const channelNameEncoder = new TextEncoder()
+
+export const validateChannelName = (channel: string, operation: string): SqlError | undefined => {
+  if (channelNameEncoder.encode(channel).byteLength <= 63) return undefined
+  const message = "PostgreSQL channel names must not exceed 63 UTF-8 bytes"
+  return new SqlError({ reason: new UnknownError({ cause: new Error(message), message, operation }) })
+}
+
+const normalizeConstraint = (constraint: unknown): string => {
+  if (typeof constraint !== "string") return "unknown"
+  const normalized = constraint.trim()
+  return normalized.length === 0 ? "unknown" : normalized
+}
+
+export const classifySqlState = (
+  code: string | undefined,
+  constraint: unknown,
+  props: ErrorProps
+): SqlErrorReason => {
+  if (code !== undefined) {
+    if (code.startsWith("08")) {
+      return new ConnectionError(props)
+    }
+    if (code.startsWith("28")) {
+      return new AuthenticationError(props)
+    }
+    if (code === "42501") {
+      return new AuthorizationError(props)
+    }
+    if (code.startsWith("42")) {
+      return new SqlSyntaxError(props)
+    }
+    if (code === "23505") {
+      return new UniqueViolation({ ...props, constraint: normalizeConstraint(constraint) })
+    }
+    if (code.startsWith("23")) {
+      return new ConstraintError(props)
+    }
+    if (code === "40P01") {
+      return new DeadlockError(props)
+    }
+    if (code === "40001") {
+      return new SerializationError(props)
+    }
+    if (code === "55P03") {
+      return new LockTimeoutError(props)
+    }
+    if (code === "57014") {
+      return new StatementTimeoutError(props)
+    }
+  }
+  return new UnknownError(props)
+}