effect-qb 0.12.3

package/src/postgres/errors/normalize.ts

@@ -0,0 +1,209 @@
+import type * as Renderer from "../../internal/renderer.js"
+import {
+  getPostgresErrorDescriptor,
+  isPostgresSqlStateCode,
+  postgresErrorClasses,
+  type PostgresErrorClassCode,
+  type PostgresErrorDescriptor,
+  type PostgresErrorTag,
+  type PostgresSqlStateCode
+} from "./catalog.js"
+import type {
+  PostgresErrorFields,
+  PostgresQueryContext
+} from "./fields.js"
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null
+
+const asString = (value: unknown): string | undefined =>
+  typeof value === "string" ? value : undefined
+
+const asNumber = (value: unknown): number | undefined => {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value
+  }
+  if (typeof value === "string" && value.trim() !== "") {
+    const parsed = Number(value)
+    return Number.isFinite(parsed) ? parsed : undefined
+  }
+  return undefined
+}
+
+const normalizeFields = (error: Record<string, unknown>): PostgresErrorFields => ({
+  severity: asString(error.severity),
+  severityNonLocalized: asString(error.severityNonLocalized),
+  detail: asString(error.detail),
+  hint: asString(error.hint),
+  position: asNumber(error.position),
+  internalPosition: asNumber(error.internalPosition),
+  internalQuery: asString(error.internalQuery),
+  where: asString(error.where),
+  schemaName: asString(error.schemaName) ?? asString(error.schema),
+  tableName: asString(error.tableName) ?? asString(error.table),
+  columnName: asString(error.columnName) ?? asString(error.column),
+  dataTypeName: asString(error.dataTypeName) ?? asString(error.dataType),
+  constraintName: asString(error.constraintName) ?? asString(error.constraint),
+  file: asString(error.file),
+  line: asNumber(error.line),
+  routine: asString(error.routine)
+})
+
+const sqlStatePattern = /^[0-9A-Z]{5}$/
+
+/** Raw Postgres-like error object as commonly exposed by client libraries. */
+export interface PostgresErrorLike {
+  readonly code?: string
+  readonly message?: string
+  readonly messagePrimary?: string
+  readonly schema?: string
+  readonly table?: string
+  readonly column?: string
+  readonly dataType?: string
+  readonly constraint?: string
+  readonly severity?: string
+  readonly severityNonLocalized?: string
+  readonly detail?: string
+  readonly hint?: string
+  readonly position?: string | number
+  readonly internalPosition?: string | number
+  readonly internalQuery?: string
+  readonly where?: string
+  readonly file?: string
+  readonly line?: string | number
+  readonly routine?: string
+}
+
+/** Structured known Postgres SQLSTATE error derived from the catalog. */
+export type KnownPostgresError<Code extends PostgresSqlStateCode = PostgresSqlStateCode> = {
+  readonly [Current in Code]: Readonly<{
+    readonly _tag: PostgresErrorTag<Current>
+    readonly code: Current
+    readonly condition: PostgresErrorDescriptor<Current>["condition"]
+    readonly classCode: PostgresErrorDescriptor<Current>["classCode"]
+    readonly className: PostgresErrorDescriptor<Current>["className"]
+    readonly message: string
+    readonly primaryFields: PostgresErrorDescriptor<Current>["primaryFields"]
+    readonly query?: PostgresQueryContext
+    readonly raw: PostgresErrorLike
+  } & PostgresErrorFields>
+}[Code]
+
+/** Extracts the known Postgres error variant for a specific SQLSTATE code. */
+export type KnownPostgresErrorByCode<Code extends PostgresSqlStateCode> = Extract<
+  KnownPostgresError,
+  { readonly code: Code }
+>
+
+/** Postgres-like error whose SQLSTATE is well-formed but not in the current catalog. */
+export type UnknownPostgresSqlStateError = Readonly<{
+  readonly _tag: "@postgres/unknown/sqlstate"
+  readonly code: string
+  readonly classCode: string
+  readonly className?: string
+  readonly message: string
+  readonly query?: PostgresQueryContext
+  readonly raw: PostgresErrorLike
+} & PostgresErrorFields>
+
+/** Fallback for non-Postgres driver failures in the Postgres executor path. */
+export type UnknownPostgresDriverError = Readonly<{
+  readonly _tag: "@postgres/unknown/driver"
+  readonly message: string
+  readonly query?: PostgresQueryContext
+  readonly cause: unknown
+}>
+
+/** Any Postgres-specific driver failure surfaced by the Postgres executor. */
+export type PostgresDriverError =
+  | KnownPostgresError
+  | UnknownPostgresSqlStateError
+  | UnknownPostgresDriverError
+
+/** Runtime guard for objects that look like Postgres driver errors. */
+export const isPostgresErrorLike = (value: unknown): value is PostgresErrorLike =>
+  isRecord(value) &&
+  (
+    (typeof value.code === "string" && sqlStatePattern.test(value.code)) ||
+    typeof value.severity === "string" ||
+    typeof value.message === "string" ||
+    typeof value.messagePrimary === "string"
+  )
+
+const errorMessageOf = (error: PostgresErrorLike): string =>
+  error.message ?? error.messagePrimary ?? "Postgres driver error"
+
+const makeKnownPostgresError = <Code extends PostgresSqlStateCode>(
+  code: Code,
+  raw: PostgresErrorLike,
+  query?: PostgresQueryContext
+): KnownPostgresError<Code> => {
+  const descriptor = getPostgresErrorDescriptor(code)
+  return {
+    _tag: descriptor.tag,
+    code,
+    condition: descriptor.condition,
+    classCode: descriptor.classCode,
+    className: descriptor.className,
+    message: errorMessageOf(raw),
+    primaryFields: descriptor.primaryFields,
+    query,
+    raw,
+    ...normalizeFields(raw as Record<string, unknown>)
+  } as KnownPostgresError<Code>
+}
+
+/** Normalizes an unknown failure into a structured Postgres driver error. */
+export const normalizePostgresDriverError = (
+  cause: unknown,
+  query?: PostgresQueryContext | Renderer.RenderedQuery<any, "postgres">
+): PostgresDriverError => {
+  const context = query === undefined
+    ? undefined
+    : "sql" in query
+      ? { sql: query.sql, params: query.params }
+      : query
+
+  if (!isPostgresErrorLike(cause)) {
+    return {
+      _tag: "@postgres/unknown/driver",
+      message: cause instanceof Error ? cause.message : "Unknown Postgres driver failure",
+      query: context,
+      cause
+    } as UnknownPostgresDriverError
+  }
+
+  if (cause.code && isPostgresSqlStateCode(cause.code)) {
+    return makeKnownPostgresError(cause.code, cause, context)
+  }
+
+  if (typeof cause.code === "string" && sqlStatePattern.test(cause.code)) {
+    const classCode = cause.code.slice(0, 2)
+    return {
+      _tag: "@postgres/unknown/sqlstate",
+      code: cause.code,
+      classCode,
+      className: classCode in postgresErrorClasses
+        ? postgresErrorClasses[classCode as PostgresErrorClassCode]
+        : undefined,
+      message: errorMessageOf(cause),
+      query: context,
+      raw: cause,
+      ...normalizeFields(cause as Record<string, unknown>)
+    } as UnknownPostgresSqlStateError
+  }
+
+  return {
+    _tag: "@postgres/unknown/driver",
+    message: errorMessageOf(cause),
+    query: context,
+    cause
+  } as UnknownPostgresDriverError
+}
+
+/** Type guard for a specific SQLSTATE code. */
+export const hasSqlState = <Code extends PostgresSqlStateCode>(
+  error: PostgresDriverError | { readonly code?: string },
+  code: Code
+): error is KnownPostgresErrorByCode<Code> =>
+  "code" in error && error.code === code

package/src/postgres/errors/requirements.ts

@@ -0,0 +1,65 @@
+import { read_query_capabilities, type QueryCapability, type QueryRequirement } from "../../internal/query-requirements.js"
+import type { PostgresErrorClassCode } from "./catalog.js"
+import type { PostgresQueryContext } from "./fields.js"
+import type {
+  KnownPostgresError,
+  PostgresDriverError,
+  UnknownPostgresDriverError,
+  UnknownPostgresSqlStateError
+} from "./normalize.js"
+
+type WriteRequiredPostgresClassCode = "23" | "27" | "44"
+export type PostgresQueryRequirement = Extract<QueryRequirement, "write" | "ddl" | "transaction" | "locking">
+
+export const postgres_requirements_by_class_code = {
+  "23": ["write"],
+  "27": ["write"],
+  "44": ["write"]
+} as const satisfies Partial<Record<PostgresErrorClassCode, readonly PostgresQueryRequirement[]>>
+
+export type PostgresQueryRequirementsError = Readonly<{
+  readonly _tag: "@postgres/unknown/query-requirements"
+  readonly message: string
+  readonly query?: PostgresQueryContext
+  readonly requiredCapabilities: readonly PostgresQueryRequirement[]
+  readonly actualCapabilities: readonly QueryCapability[]
+  readonly cause: PostgresDriverError
+}>
+
+export type PostgresReadQueryError =
+  | Exclude<KnownPostgresError, { readonly classCode: keyof typeof postgres_requirements_by_class_code & WriteRequiredPostgresClassCode }>
+  | UnknownPostgresSqlStateError
+  | UnknownPostgresDriverError
+  | PostgresQueryRequirementsError
+
+const lookup_postgres_requirements = (
+  classCode: string
+): readonly PostgresQueryRequirement[] =>
+  classCode in postgres_requirements_by_class_code
+    ? postgres_requirements_by_class_code[classCode as keyof typeof postgres_requirements_by_class_code]
+    : []
+
+export const requirements_of_postgres_error = (
+  error: PostgresDriverError
+): readonly PostgresQueryRequirement[] =>
+  "classCode" in error
+    ? lookup_postgres_requirements(error.classCode)
+    : []
+
+export const narrowPostgresDriverErrorForReadQuery = (
+  error: PostgresDriverError
+): PostgresReadQueryError => {
+  const requiredCapabilities = requirements_of_postgres_error(error)
+  if (requiredCapabilities.length === 0) {
+    return error as PostgresReadQueryError
+  }
+
+  return {
+    _tag: "@postgres/unknown/query-requirements",
+    message: "Postgres driver error requires query capabilities not provided by this plan",
+    query: error.query,
+    requiredCapabilities,
+    actualCapabilities: read_query_capabilities,
+    cause: error
+  } satisfies PostgresQueryRequirementsError
+}

package/src/postgres/errors/types.ts

@@ -0,0 +1,38 @@
+/** Structured Postgres error-report fields commonly exposed by drivers. */
+export type PostgresErrorSemanticField =
+  | "schema"
+  | "table"
+  | "column"
+  | "constraint"
+  | "dataType"
+  | "position"
+  | "internalPosition"
+  | "internalQuery"
+  | "file"
+  | "line"
+  | "routine"
+
+/** Class-level metadata for a family of SQLSTATE errors. */
+export interface PostgresSqlStateClassMetadata<
+  ClassCode extends string = string,
+  ClassName extends string = string
+> {
+  readonly classCode: ClassCode
+  readonly className: ClassName
+  readonly tag: string
+}
+
+/** Metadata for a single Postgres SQLSTATE condition. */
+export interface PostgresSqlStateMetadata<
+  Code extends string = string,
+  Condition extends string = string,
+  ClassCode extends string = string,
+  ClassName extends string = string
+> {
+  readonly code: Code
+  readonly condition: Condition
+  readonly classCode: ClassCode
+  readonly className: ClassName
+  readonly tag: string
+  readonly semanticFields: readonly PostgresErrorSemanticField[]
+}

package/src/postgres/executor.ts

@@ -0,0 +1,131 @@
+import * as Effect from "effect/Effect"
+import * as SqlClient from "@effect/sql/SqlClient"
+
+import * as CoreExecutor from "../internal/executor.js"
+import * as Query from "./query.js"
+import * as Renderer from "./renderer.js"
+import {
+  narrowPostgresDriverErrorForReadQuery,
+  normalizePostgresDriverError,
+  type PostgresDriverError,
+  type PostgresReadQueryError
+} from "./errors/index.js"
+
+/** Postgres-specialized flat row returned by SQL drivers. */
+export type FlatRow = CoreExecutor.FlatRow
+/** Runtime decode failure raised after SQL execution but before row remapping. */
+export type RowDecodeError = CoreExecutor.RowDecodeError
+/** Postgres-specialized rendered-query driver. */
+export type Driver<Error = never, Context = never> = CoreExecutor.Driver<"postgres", Error, Context>
+/** Postgres-specialized executor contract. */
+export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"postgres", Error, Context>
+/** Optional renderer / driver overrides for the standard Postgres executor pipeline. */
+export interface MakeOptions<Error = never, Context = never> {
+  readonly renderer?: Renderer.Renderer
+  readonly driver?: Driver<Error, Context>
+  readonly driverMode?: CoreExecutor.DriverMode
+}
+/** Standard composed error shape for Postgres executors. */
+export type PostgresExecutorError = PostgresDriverError | RowDecodeError
+/** Read-query error surface emitted by built-in Postgres executors. */
+export type PostgresQueryError<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>> =
+  Exclude<Query.CapabilitiesOfPlan<PlanValue>, "read"> extends never ? PostgresReadQueryError : PostgresExecutorError
+
+/** Runs an effect within the ambient Postgres SQL transaction service. */
+export const withTransaction = CoreExecutor.withTransaction
+/** Runs an effect in a nested Postgres SQL transaction scope. */
+export const withSavepoint = CoreExecutor.withSavepoint
+
+/** Postgres executor whose error channel narrows based on the query plan. */
+export interface QueryExecutor<Context = never> {
+  readonly dialect: "postgres"
+  execute<PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: Query.DialectCompatiblePlan<PlanValue, "postgres">
+  ): Effect.Effect<Query.ResultRows<PlanValue>, PostgresQueryError<PlanValue>, Context>
+}
+
+/** Constructs a Postgres-specialized SQL driver. */
+export function driver(execute: any): Driver<any, any>
+export function driver(dialect: "postgres", execute: any): Driver<any, any>
+export function driver(dialectOrExecute: "postgres" | any, maybeExecute?: any): Driver<any, any> {
+  const execute = typeof dialectOrExecute === "string" ? maybeExecute : dialectOrExecute
+  return CoreExecutor.driver("postgres", execute as any)
+}
+
+const fromDriver = <
+  Error = never,
+  Context = never
+>(
+  renderer: Renderer.Renderer,
+  sqlDriver: Driver<Error, Context>,
+  driverMode: CoreExecutor.DriverMode = "raw"
+): QueryExecutor<Context> => ({
+  dialect: "postgres",
+  execute(plan) {
+    const rendered = renderer.render(plan)
+    return Effect.mapError(
+      Effect.flatMap(
+        sqlDriver.execute(rendered),
+        (rows) => Effect.try({
+          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode }),
+          catch: (error) => error as RowDecodeError
+        })
+      ),
+      (error) => {
+        if (typeof error === "object" && error !== null && "_tag" in error && error._tag === "RowDecodeError") {
+          return error as RowDecodeError
+        }
+        const normalized = normalizePostgresDriverError(error, rendered)
+        return CoreExecutor.hasWriteCapability(plan)
+          ? normalized
+          : narrowPostgresDriverErrorForReadQuery(normalized)
+      }
+    ) as Effect.Effect<any, any, Context>
+  }
+})
+
+const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
+  driver((query: Renderer.RenderedQuery<any>) =>
+    Effect.flatMap(SqlClient.SqlClient, (sql) =>
+      sql.unsafe<FlatRow>(query.sql, [...query.params])))
+
+/**
+ * Creates the standard Postgres executor pipeline.
+ *
+ * By default this uses the built-in Postgres renderer plus the ambient
+ * `@effect/sql` `SqlClient`. Advanced callers can override the renderer,
+ * driver, or both.
+ */
+export function make(): QueryExecutor<SqlClient.SqlClient>
+export function make(
+  options: {
+    readonly renderer?: Renderer.Renderer
+    readonly driverMode?: CoreExecutor.DriverMode
+  }
+): QueryExecutor<SqlClient.SqlClient>
+export function make<Error = never, Context = never>(
+  options: {
+    readonly renderer?: Renderer.Renderer
+    readonly driver: Driver<Error, Context>
+    readonly driverMode?: CoreExecutor.DriverMode
+  }
+): QueryExecutor<Context>
+export function make<Error = never, Context = never>(
+  options: MakeOptions<Error, Context> = {}
+): QueryExecutor<any> {
+  if (options.driver) {
+    return fromDriver(options.renderer ?? Renderer.make(), options.driver, options.driverMode)
+  }
+  return fromDriver(options.renderer ?? Renderer.make(), sqlClientDriver(), options.driverMode)
+}
+
+/** Creates a Postgres-specialized executor from a typed implementation callback. */
+export const custom = <
+  Error = never,
+  Context = never
+>(
+  execute: <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: Query.DialectCompatiblePlan<PlanValue, "postgres">
+  ) => Effect.Effect<Query.ResultRows<PlanValue>, Error, Context>
+): Executor<Error, Context> =>
+  CoreExecutor.make("postgres", execute as any) as Executor<Error, Context>

package/src/postgres/query.ts

@@ -0,0 +1,189 @@
+import * as Expression from "../internal/expression.js"
+import { postgresDatatypes } from "./datatypes/index.js"
+import {
+  type CapabilitiesOfPlan,
+  type CompletePlan,
+  type DialectCompatiblePlan,
+  type DerivedSourceRequiredError,
+  type CteSource,
+  type EffectiveNullability,
+  type ExpressionInput,
+  type ExpressionOutput,
+  type GroupByInput,
+  type MergeCapabilities,
+  type MergeCapabilityTuple,
+  type HavingPredicateInput,
+  type OrderDirection,
+  type OutputOfSelection,
+  type MutationInputOf,
+  type MutationTargetLike,
+  type NumericExpressionInput,
+  type PredicateInput,
+  type QueryCapability,
+  type QueryPlan,
+  type QueryRequirement,
+  type SetCompatiblePlan,
+  type SetCompatibleRightPlan,
+  type SetOperator,
+  type QueryStatement,
+  type ResultRow,
+  type ResultRows,
+  type RuntimeResultRow,
+  type RuntimeResultRows,
+  type SchemaTableLike,
+  type SourceCapabilitiesOf,
+  type SourceRequiredOf,
+  type SourceRequirementError,
+  type StatementOfPlan,
+  type StringExpressionInput
+} from "../internal/query.js"
+import { makeDialectQuery } from "../internal/query-factory.js"
+
+const postgresQuery = makeDialectQuery({
+  dialect: "postgres",
+  textDb: { dialect: "postgres", kind: "text" } as Expression.DbType.PgText,
+  numericDb: { dialect: "postgres", kind: "float8" } as Expression.DbType.PgFloat8,
+  boolDb: { dialect: "postgres", kind: "bool" } as Expression.DbType.PgBool,
+  timestampDb: { dialect: "postgres", kind: "timestamp" } as Expression.DbType.PgTimestamp,
+  nullDb: { dialect: "postgres", kind: "null" } as Expression.DbType.Base<"postgres", "null">,
+  type: postgresDatatypes
+})
+
+export const literal = postgresQuery.literal
+export const cast = postgresQuery.cast
+export const type = postgresQuery.type
+export const json = postgresQuery.json
+export const eq = postgresQuery.eq
+export const neq = postgresQuery.neq
+export const lt = postgresQuery.lt
+export const lte = postgresQuery.lte
+export const gt = postgresQuery.gt
+export const gte = postgresQuery.gte
+export const isNull = postgresQuery.isNull
+export const isNotNull = postgresQuery.isNotNull
+export const upper = postgresQuery.upper
+export const lower = postgresQuery.lower
+export const like = postgresQuery.like
+export const ilike = postgresQuery.ilike
+export const and = postgresQuery.and
+export const or = postgresQuery.or
+export const not = postgresQuery.not
+export const all = postgresQuery.all
+export const any = postgresQuery.any
+const case_ = postgresQuery.case
+export const match = postgresQuery.match
+export const coalesce = postgresQuery.coalesce
+export const in_ = postgresQuery.in
+export const notIn = postgresQuery.notIn
+export const between = postgresQuery.between
+export const contains = postgresQuery.contains
+export const containedBy = postgresQuery.containedBy
+export const overlaps = postgresQuery.overlaps
+export const concat = postgresQuery.concat
+export const exists = postgresQuery.exists
+export const over = postgresQuery.over
+export const rowNumber = postgresQuery.rowNumber
+export const rank = postgresQuery.rank
+export const denseRank = postgresQuery.denseRank
+export const count = postgresQuery.count
+export const max = postgresQuery.max
+export const min = postgresQuery.min
+export const isDistinctFrom = postgresQuery.isDistinctFrom
+export const isNotDistinctFrom = postgresQuery.isNotDistinctFrom
+export const excluded = postgresQuery.excluded
+export const as = postgresQuery.as
+export const with_ = postgresQuery.with
+export const withRecursive = postgresQuery.withRecursive
+export const lateral = postgresQuery.lateral
+export const scalar = postgresQuery.scalar
+export const inSubquery = postgresQuery.inSubquery
+export const compareAny = postgresQuery.compareAny
+export const compareAll = postgresQuery.compareAll
+export const values = postgresQuery.values
+export const unnest = postgresQuery.unnest
+export const generateSeries = postgresQuery.generateSeries
+export const returning = postgresQuery.returning
+export const defaultValues = postgresQuery.defaultValues
+export const onConflict = postgresQuery.onConflict
+export const insert = postgresQuery.insert
+export const update = postgresQuery.update
+export const upsert = postgresQuery.upsert
+export const delete_ = postgresQuery.delete
+export const truncate = postgresQuery.truncate
+export const merge = postgresQuery.merge
+export const transaction = postgresQuery.transaction
+export const commit = postgresQuery.commit
+export const rollback = postgresQuery.rollback
+export const savepoint = postgresQuery.savepoint
+export const rollbackTo = postgresQuery.rollbackTo
+export const releaseSavepoint = postgresQuery.releaseSavepoint
+export const createTable = postgresQuery.createTable
+export const dropTable = postgresQuery.dropTable
+export const createIndex = postgresQuery.createIndex
+export const dropIndex = postgresQuery.dropIndex
+export const union = postgresQuery.union
+export const unionAll = postgresQuery.unionAll
+export const intersect = postgresQuery.intersect
+export const intersectAll = postgresQuery.intersectAll
+export const except = postgresQuery.except
+export const exceptAll = postgresQuery.exceptAll
+export const select = postgresQuery.select
+export const where = postgresQuery.where
+export const having = postgresQuery.having
+export const from = postgresQuery.from
+export const innerJoin = postgresQuery.innerJoin
+export const leftJoin = postgresQuery.leftJoin
+export const rightJoin = postgresQuery.rightJoin
+export const fullJoin = postgresQuery.fullJoin
+export const crossJoin = postgresQuery.crossJoin
+export const distinct = postgresQuery.distinct
+export const distinctOn = postgresQuery.distinctOn
+export const limit = postgresQuery.limit
+export const offset = postgresQuery.offset
+export const lock = postgresQuery.lock
+export const orderBy = postgresQuery.orderBy
+export const groupBy = postgresQuery.groupBy
+export { case_ as case }
+export { in_ as in }
+export { with_ as with }
+export { delete_ as delete }
+
+export type {
+  CapabilitiesOfPlan,
+  CompletePlan,
+  DialectCompatiblePlan,
+  DerivedSourceRequiredError,
+  CteSource,
+  EffectiveNullability,
+  ExpressionInput,
+  ExpressionOutput,
+  GroupByInput,
+  MergeCapabilities,
+  MergeCapabilityTuple,
+  HavingPredicateInput,
+  OrderDirection,
+  OutputOfSelection,
+  MutationInputOf,
+  MutationTargetLike,
+  NumericExpressionInput,
+  PredicateInput,
+  QueryCapability,
+  QueryPlan,
+  QueryStatement,
+  QueryRequirement,
+  SetCompatiblePlan,
+  SetCompatibleRightPlan,
+  SetOperator,
+  ResultRow,
+  ResultRows,
+  RuntimeResultRow,
+  RuntimeResultRows,
+  SchemaTableLike,
+  SourceCapabilitiesOf,
+  SourceRequiredOf,
+  SourceRequirementError,
+  StatementOfPlan,
+  StringExpressionInput
+}
+
+export { union_query_capabilities } from "../internal/query.js"

package/src/postgres/renderer.ts

@@ -0,0 +1,29 @@
+import * as CoreRenderer from "../internal/renderer.js"
+
+/** Postgres-specialized rendered query shape. */
+export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "postgres">
+/** Extracts the row type carried by a Postgres rendered query. */
+export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
+/** Postgres-specialized renderer contract. */
+export type Renderer = CoreRenderer.Renderer<"postgres">
+
+export { TypeId } from "../internal/renderer.js"
+export type { Projection } from "../internal/renderer.js"
+
+/** Creates the built-in Postgres renderer. */
+export function make(): Renderer
+export function make(dialect: "postgres"): Renderer
+export function make(
+  dialect: "postgres",
+  render: Parameters<typeof CoreRenderer.make>[1]
+): Renderer
+export function make(
+  dialectOrRender?: "postgres" | Parameters<typeof CoreRenderer.make>[1],
+  render?: Parameters<typeof CoreRenderer.make>[1]
+): Renderer {
+  const customRender = typeof dialectOrRender === "function" ? dialectOrRender : render
+  return customRender ? CoreRenderer.make("postgres", customRender as any) : CoreRenderer.make("postgres")
+}
+
+/** Shared built-in Postgres renderer instance. */
+export const postgres = make()