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

package/src/PgTypes.ts

@@ -18,6 +18,9 @@
  */
 import * as Data from "effect/Data"
 import * as Result from "effect/Result"
+import * as IpInterface from "effect/unstable/net/IpInterface"
+import * as IpNetwork from "effect/unstable/net/IpNetwork"
+import * as NetAddress from "effect/unstable/net/NetAddress"
 import type * as PgProtocol from "./PgProtocol.ts"
 import type { ValueSink } from "./PgProtocol.ts"
 
@@ -355,6 +358,31 @@ const elementToArray = new Map<number, number>(
   Array.from(arrayToElement, ([array, element]) => [element, array])
 )
 
+/**
+ * Options for registering a codec.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface RegisterOptions {
+  /**
+   * Registers a one-dimensional array codec at this OID and enables array type
+   * inference for the scalar codec.
+   */
+  readonly arrayOid?: number | undefined
+}
+
+/**
+ * A client-specific set of PostgreSQL binary codecs. Each registry starts with
+ * the built-in codecs and does not affect the module-level registry.
+ *
+ * @category models
+ * @since 4.0.0
+ */
+export interface Registry {
+  readonly register: <A>(oid: number, codec: Codec<A>, options?: RegisterOptions) => void
+}
+
 /**
  * Returns the array OID whose elements have the given OID, or `undefined`
  * when there is no array type registered for it.
@@ -362,7 +390,8 @@ const elementToArray = new Map<number, number>(
  * @category getters
  * @since 4.0.0
  */
-export const arrayOidFor = (elementOid: number): number | undefined => elementToArray.get(elementOid)
+export const arrayOidFor = (elementOid: number, registry?: Registry): number | undefined =>
+  registry === undefined ? elementToArray.get(elementOid) : getRegistryState(registry).elementToArray.get(elementOid)
 
 // -----------------------------------------------------------------------------
 // calendar helpers
@@ -629,123 +658,28 @@ const decodeNumeric = (bytes: Uint8Array, offset: number, size: number): string
 const PGSQL_AF_INET = 2
 const PGSQL_AF_INET6 = 3
 
-const parseIPv4 = (text: string): Uint8Array | undefined => {
-  const parts = text.split(".")
-  if (parts.length !== 4) return undefined
-  const bytes = new Uint8Array(4)
-  for (let i = 0; i < 4; i++) {
-    if (!/^\d{1,3}$/.test(parts[i])) return undefined
-    const value = Number(parts[i])
-    if (value > 255) return undefined
-    bytes[i] = value
-  }
-  return bytes
-}
-
-const parseIPv6 = (text: string): Uint8Array | undefined => {
-  const halves = text.split("::")
-  if (halves.length > 2) return undefined
-  const toGroups = (part: string): Array<string> => part === "" ? [] : part.split(":")
-  const head = toGroups(halves[0])
-  const tail = halves.length === 2 ? toGroups(halves[1]) : []
-  const bytes = new Uint8Array(16)
-
-  const trailing = tail.length > 0 ? tail[tail.length - 1] : head.length > 0 ? head[head.length - 1] : ""
-  const embedded = trailing.includes(".") ? parseIPv4(trailing) : undefined
-  if (trailing.includes(".") && embedded === undefined) return undefined
-  if (embedded !== undefined) {
-    if (tail.length > 0) tail.pop()
-    else head.pop()
-  }
-  const groupCount = embedded === undefined ? 8 : 6
-  if (head.length + tail.length > groupCount) return undefined
-  if (halves.length === 1 && head.length !== groupCount) return undefined
-
-  const writeGroup = (group: string, offset: number): boolean => {
-    if (!/^[0-9a-fA-F]{1,4}$/.test(group)) return false
-    const value = Number.parseInt(group, 16)
-    bytes[offset] = value >> 8
-    bytes[offset + 1] = value & 0xff
-    return true
-  }
-  for (let i = 0; i < head.length; i++) {
-    if (!writeGroup(head[i], i * 2)) return undefined
-  }
-  for (let i = 0; i < tail.length; i++) {
-    if (!writeGroup(tail[i], (groupCount - tail.length + i) * 2)) return undefined
-  }
-  if (embedded !== undefined) bytes.set(embedded, 12)
-  return bytes
-}
-
-const formatIPv4 = (bytes: Uint8Array, offset: number): string =>
-  `${bytes[offset]}.${bytes[offset + 1]}.${bytes[offset + 2]}.${bytes[offset + 3]}`
-
-const formatIPv6 = (bytes: Uint8Array, offset: number): string => {
-  let isV4Mapped = bytes[offset + 10] === 0xff && bytes[offset + 11] === 0xff
-  for (let i = 0; isV4Mapped && i < 10; i++) isV4Mapped = bytes[offset + i] === 0
-  if (isV4Mapped) return `::ffff:${formatIPv4(bytes, offset + 12)}`
-
-  const groups: Array<number> = []
-  for (let i = 0; i < 8; i++) groups.push(readUint16(bytes, offset + i * 2))
-
-  let bestStart = -1
-  let bestLength = 0
-  let start = -1
-  for (let i = 0; i <= 8; i++) {
-    if (i < 8 && groups[i] === 0) {
-      if (start === -1) start = i
-    } else if (start !== -1) {
-      if (i - start > bestLength) {
-        bestStart = start
-        bestLength = i - start
-      }
-      start = -1
-    }
-  }
-  if (bestLength < 2) {
-    return groups.map((group) => group.toString(16)).join(":")
-  }
-  const head = groups.slice(0, bestStart).map((group) => group.toString(16)).join(":")
-  const tail = groups.slice(bestStart + bestLength).map((group) => group.toString(16)).join(":")
-  return `${head}::${tail}`
-}
-
-const hasHostBits = (bytes: Uint8Array, offset: number, length: number, bits: number): boolean => {
-  const wholeBytes = Math.floor(bits / 8)
-  const partialBits = bits % 8
-  if (partialBits !== 0 && (bytes[offset + wholeBytes] & ((1 << (8 - partialBits)) - 1)) !== 0) {
-    return true
-  }
-  for (let index = wholeBytes + (partialBits === 0 ? 0 : 1); index < length; index++) {
-    if (bytes[offset + index] !== 0) return true
-  }
-  return false
-}
-
 const encodeInet = (value: unknown, isCidr: boolean): Uint8Array => {
-  const text = requireString(value, isCidr ? "cidr" : "inet")
-  const slash = text.lastIndexOf("/")
-  const address = slash === -1 ? text : text.slice(0, slash)
-  const v4 = parseIPv4(address)
-  const bytes = v4 ?? parseIPv6(address)
-  if (bytes === undefined) {
-    return fail(`Expected an IP address, received "${text}"`)
-  }
-  const fullBits = bytes.length * 8
-  const bits = slash === -1 ? fullBits : Number(text.slice(slash + 1))
-  if (!Number.isInteger(bits) || bits < 0 || bits > fullBits) {
-    return fail(`Invalid netmask length in "${text}"`)
-  }
-  if (isCidr && hasHostBits(bytes, 0, bytes.length, bits)) {
-    return fail(`CIDR address has host bits set in "${text}"`)
+  const type = isCidr ? "cidr" : "inet"
+  const text = requireString(value, type)
+  const parsed = IpInterface.fromString(text)
+  if (Result.isFailure(parsed)) return fail(`Invalid ${type} value ${JSON.stringify(text)}: ${parsed.failure.message}`)
+  const address = parsed.success.address
+  const bits = parsed.success.prefixLength
+  if (isCidr) {
+    const network = IpNetwork.make(address, bits)
+    if (Result.isFailure(network)) {
+      return fail(`Invalid ${type} value ${JSON.stringify(text)}: ${network.failure.message}`)
+    }
   }
-  const result = new Uint8Array(4 + bytes.length)
-  result[0] = v4 === undefined ? PGSQL_AF_INET6 : PGSQL_AF_INET
+  const octets = NetAddress.isIpv4Address(address)
+    ? NetAddress.ipv4ToOctets(address)
+    : NetAddress.ipv6ToOctets(address)
+  const result = new Uint8Array(4 + octets.length)
+  result[0] = NetAddress.isIpv4Address(address) ? PGSQL_AF_INET : PGSQL_AF_INET6
   result[1] = bits
   result[2] = isCidr ? 1 : 0
-  result[3] = bytes.length
-  result.set(bytes, 4)
+  result[3] = octets.length
+  result.set(octets, 4)
   return result
 }
 
@@ -763,11 +697,18 @@ const decodeInet = (bytes: Uint8Array, offset: number, size: number): string =>
   }
   requireSize(size, 4 + addressSize, "inet")
   if (bits > addressSize * 8) return fail(`Invalid inet netmask length: ${bits}`)
-  if (isCidr && hasHostBits(bytes, offset + 4, addressSize, bits)) {
-    return fail("CIDR address has host bits set")
-  }
-  const text = family === PGSQL_AF_INET ? formatIPv4(bytes, offset + 4) : formatIPv6(bytes, offset + 4)
-  return isCidr || bits !== addressSize * 8 ? `${text}/${bits}` : text
+  const addressBytes = bytes.slice(offset + 4, offset + 4 + addressSize)
+  const address = family === PGSQL_AF_INET
+    ? NetAddress.ipv4FromBytesUnsafe(addressBytes)
+    : NetAddress.ipv6FromBytesUnsafe(addressBytes)
+  if (isCidr) {
+    const network = IpNetwork.make(address, bits)
+    if (Result.isFailure(network)) return fail(network.failure.message)
+    return IpNetwork.format(network.success)
+  }
+  return bits === addressSize * 8
+    ? NetAddress.formatIp(address)
+    : IpInterface.format(IpInterface.makeUnsafe(address, bits))
 }
 
 // -----------------------------------------------------------------------------
@@ -956,6 +897,34 @@ interface UnsafeCodec<A> {
   readonly read?: (bytes: Uint8Array, offset: number, size: number) => A
 }
 
+type Lookup = (oid: number) => UnsafeCodec<any> | undefined
+
+const toUnsafeCodec = <A>(codec: Codec<A>): UnsafeCodec<A> => ({
+  encode(value) {
+    const encoded = codec.encode(value)
+    if (Result.isFailure(encoded)) throw encoded.failure
+    return encoded.success
+  },
+  decode(bytes) {
+    const decoded = codec.decode(bytes)
+    if (Result.isFailure(decoded)) throw decoded.failure
+    return decoded.success
+  },
+  ...(codec.write === undefined ? undefined : {
+    write(sink: ValueSink, value: A) {
+      const written = codec.write!(sink, value)
+      if (Result.isFailure(written)) throw written.failure
+    }
+  }),
+  ...(codec.read === undefined ? undefined : {
+    read(bytes: Uint8Array, offset: number, size: number) {
+      const decoded = codec.read!(bytes, offset, size)
+      if (Result.isFailure(decoded)) throw decoded.failure
+      return decoded.success
+    }
+  })
+})
+
 /** A codec whose `decode` is its `read` over the whole of its bytes. */
 const codecOf = <A>(
   read: (bytes: Uint8Array, offset: number, size: number) => A,
@@ -1181,7 +1150,7 @@ const jsonbCodec: UnsafeCodec<any> = codecOf(
   }
 )
 
-const builtins = new Map<number, UnsafeCodec<any>>([
+const builtinScalars = new Map<number, UnsafeCodec<any>>([
   [
     OID.bool,
     codecOf(
@@ -1340,16 +1309,14 @@ const builtins = new Map<number, UnsafeCodec<any>>([
   [OID.timestamptz, timestampCodec]
 ])
 
-for (const [arrayOid, elementOid] of arrayToElement) {
-  builtins.set(
-    arrayOid,
-    codecOf(
-      (bytes, offset, size) => decodeArray(bytes, offset, size, elementOid),
-      (value) => encodeArray(value, elementOid),
-      (sink, value) => writeArray(sink, value, elementOid)
-    )
+const makeArrayCodec = (elementOid: number, lookup: Lookup): UnsafeCodec<ReadonlyArray<unknown>> =>
+  codecOf(
+    (bytes, offset, size) => decodeArray(bytes, offset, size, elementOid, lookup),
+    (value) => encodeArray(value, elementOid, lookup),
+    (sink, value) => writeArray(sink, value, elementOid, lookup)
   )
-}
+
+const builtins = new Map<number, UnsafeCodec<any>>(builtinScalars)
 
 /**
  * Built-ins with registered codecs layered over them, so `encode` and `decode`
@@ -1365,10 +1332,69 @@ const codecs = new Map<number, UnsafeCodec<any>>(builtins)
 const tableSize = 4096
 
 const table = new Array<UnsafeCodec<any> | undefined>(tableSize)
-for (const [oid, codec] of codecs) table[oid] = codec
 
 const lookup = (oid: number): UnsafeCodec<any> | undefined => oid >= 0 && oid < tableSize ? table[oid] : codecs.get(oid)
 
+for (const [arrayOid, elementOid] of arrayToElement) {
+  const codec = makeArrayCodec(elementOid, lookup)
+  builtins.set(arrayOid, codec)
+  codecs.set(arrayOid, codec)
+}
+for (const [oid, codec] of codecs) table[oid] = codec
+
+interface RegistryState {
+  readonly codecs: Map<number, UnsafeCodec<any>>
+  readonly elementToArray: Map<number, number>
+  readonly lookup: Lookup
+}
+
+const registryStates = new WeakMap<Registry, RegistryState>()
+
+const getRegistryState = (registry: Registry): RegistryState => {
+  const state = registryStates.get(registry)
+  if (state === undefined) return fail("Invalid PgTypes Registry")
+  return state
+}
+
+const registerInState = <A>(
+  state: RegistryState,
+  oid: number,
+  codec: Codec<A>,
+  options?: RegisterOptions
+): void => {
+  state.codecs.set(oid, toUnsafeCodec(codec))
+  if (options?.arrayOid !== undefined) {
+    state.elementToArray.set(oid, options.arrayOid)
+    state.codecs.set(options.arrayOid, makeArrayCodec(oid, state.lookup))
+  }
+}
+
+/**
+ * Creates a client-specific registry containing the built-in codecs.
+ *
+ * @category constructors
+ * @since 4.0.0
+ */
+export const makeRegistry = (): Registry => {
+  const codecs = new Map<number, UnsafeCodec<any>>(builtinScalars)
+  const state: RegistryState = {
+    codecs,
+    elementToArray: new Map(elementToArray),
+    lookup: (oid) => codecs.get(oid)
+  }
+  for (const [arrayOid, elementOid] of arrayToElement) {
+    codecs.set(arrayOid, makeArrayCodec(elementOid, state.lookup))
+  }
+  const registry: Registry = {
+    register: (oid, codec, options) => registerInState(state, oid, codec, options)
+  }
+  registryStates.set(registry, state)
+  return registry
+}
+
+const lookupFor = (registry: Registry | undefined): Lookup =>
+  registry === undefined ? lookup : getRegistryState(registry).lookup
+
 /**
  * Registers a binary codec for an OID the built-in catalogue does not cover,
  * or overrides a built-in one. Registered codecs take precedence.
@@ -1377,31 +1403,7 @@ const lookup = (oid: number): UnsafeCodec<any> | undefined => oid >= 0 && oid <
  * @since 4.0.0
  */
 export const register = <A>(oid: number, codec: Codec<A>): void => {
-  const unsafe: UnsafeCodec<A> = {
-    encode(value) {
-      const encoded = codec.encode(value)
-      if (Result.isFailure(encoded)) throw encoded.failure
-      return encoded.success
-    },
-    decode(bytes) {
-      const decoded = codec.decode(bytes)
-      if (Result.isFailure(decoded)) throw decoded.failure
-      return decoded.success
-    },
-    ...(codec.write === undefined ? undefined : {
-      write(sink: ValueSink, value: A) {
-        const written = codec.write!(sink, value)
-        if (Result.isFailure(written)) throw written.failure
-      }
-    }),
-    ...(codec.read === undefined ? undefined : {
-      read(bytes: Uint8Array, offset: number, size: number) {
-        const decoded = codec.read!(bytes, offset, size)
-        if (Result.isFailure(decoded)) throw decoded.failure
-        return decoded.success
-      }
-    })
-  }
+  const unsafe = toUnsafeCodec(codec)
   codecs.set(oid, unsafe)
   if (oid >= 0 && oid < tableSize) table[oid] = unsafe
 }
@@ -1423,7 +1425,7 @@ export const unregister = (oid: number): void => {
 // arrays
 // -----------------------------------------------------------------------------
 
-const encodeArray = (value: unknown, elementOid: number): Uint8Array => {
+const encodeArray = (value: unknown, elementOid: number, lookup: Lookup): Uint8Array => {
   if (!Array.isArray(value)) {
     return fail("Expected an array")
   }
@@ -1475,7 +1477,7 @@ const encodeArray = (value: unknown, elementOid: number): Uint8Array => {
  * and written in place, so neither the elements nor the array itself needs an
  * array of bytes of its own.
  */
-const writeArray = (sink: ValueSink, value: unknown, elementOid: number): void => {
+const writeArray = (sink: ValueSink, value: unknown, elementOid: number, lookup: Lookup): void => {
   if (!Array.isArray(value)) {
     return fail("Expected an array")
   }
@@ -1506,7 +1508,7 @@ const writeArray = (sink: ValueSink, value: unknown, elementOid: number): void =
       sink.int32(-1)
     } else {
       const token = sink.beginLength()
-      if (write === undefined) writeValue(sink, element, elementOid)
+      if (write === undefined) writeValue(sink, element, elementOid, lookup)
       else write(sink, element)
       sink.endLength(token)
     }
@@ -1522,7 +1524,8 @@ const decodeArray = (
   bytes: Uint8Array,
   start: number,
   size: number,
-  elementOid: number
+  elementOid: number,
+  lookup: Lookup
 ): ReadonlyArray<unknown> => {
   if (size < 12) return fail("Truncated array value")
   const dimensions = readInt32(bytes, start)
@@ -1584,18 +1587,15 @@ export interface Column {
 }
 
 /**
- * Builds a field reader for `PgProtocol.makeParser`, so a result's rows decode
- * as they are parsed rather than through a view per column.
+ * Creates a field reader for `PgProtocol.makeParser`.
+ *
+ * **Details**
  *
- * Every column is resolved once here rather than once per row, and a codec that
- * can read in place does; the rest are handed a view. SQL NULL reads as `null`,
- * and a column whose OID has no codec reads as a copy of its bytes.
+ * Codecs are resolved once per column. SQL `NULL` becomes `null`, and columns
+ * without a registered codec return a copy of their bytes. Text-format columns
+ * fail with `CodecError`.
  *
- * Only the binary format is supported, and a text column returns a
- * `CodecError` failure here rather than once per row. A successful result
- * contains the parser's internal throwing fast path; its failures are terminal
- * for that parser. The standalone `encode` and `decode` APIs remain typed
- * `Result` values.
+ * **Example** (Updating the reader after `RowDescription`)
  *
  * ```ts
  * import { PgProtocol, PgTypes } from "@effect/sql-pg"
@@ -1610,9 +1610,11 @@ export interface Column {
  * @since 4.0.0
  */
 export const makeFieldReader = (
-  columns: ReadonlyArray<Column>
+  columns: ReadonlyArray<Column>,
+  registry?: Registry
 ): Result.Result<PgProtocol.FieldReader<unknown>, CodecError> =>
   result(() => {
+    const lookup = lookupFor(registry)
     const codecs = columns.map((column, index) => {
       if (column.format !== 1) {
         return fail(`Only the binary format is supported, column ${index} has format ${column.format}`)
@@ -1631,15 +1633,17 @@ export const makeFieldReader = (
 /**
  * Encodes a JavaScript value as the binary representation of the given OID.
  *
+ * **Details**
+ *
  * Returns a `CodecError` failure when the value has the wrong JavaScript type,
  * or when the OID is neither built in nor registered.
  *
  * @category encoding
  * @since 4.0.0
  */
-export const encode = (value: unknown, oid: number): Result.Result<Uint8Array, CodecError> =>
+export const encode = (value: unknown, oid: number, registry?: Registry): Result.Result<Uint8Array, CodecError> =>
   result(() => {
-    const codec = lookup(oid)
+    const codec = lookupFor(registry)(oid)
     if (codec === undefined) return fail(`No codec registered for OID ${oid}`)
     return codec.encode(value)
   })
@@ -1647,6 +1651,8 @@ export const encode = (value: unknown, oid: number): Result.Result<Uint8Array, C
 /**
  * Decodes the binary representation of the given OID.
  *
+ * **Details**
+ *
  * `format` must be `1`; the text format is not implemented. An OID that is
  * neither built in nor registered decodes to the raw bytes.
  *
@@ -1656,13 +1662,14 @@ export const encode = (value: unknown, oid: number): Result.Result<Uint8Array, C
 export const decode = (
   bytes: Uint8Array,
   oid: number,
-  format: number
+  format: number,
+  registry?: Registry
 ): Result.Result<unknown, CodecError> =>
   result(() => {
     if (format !== 1) {
       return fail(`Only the binary format is supported, received format ${format}`)
     }
-    const codec = lookup(oid)
+    const codec = lookupFor(registry)(oid)
     return codec === undefined ? bytes : codec.decode(bytes)
   })
 
@@ -1670,6 +1677,22 @@ export const decode = (
 // parameter constructors
 // -----------------------------------------------------------------------------
 
+/**
+ * The runtime type identifier for PostgreSQL parameters.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+export const ParameterTypeId: ParameterTypeId = "~@effect/sql-pg/PgTypes/Parameter"
+
+/**
+ * The type-level identifier for PostgreSQL parameters.
+ *
+ * @category type IDs
+ * @since 4.0.0
+ */
+export type ParameterTypeId = "~@effect/sql-pg/PgTypes/Parameter"
+
 /**
  * A value paired with the OID it should be encoded as.
  *
@@ -1677,26 +1700,49 @@ export const decode = (
  * @since 4.0.0
  */
 export interface Parameter {
+  readonly [ParameterTypeId]: ParameterTypeId
   readonly oid: number
   readonly value: unknown
 }
 
+/**
+ * Returns whether a value is a parameter created by this module.
+ *
+ * @category guards
+ * @since 4.0.0
+ */
+export const isParameter = (value: unknown): value is Parameter =>
+  typeof value === "object" && value !== null && (value as any)[ParameterTypeId] === ParameterTypeId
+
 /**
  * Encodes a parameter for a `Bind` message. SQL NULL stays `null`.
  *
  * @category encoding
  * @since 4.0.0
  */
-export const encodeParameter = (parameter: Parameter): Result.Result<Uint8Array | null, CodecError> =>
-  parameter.value === null ? Result.succeed(null) : encode(parameter.value, parameter.oid)
+export const encodeParameter = (
+  parameter: Parameter,
+  registry?: Registry
+): Result.Result<Uint8Array | null, CodecError> =>
+  parameter.value === null ? Result.succeed(null) : encode(parameter.value, parameter.oid, registry)
 
-const writeValue = (sink: ValueSink, value: unknown, oid: number): void => {
+const writeValue = (sink: ValueSink, value: unknown, oid: number, lookup: Lookup): void => {
   const codec = lookup(oid)
   if (codec === undefined) return fail(`No codec registered for OID ${oid}`)
   if (codec.write === undefined) sink.raw(codec.encode(value))
   else codec.write(sink, value)
 }
 
+/**
+ * Returns whether a parameter uses the text format in a `Bind` message.
+ * Untyped parameters (OID `0`) use text so PostgreSQL can infer their type;
+ * typed parameters use the binary format.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
+export const isTextFormat = (parameter: Parameter): boolean => parameter.oid === 0
+
 /**
  * Writes a parameter into a `Bind` frame, for `PgProtocol.makeBindEncoder`.
  * Codecs that can write their bytes in place do; the rest fall back to
@@ -1705,15 +1751,28 @@ const writeValue = (sink: ValueSink, value: unknown, oid: number): void => {
  * @category encoding
  * @since 4.0.0
  */
-const writeParameterUnsafe = (sink: ValueSink, parameter: Parameter): void =>
-  parameter.value === null ? sink.sqlNull() : writeValue(sink, parameter.value, parameter.oid)
+const writeParameterUnsafe = (sink: ValueSink, parameter: Parameter, lookup: Lookup): void =>
+  parameter.value === null
+    ? sink.sqlNull()
+    // An untyped parameter is the value's text representation; see
+    // `isTextFormat`.
+    : parameter.oid === 0
+    ? sink.utf8(String(parameter.value))
+    : writeValue(sink, parameter.value, parameter.oid, lookup)
 
+/**
+ * Writes a parameter into a `Bind` frame.
+ *
+ * @category encoding
+ * @since 4.0.0
+ */
 export const writeParameter = (
   sink: ValueSink,
-  parameter: Parameter
+  parameter: Parameter,
+  registry?: Registry
 ): Result.Result<void, CodecError> => {
   try {
-    writeParameterUnsafe(sink, parameter)
+    writeParameterUnsafe(sink, parameter, lookupFor(registry))
     return Result.void
   } catch (error) {
     if (error instanceof CodecError) return Result.fail(error)
@@ -1722,9 +1781,17 @@ export const writeParameter = (
 }
 
 const valueWriterUnsafe = Symbol.for("@effect/sql-pg/PgProtocol/ValueWriter/unsafe")
-Object.defineProperty(writeParameter, valueWriterUnsafe, { value: writeParameterUnsafe })
+Object.defineProperty(writeParameter, valueWriterUnsafe, {
+  value: (sink: ValueSink, parameter: Parameter) => writeParameterUnsafe(sink, parameter, lookup)
+})
+
+const makeParameter = (oid: number, value: unknown): Parameter => ({
+  [ParameterTypeId]: ParameterTypeId,
+  oid,
+  value
+})
 
-const parameter = (oid: number) => (value: unknown): Parameter => ({ oid, value })
+const parameter = (oid: number) => (value: unknown): Parameter => makeParameter(oid, value)
 
 /**
  * A `bool` parameter.
@@ -1919,12 +1986,13 @@ export const timestamptz: (value: number | null) => Parameter = parameter(OID.ti
  */
 export const array = (
   values: ReadonlyArray<unknown> | null,
-  elementOid: number
+  elementOid: number,
+  registry?: Registry
 ): Result.Result<Parameter, CodecError> =>
   result(() => {
-    const arrayOid = elementToArray.get(elementOid)
+    const arrayOid = arrayOidFor(elementOid, registry)
     if (arrayOid === undefined) {
       return fail(`No array type known for element OID ${elementOid}`)
     }
-    return { oid: arrayOid, value: values }
+    return makeParameter(arrayOid, values)
   })

package/src/index.ts

@@ -14,11 +14,21 @@ export * as PgAuth from "./PgAuth.ts"
  */
 export * as PgClient from "./PgClient.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as PgConnection from "./PgConnection.ts"
+
 /**
  * @since 4.0.0
  */
 export * as PgMigrator from "./PgMigrator.ts"
 
+/**
+ * @since 4.0.0
+ */
+export * as PgPool from "./PgPool.ts"
+
 /**
  * @since 4.0.0
  */