effect-qb 0.17.0 → 0.20.0

package/src/mysql/internal/renderer.ts

@@ -1,9 +1,10 @@
 import * as Query from "../../internal/query.js"
 import type * as Expression from "../../internal/scalar.js"
+import type * as Casing from "../../internal/casing.js"
 import { type RenderState } from "../../internal/dialect.js"
 import { mysqlDialect } from "./dialect.js"
 import { type Projection } from "../../internal/projections.js"
-import { renderQueryAst } from "./sql-expression-renderer.js"
+import { renderQueryAst } from "../../internal/sql-expression-renderer.js"
 
 /**
  * Internal rendered-query payload produced by the built-in MySQL renderer.
@@ -17,6 +18,7 @@ export interface MysqlRenderResult {
 
 export interface MysqlRenderOptions {
   readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
 }
 
 /**
@@ -29,9 +31,11 @@ export const renderMysqlPlan = <PlanValue extends Query.Plan.Any>(
   const state: RenderState = {
     params: [],
     valueMappings: options.valueMappings,
+    casing: options.casing,
     ctes: [],
     cteNames: new Set<string>(),
-    cteSources: new Map<string, unknown>()
+    cteSources: new Map<string, unknown>(),
+    sourceNames: new Map()
   }
   const rendered = renderQueryAst(
     Query.getAst(plan as Query.Plan.Any) as any,

package/src/mysql/json.ts

@@ -1,2 +1,7 @@
-/** MySQL JSON expression helpers. */
-export { json } from "./internal/dsl.js"
+/** MySQL-specific JSON expression helpers. Portable JSON helpers are exported from `effect-qb`. */
+import { json } from "./internal/dsl.js"
+
+export const typeOf = json.typeOf
+export const length = json.length
+export const stripNulls = json.stripNulls
+export const pathMatch = json.pathMatch

package/src/mysql/query-extension.ts

@@ -0,0 +1,16 @@
+import { lock } from "./query.js"
+
+/** MySQL-only mutation modifier for UPDATE IGNORE. */
+export const ignore = lock("ignore")
+
+/** MySQL-only mutation modifier for DELETE QUICK. */
+export const quick = lock("quick")
+
+/** MySQL-only mutation modifier for LOW_PRIORITY mutations. */
+export const lowPriority = lock("lowPriority")
+
+/** MySQL-only mutation ordering and limiting. */
+export { orderBy, limit } from "./query.js"
+
+/** MySQL-only multi-target mutation forms. */
+export { update, delete } from "./query.js"

package/src/mysql/renderer.ts

@@ -1,5 +1,9 @@
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
 import * as CoreRenderer from "../internal/renderer.js"
+import * as Casing from "../internal/casing.js"
 import type * as Expression from "../internal/scalar.js"
+import type { MysqlDatatypeFamily, MysqlDatatypeKind } from "./datatypes/spec.js"
 import { renderMysqlPlan } from "./internal/renderer.js"
 
 /** MySQL-specialized rendered query shape. */
@@ -7,18 +11,48 @@ export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "mysql">
 /** Extracts the row type carried by a MySQL rendered query. */
 export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
 /** MySQL-specialized renderer contract. */
-export type Renderer = CoreRenderer.Renderer<"mysql">
+export type Renderer = CoreRenderer.Renderer<"mysql"> & Pipeable & {
+  readonly [Casing.TypeId]: Casing.State
+  readonly withCasing: (options: Casing.Options) => Renderer
+}
+
+export type ValueMappings = Expression.DriverValueMappingsFor<MysqlDatatypeKind | "uuid", MysqlDatatypeFamily | "uuid">
 
 export interface MakeOptions {
-  readonly valueMappings?: Expression.DriverValueMappings
+  readonly valueMappings?: ValueMappings
+}
+
+interface RendererState extends MakeOptions {
+  readonly casing?: Casing.Options
 }
 
 export { TypeId } from "../internal/renderer.js"
 export type { Projection } from "../internal/renderer.js"
 
+const RendererProto = {
+  pipe(this: Pipeable) {
+    return pipeArguments(this, arguments)
+  }
+}
+
+/** Creates the built-in MySQL renderer. */
+const makeWithState = (state: RendererState = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("mysql", (plan) => renderMysqlPlan(plan, state))
+  return Object.assign(Object.create(RendererProto), renderer, {
+    [Casing.TypeId]: {
+      casing: state.casing
+    },
+    withCasing: (override: Casing.Options) =>
+      makeWithState({
+        ...state,
+        casing: Casing.merge(state.casing, override)
+      })
+  }) as Renderer
+}
+
 /** Creates the built-in MySQL renderer. */
 export const make = (options: MakeOptions = {}): Renderer =>
-  CoreRenderer.make("mysql", (plan) => renderMysqlPlan(plan, options))
+  makeWithState({ valueMappings: options.valueMappings })
 
 /** Shared built-in MySQL renderer instance. */
 export const mysql = make()

package/src/mysql/type.ts

@@ -0,0 +1,60 @@
+import type * as Expression from "../internal/scalar.js"
+import type { NonEmptyStringInput } from "../internal/table-options.js"
+import {
+  mysqlSpecificDatatypeKeys,
+  pickDatatypeConstructors,
+  type MysqlSpecificDatatypeKey
+} from "../internal/datatypes/matrix.js"
+import { mysqlDatatypes } from "./datatypes/index.js"
+
+type MysqlSpecificDatatypes = Pick<typeof mysqlDatatypes, MysqlSpecificDatatypeKey>
+
+type MysqlTypeNamespace = MysqlSpecificDatatypes & {
+  readonly enum: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Enum<"mysql", Kind>
+  readonly set: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Set<"mysql", Kind>
+  readonly custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Base<"mysql", Kind>
+  readonly driverValueMapping: <Db extends Expression.DbType.Any>(
+    dbType: Db,
+    mapping: Expression.DriverValueMapping
+  ) => Db
+}
+
+const enum_ = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Enum<"mysql", Kind> => ({
+  dialect: "mysql",
+  kind: kind as Kind,
+  variant: "enum"
+})
+
+const set = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Set<"mysql", Kind> => ({
+  dialect: "mysql",
+  kind: kind as Kind,
+  variant: "set"
+})
+
+const custom = <Kind extends string>(
+  kind: NonEmptyStringInput<Kind>
+): Expression.DbType.Base<"mysql", Kind> => ({
+  dialect: "mysql",
+  kind: kind as Kind
+})
+
+const driverValueMapping = <Db extends Expression.DbType.Any>(
+  dbType: Db,
+  mapping: Expression.DriverValueMapping
+): Db => ({
+  ...dbType,
+  driverValueMapping: mapping
+})
+
+/** MySQL-only database-type constructors for casts and typed column references. */
+export const type: MysqlTypeNamespace = {
+  ...pickDatatypeConstructors(mysqlDatatypes, mysqlSpecificDatatypeKeys),
+  enum: enum_,
+  set,
+  custom,
+  driverValueMapping
+}

package/src/mysql.ts

@@ -1,22 +1,16 @@
-/** MySQL-specialized column-definition DSL. */
-export * as Column from "./mysql/column.js"
+/** MySQL-specific column extensions. Portable columns are exported from `effect-qb`. */
+export * as Column from "./mysql/column-extension.js"
 /** MySQL datatype witnesses and coercion families. */
 export * as Datatypes from "./mysql/datatypes/index.js"
 /** MySQL error catalog and error normalization helpers. */
 export * as Errors from "./mysql/errors/index.js"
-/** Shared scalar SQL interfaces and DB-type descriptors. */
-export * as Scalar from "./internal/scalar.js"
-/** MySQL-specialized SQL function expressions. */
-export * as Function from "./mysql/function/index.js"
-/** MySQL-specialized JSON expression helpers. */
+/** MySQL-specific JSON expression helpers. Portable JSON helpers are exported from the root package. */
 export * as Json from "./mysql/json.js"
 /** MySQL-specialized typed query execution contracts. */
 export * as Executor from "./mysql/executor.js"
-/** Shared logical row-set interfaces. */
-export * as RowSet from "./internal/row-set.js"
-/** MySQL-specialized query-construction DSL. */
-export * as Query from "./mysql/query.js"
-/** MySQL-specialized table-definition DSL. */
-export * as Table from "./mysql/table.js"
+/** MySQL-specific query helpers. Portable queries are exported from the root package. */
+export * as Query from "./mysql/query-extension.js"
+/** MySQL-only database-type constructors for casts and typed references. */
+export { type as Type } from "./mysql/type.js"
 /** MySQL-specialized built-in renderer entrypoint. */
 export * as Renderer from "./mysql/renderer.js"

package/src/postgres/check.ts

@@ -0,0 +1 @@
+export { noInherit } from "./table.js"

package/src/postgres/column-extension.ts

@@ -0,0 +1,28 @@
+export {
+  array,
+  bit,
+  bytea,
+  custom,
+  ddlType,
+  float4,
+  float8,
+  foreignKey,
+  identityAlways,
+  identityByDefault,
+  index,
+  int2,
+  int8,
+  interval,
+  jsonb,
+  name,
+  oid,
+  pg_lsn,
+  regclass,
+  timetz,
+  timestamptz,
+  unique,
+  varbit,
+  xml
+} from "./column.js"
+
+export type { Any, AnyBound } from "./column.js"

package/src/postgres/column.ts

@@ -3,6 +3,7 @@ import * as Schema from "effect/Schema"
 import * as BaseColumn from "../internal/column.js"
 import { makeColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
 import type * as Expression from "../internal/scalar.js"
+import { enrichDbType } from "../internal/datatypes/enrich.js"
 import {
   BigIntStringSchema,
   DecimalStringSchema,
@@ -21,15 +22,8 @@ import {
 } from "../internal/runtime/value.js"
 import { postgresDatatypes } from "./datatypes/index.js"
 
-const enrichDbType = <Db extends Expression.DbType.Any>(dbType: Db): Db => {
-  const candidate = (postgresDatatypes as unknown as Record<string, (() => Expression.DbType.Any) | undefined>)[dbType.kind]
-  return typeof candidate === "function"
-    ? { ...candidate(), ...dbType } as Db
-    : dbType
-}
-
 const primitive = <Type, Db extends Expression.DbType.Any>(
-  schema: Schema.Schema<Type, any, any>,
+  schema: Schema.Schema<Type>,
   dbType: Db
 ): ColumnDefinition<Type, Type, Type, Db, false, false, false, false, false, undefined> =>
   makeColumnDefinition(schema as Schema.Schema<NonNullable<Type>>, {
@@ -57,16 +51,16 @@ const renderNumericDdlType = (
 const boundedString = (length?: number): Schema.Schema<string> =>
   length === undefined
     ? Schema.String
-    : Schema.String.pipe(Schema.maxLength(length))
+    : Schema.String.check(Schema.isMaxLength(length))
 
-const finiteNumber = Schema.Number.pipe(Schema.finite())
+const finiteNumber = Schema.Number.check(Schema.isFinite())
 
-export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
+export const custom = <SchemaType extends Schema.Top, Db extends Expression.DbType.Any>(
   schema: SchemaType,
   dbType: Db
 ) =>
-  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
-    dbType: enrichDbType(dbType),
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
+    dbType: enrichDbType(postgresDatatypes, dbType),
     nullable: false,
     hasDefault: false,
     generated: false,
@@ -77,7 +71,7 @@ export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expressi
     identity: undefined
   })
 
-export const uuid = () => primitive(Schema.UUID, postgresDatatypes.uuid())
+export const uuid = () => primitive(Schema.String.check(Schema.isUUID()), postgresDatatypes.uuid())
 export const text = () => primitive(Schema.String, postgresDatatypes.text())
 export const int = () => primitive(Schema.Int, postgresDatatypes.int4())
 export const int2 = () => primitive(Schema.Int, postgresDatatypes.int2())
@@ -103,7 +97,7 @@ export const time = () => primitive(LocalTimeStringSchema, postgresDatatypes.tim
 export const timetz = () => primitive(OffsetTimeStringSchema, postgresDatatypes.timetz())
 export const timestamptz = () => primitive(InstantStringSchema, postgresDatatypes.timestamptz())
 export const interval = () => primitive(Schema.String, postgresDatatypes.interval())
-export const bytea = () => primitive(Schema.Uint8ArrayFromSelf, postgresDatatypes.bytea())
+export const bytea = () => primitive(Schema.Uint8Array, postgresDatatypes.bytea())
 export const name = () => primitive(Schema.String, postgresDatatypes.name())
 export const oid = () => primitive(Schema.Int, postgresDatatypes.oid())
 export const regclass = () => primitive(Schema.String, postgresDatatypes.regclass())
@@ -135,8 +129,8 @@ export const varchar = (length?: number) =>
     ddlType: length === undefined ? "varchar" : `varchar(${length})`,
     identity: undefined
   })
-export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
-  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+export const json = <SchemaType extends Schema.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: postgresDatatypes.json(),
     nullable: false,
     hasDefault: false,
@@ -147,8 +141,8 @@ export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =
     ddlType: undefined,
     identity: undefined
   })
-export const jsonb = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
-  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+export const jsonb = <SchemaType extends Schema.Top>(schema: SchemaType) =>
+  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>>, {
     dbType: postgresDatatypes.jsonb(),
     nullable: false,
     hasDefault: false,

package/src/postgres/datatypes/index.d.ts

@@ -1,7 +1,8 @@
 import type * as Expression from "../../internal/scalar.js";
+import type { NonEmptyStringInput } from "../../internal/table-options.js";
 import { postgresDatatypeFamilies, postgresDatatypeKinds } from "./spec.js";
 export declare const postgresDatatypes: {
-    custom: <Kind extends string>(kind: Kind) => Expression.DbType.Base<"postgres", Kind>;
+    custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Base<"postgres", Kind>;
     text: () => Expression.DbType.Base<"postgres", "text"> & {
         readonly family: "text";
         readonly runtime: "string";

package/src/postgres/datatypes/index.ts

@@ -1,5 +1,6 @@
 import type { DatatypeModule } from "../../internal/datatypes/define.js"
 import type * as Expression from "../../internal/scalar.js"
+import type { NonEmptyStringInput } from "../../internal/table-options.js"
 import { postgresDatatypeFamilies, postgresDatatypeKinds } from "./spec.js"
 
 const withMetadata = <Kind extends keyof typeof postgresDatatypeKinds & string>(
@@ -14,14 +15,15 @@ const withMetadata = <Kind extends keyof typeof postgresDatatypeKinds & string>(
     runtime: kindSpec.runtime,
     compareGroup: familySpec?.compareGroup,
     castTargets: familySpec?.castTargets,
+    implicitTargets: (familySpec as { readonly implicitTargets?: readonly string[] }).implicitTargets,
     traits: familySpec?.traits
   }
 }
 
 const postgresDatatypeModule = {
-  custom: (kind: string) => ({
+  custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => ({
     dialect: "postgres",
-    kind
+    kind: kind as Kind
   }),
   boolean: () => withMetadata("bool")
 } as Record<string, (...args: readonly any[]) => Expression.DbType.Base<"postgres", string>>

package/src/postgres/datatypes/spec.ts

@@ -1,264 +1,10 @@
-import type { DatatypeFamilySpec, DatatypeKindSpec } from "../../internal/datatypes/shape.js"
+import {
+  postgresDatatypeFamilies as matrixPostgresDatatypeFamilies,
+  postgresDatatypeKinds as matrixPostgresDatatypeKinds
+} from "../../internal/datatypes/matrix.js"
 
-export const postgresDatatypeFamilies = {
-  text: {
-    compareGroup: "text",
-    castTargets: [
-      "text",
-      "numeric",
-      "boolean",
-      "date",
-      "time",
-      "timestamp",
-      "interval",
-      "binary",
-      "uuid",
-      "json",
-      "xml",
-      "bit",
-      "oid",
-      "identifier",
-      "network",
-      "spatial",
-      "textsearch",
-      "range",
-      "multirange",
-      "array",
-      "money",
-      "null"
-    ],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  numeric: {
-    compareGroup: "numeric",
-    castTargets: ["numeric", "text", "boolean", "date", "time", "timestamp", "interval", "uuid", "bit", "oid", "money"],
-    traits: {
-      ordered: true
-    }
-  },
-  boolean: {
-    compareGroup: "boolean",
-    castTargets: ["boolean", "text", "numeric"],
-    traits: {}
-  },
-  date: {
-    compareGroup: "date",
-    castTargets: ["date", "timestamp", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  time: {
-    compareGroup: "time",
-    castTargets: ["time", "timestamp", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  timestamp: {
-    compareGroup: "timestamp",
-    castTargets: ["timestamp", "date", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  interval: {
-    compareGroup: "interval",
-    castTargets: ["interval", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  binary: {
-    compareGroup: "binary",
-    castTargets: ["binary", "text"],
-    traits: {}
-  },
-  uuid: {
-    compareGroup: "uuid",
-    castTargets: ["uuid", "text"],
-    traits: {
-      ordered: true
-    }
-  },
-  json: {
-    compareGroup: "json",
-    castTargets: ["json", "text"],
-    traits: {}
-  },
-  xml: {
-    compareGroup: "xml",
-    castTargets: ["xml", "text"],
-    traits: {}
-  },
-  bit: {
-    compareGroup: "bit",
-    castTargets: ["bit", "text", "numeric"],
-    traits: {}
-  },
-  oid: {
-    compareGroup: "oid",
-    castTargets: ["oid", "text", "numeric"],
-    traits: {
-      ordered: true
-    }
-  },
-  identifier: {
-    compareGroup: "identifier",
-    castTargets: ["identifier", "text"],
-    traits: {}
-  },
-  network: {
-    compareGroup: "network",
-    castTargets: ["network", "text"],
-    traits: {}
-  },
-  spatial: {
-    compareGroup: "spatial",
-    castTargets: ["spatial", "text"],
-    traits: {}
-  },
-  textsearch: {
-    compareGroup: "textsearch",
-    castTargets: ["textsearch", "text"],
-    traits: {}
-  },
-  range: {
-    compareGroup: "range",
-    castTargets: ["range", "text"],
-    traits: {}
-  },
-  multirange: {
-    compareGroup: "multirange",
-    castTargets: ["multirange", "text"],
-    traits: {}
-  },
-  enum: {
-    compareGroup: "enum",
-    castTargets: ["enum", "text"],
-    traits: {
-      textual: true,
-      ordered: true
-    }
-  },
-  record: {
-    compareGroup: "record",
-    castTargets: ["record", "text"],
-    traits: {}
-  },
-  array: {
-    compareGroup: "array",
-    castTargets: ["array", "text"],
-    traits: {}
-  },
-  money: {
-    compareGroup: "money",
-    castTargets: ["money", "text", "numeric"],
-    traits: {
-      ordered: true
-    }
-  },
-  null: {
-    compareGroup: "null",
-    castTargets: [
-      "text",
-      "numeric",
-      "boolean",
-      "date",
-      "time",
-      "timestamp",
-      "interval",
-      "binary",
-      "uuid",
-      "json",
-      "xml",
-      "bit",
-      "oid",
-      "identifier",
-      "network",
-      "spatial",
-      "textsearch",
-      "range",
-      "multirange",
-      "array",
-      "money",
-      "null"
-    ],
-    traits: {}
-  }
-} as const satisfies Record<string, DatatypeFamilySpec>
-
-export const postgresDatatypeKinds = {
-  text: { family: "text", runtime: "string" },
-  varchar: { family: "text", runtime: "string" },
-  char: { family: "text", runtime: "string" },
-  citext: { family: "text", runtime: "string" },
-  name: { family: "text", runtime: "string" },
-  uuid: { family: "uuid", runtime: "string" },
-  int2: { family: "numeric", runtime: "number" },
-  int4: { family: "numeric", runtime: "number" },
-  int8: { family: "numeric", runtime: "bigintString" },
-  numeric: { family: "numeric", runtime: "decimalString" },
-  float4: { family: "numeric", runtime: "number" },
-  float8: { family: "numeric", runtime: "number" },
-  money: { family: "money", runtime: "number" },
-  bool: { family: "boolean", runtime: "boolean" },
-  date: { family: "date", runtime: "localDate" },
-  time: { family: "time", runtime: "localTime" },
-  timetz: { family: "time", runtime: "offsetTime" },
-  timestamp: { family: "timestamp", runtime: "localDateTime" },
-  timestamptz: { family: "timestamp", runtime: "instant" },
-  interval: { family: "interval", runtime: "string" },
-  bytea: { family: "binary", runtime: "bytes" },
-  json: { family: "json", runtime: "json" },
-  jsonb: { family: "json", runtime: "json" },
-  xml: { family: "xml", runtime: "string" },
-  bit: { family: "bit", runtime: "string" },
-  varbit: { family: "bit", runtime: "string" },
-  oid: { family: "oid", runtime: "number" },
-  xid: { family: "oid", runtime: "number" },
-  xid8: { family: "oid", runtime: "bigintString" },
-  cid: { family: "oid", runtime: "number" },
-  tid: { family: "identifier", runtime: "string" },
-  regclass: { family: "identifier", runtime: "string" },
-  regtype: { family: "identifier", runtime: "string" },
-  regproc: { family: "identifier", runtime: "string" },
-  regprocedure: { family: "identifier", runtime: "string" },
-  regoper: { family: "identifier", runtime: "string" },
-  regoperator: { family: "identifier", runtime: "string" },
-  regconfig: { family: "identifier", runtime: "string" },
-  regdictionary: { family: "identifier", runtime: "string" },
-  pg_lsn: { family: "identifier", runtime: "string" },
-  txid_snapshot: { family: "identifier", runtime: "string" },
-  inet: { family: "network", runtime: "string" },
-  cidr: { family: "network", runtime: "string" },
-  macaddr: { family: "network", runtime: "string" },
-  macaddr8: { family: "network", runtime: "string" },
-  point: { family: "spatial", runtime: "unknown" },
-  line: { family: "spatial", runtime: "unknown" },
-  lseg: { family: "spatial", runtime: "unknown" },
-  box: { family: "spatial", runtime: "unknown" },
-  path: { family: "spatial", runtime: "unknown" },
-  polygon: { family: "spatial", runtime: "unknown" },
-  circle: { family: "spatial", runtime: "unknown" },
-  tsvector: { family: "textsearch", runtime: "string" },
-  tsquery: { family: "textsearch", runtime: "string" },
-  int4range: { family: "range", runtime: "unknown" },
-  int8range: { family: "range", runtime: "unknown" },
-  numrange: { family: "range", runtime: "unknown" },
-  tsrange: { family: "range", runtime: "unknown" },
-  tstzrange: { family: "range", runtime: "unknown" },
-  daterange: { family: "range", runtime: "unknown" },
-  int4multirange: { family: "multirange", runtime: "unknown" },
-  int8multirange: { family: "multirange", runtime: "unknown" },
-  nummultirange: { family: "multirange", runtime: "unknown" },
-  tsmultirange: { family: "multirange", runtime: "unknown" },
-  tstzmultirange: { family: "multirange", runtime: "unknown" },
-  datemultirange: { family: "multirange", runtime: "unknown" }
-} as const satisfies Record<string, DatatypeKindSpec>
+export const postgresDatatypeFamilies = matrixPostgresDatatypeFamilies
+export const postgresDatatypeKinds = matrixPostgresDatatypeKinds
 
 export type PostgresDatatypeFamily = keyof typeof postgresDatatypeFamilies
 export type PostgresDatatypeKind = keyof typeof postgresDatatypeKinds

package/src/postgres/errors/normalize.ts

@@ -29,7 +29,6 @@ const unwrapPostgresDriverCause = (cause: unknown): unknown => {
   while (
     isRecord(current) &&
     "_tag" in current &&
-    current._tag === "SqlError" &&
     "cause" in current
   ) {
     current = current.cause