effect-qb 0.13.0 → 0.15.0

package/src/postgres/errors/index.ts

@@ -2,3 +2,4 @@ export * from "./catalog.js"
 export * from "./fields.js"
 export * from "./normalize.js"
 export * from "./requirements.js"
+export * from "./types.js"

package/src/postgres/errors/normalize.ts

@@ -8,14 +8,35 @@ import {
   type PostgresErrorTag,
   type PostgresSqlStateCode
 } from "./catalog.js"
+import {
+  postgresKnownErrorClassesByCode,
+  type KnownPostgresErrorByCode as ExactKnownPostgresErrorByCode
+} from "./generated.js"
 import type {
   PostgresErrorFields,
   PostgresQueryContext
 } from "./fields.js"
+import type {
+  PostgresErrorLike,
+  PostgresKnownErrorBase
+} from "./types.js"
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null
 
+const unwrapPostgresDriverCause = (cause: unknown): unknown => {
+  let current = cause
+  while (
+    isRecord(current) &&
+    "_tag" in current &&
+    current._tag === "SqlError" &&
+    "cause" in current
+  ) {
+    current = current.cause
+  }
+  return current
+}
+
 const asString = (value: unknown): string | undefined =>
   typeof value === "string" ? value : undefined
 
@@ -51,49 +72,14 @@ const normalizeFields = (error: Record<string, unknown>): PostgresErrorFields =>
 
 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
-}
+export type { PostgresErrorLike } from "./types.js"
 
 /** 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]
+export type KnownPostgresError<Code extends PostgresSqlStateCode = PostgresSqlStateCode> =
+  ExactKnownPostgresErrorByCode<Code>
 
 /** Extracts the known Postgres error variant for a specific SQLSTATE code. */
-export type KnownPostgresErrorByCode<Code extends PostgresSqlStateCode> = Extract<
-  KnownPostgresError,
-  { readonly code: Code }
->
+export type KnownPostgresErrorByCode<Code extends PostgresSqlStateCode> = ExactKnownPostgresErrorByCode<Code>
 
 /** Postgres-like error whose SQLSTATE is well-formed but not in the current catalog. */
 export type UnknownPostgresSqlStateError = Readonly<{
@@ -133,24 +119,19 @@ export const isPostgresErrorLike = (value: unknown): value is PostgresErrorLike
 const errorMessageOf = (error: PostgresErrorLike): string =>
   error.message ?? error.messagePrimary ?? "Postgres driver error"
 
-const makeKnownPostgresError = <Code extends PostgresSqlStateCode>(
-  code: Code,
+const makeKnownPostgresError = (
+  code: PostgresSqlStateCode,
   raw: PostgresErrorLike,
   query?: PostgresQueryContext
-): KnownPostgresError<Code> => {
+): KnownPostgresError => {
   const descriptor = getPostgresErrorDescriptor(code)
-  return {
-    _tag: descriptor.tag,
-    code,
-    condition: descriptor.condition,
-    classCode: descriptor.classCode,
-    className: descriptor.className,
+  const ErrorClass = postgresKnownErrorClassesByCode[code]
+  return new ErrorClass({
     message: errorMessageOf(raw),
-    primaryFields: descriptor.primaryFields,
     query,
     raw,
     ...normalizeFields(raw as Record<string, unknown>)
-  } as KnownPostgresError<Code>
+  }) as KnownPostgresError
 }
 
 /** Normalizes an unknown failure into a structured Postgres driver error. */
@@ -158,44 +139,45 @@ export const normalizePostgresDriverError = (
   cause: unknown,
   query?: PostgresQueryContext | Renderer.RenderedQuery<any, "postgres">
 ): PostgresDriverError => {
+  const normalizedCause = unwrapPostgresDriverCause(cause)
   const context = query === undefined
     ? undefined
     : "sql" in query
       ? { sql: query.sql, params: query.params }
       : query
 
-  if (!isPostgresErrorLike(cause)) {
+  if (!isPostgresErrorLike(normalizedCause)) {
     return {
       _tag: "@postgres/unknown/driver",
-      message: cause instanceof Error ? cause.message : "Unknown Postgres driver failure",
+      message: normalizedCause instanceof Error ? normalizedCause.message : "Unknown Postgres driver failure",
       query: context,
       cause
     } as UnknownPostgresDriverError
   }
 
-  if (cause.code && isPostgresSqlStateCode(cause.code)) {
-    return makeKnownPostgresError(cause.code, cause, context)
+  if (normalizedCause.code && isPostgresSqlStateCode(normalizedCause.code)) {
+    return makeKnownPostgresError(normalizedCause.code, normalizedCause, context)
   }
 
-  if (typeof cause.code === "string" && sqlStatePattern.test(cause.code)) {
-    const classCode = cause.code.slice(0, 2)
+  if (typeof normalizedCause.code === "string" && sqlStatePattern.test(normalizedCause.code)) {
+    const classCode = normalizedCause.code.slice(0, 2)
     return {
       _tag: "@postgres/unknown/sqlstate",
-      code: cause.code,
+      code: normalizedCause.code,
       classCode,
       className: classCode in postgresErrorClasses
         ? postgresErrorClasses[classCode as PostgresErrorClassCode]
         : undefined,
-      message: errorMessageOf(cause),
+      message: errorMessageOf(normalizedCause),
       query: context,
-      raw: cause,
-      ...normalizeFields(cause as Record<string, unknown>)
+      raw: normalizedCause,
+      ...normalizeFields(normalizedCause as Record<string, unknown>)
     } as UnknownPostgresSqlStateError
   }
 
   return {
     _tag: "@postgres/unknown/driver",
-    message: errorMessageOf(cause),
+    message: errorMessageOf(normalizedCause),
     query: context,
     cause
   } as UnknownPostgresDriverError
@@ -206,4 +188,7 @@ export const hasSqlState = <Code extends PostgresSqlStateCode>(
   error: PostgresDriverError | { readonly code?: string },
   code: Code
 ): error is KnownPostgresErrorByCode<Code> =>
-  "code" in error && error.code === code
+  (typeof error === "object" &&
+    error !== null &&
+    error instanceof postgresKnownErrorClassesByCode[code]) ||
+  ("code" in error && error.code === code)

package/src/postgres/errors/types.ts

@@ -1,38 +1,96 @@
-/** Structured Postgres error-report fields commonly exposed by drivers. */
-export type PostgresErrorSemanticField =
-  | "schema"
-  | "table"
-  | "column"
-  | "constraint"
-  | "dataType"
-  | "position"
-  | "internalPosition"
-  | "internalQuery"
-  | "file"
-  | "line"
-  | "routine"
+import type { PostgresErrorTag, PostgresSqlStateCode } from "./catalog.js"
+import type { PostgresErrorFields, PostgresQueryContext } from "./fields.js"
 
-/** 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
+/** 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
 }
 
-/** 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[]
+/** Broad known-Postgres error surface used by the normalizer return type. */
+export interface PostgresKnownErrorBase extends Error, PostgresErrorFields {
+  readonly _tag: PostgresErrorTag<PostgresSqlStateCode>
+  readonly code: PostgresSqlStateCode
+  readonly condition: string
+  readonly classCode: string
+  readonly className: string
+  readonly message: string
+  readonly primaryFields: readonly string[]
+  readonly query?: PostgresQueryContext
+  readonly raw: PostgresErrorLike
+}
+
+/** Shared constructor payload for generated Postgres error classes. */
+export type PostgresKnownErrorArgs = Readonly<{
+  readonly message: string
+  readonly query?: PostgresQueryContext
+  readonly raw: PostgresErrorLike
+} & PostgresErrorFields>
+
+/** Runtime base class shared by generated Postgres error classes. */
+export abstract class PostgresKnownErrorClass extends Error implements PostgresKnownErrorBase {
+  abstract readonly _tag: PostgresErrorTag<PostgresSqlStateCode>
+  abstract readonly code: PostgresSqlStateCode
+  abstract readonly condition: string
+  abstract readonly classCode: string
+  abstract readonly className: string
+  abstract readonly primaryFields: readonly string[]
+  readonly severity?
+  readonly severityNonLocalized?
+  readonly detail?
+  readonly hint?
+  readonly position?
+  readonly internalPosition?
+  readonly internalQuery?
+  readonly where?
+  readonly schemaName?
+  readonly tableName?
+  readonly columnName?
+  readonly dataTypeName?
+  readonly constraintName?
+  readonly file?
+  readonly line?
+  readonly routine?
+  readonly query?
+  readonly raw
+
+  constructor(args: PostgresKnownErrorArgs) {
+    super(args.message)
+    this.name = new.target.name
+    this.severity = args.severity
+    this.severityNonLocalized = args.severityNonLocalized
+    this.detail = args.detail
+    this.hint = args.hint
+    this.position = args.position
+    this.internalPosition = args.internalPosition
+    this.internalQuery = args.internalQuery
+    this.where = args.where
+    this.schemaName = args.schemaName
+    this.tableName = args.tableName
+    this.columnName = args.columnName
+    this.dataTypeName = args.dataTypeName
+    this.constraintName = args.constraintName
+    this.file = args.file
+    this.line = args.line
+    this.routine = args.routine
+    this.query = args.query
+    this.raw = args.raw
+  }
 }

package/src/postgres/executor.ts

@@ -1,9 +1,11 @@
 import * as Effect from "effect/Effect"
 import * as SqlClient from "@effect/sql/SqlClient"
+import * as Stream from "effect/Stream"
 
 import * as CoreExecutor from "../internal/executor.js"
 import * as CoreQuery from "../internal/query.js"
 import * as CoreRenderer from "../internal/renderer.js"
+import { renderPostgresPlan } from "./internal/renderer.js"
 import {
   narrowPostgresDriverErrorForReadQuery,
   normalizePostgresDriverError,
@@ -44,6 +46,11 @@ export interface QueryExecutor<Context = never> {
   execute<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     plan: CoreQuery.DialectCompatiblePlan<PlanValue, "postgres">
   ): Effect.Effect<CoreQuery.ResultRows<PlanValue>, PostgresQueryError<PlanValue>, Context>
+  stream<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
+    plan: Exclude<CoreQuery.CapabilitiesOfPlan<PlanValue>, "read" | "locking"> extends never
+      ? CoreQuery.DialectCompatiblePlan<PlanValue, "postgres">
+      : never
+  ): Stream.Stream<CoreQuery.ResultRow<PlanValue>, PostgresQueryError<PlanValue>, Context>
 }
 
 /** Constructs a Postgres-specialized SQL driver. */
@@ -83,13 +90,38 @@ const fromDriver = <
           : narrowPostgresDriverErrorForReadQuery(normalized)
       }
     ) as Effect.Effect<any, any, Context>
+  },
+  stream(plan) {
+    const rendered = renderer.render(plan)
+    return Stream.mapError(
+      Stream.mapChunksEffect(
+        sqlDriver.stream(rendered),
+        (rows) => Effect.try({
+          try: () => CoreExecutor.decodeChunk(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 Stream.Stream<any, any, Context>
   }
 })
 
 const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
-  driver((query: CoreRenderer.RenderedQuery<any, "postgres">) =>
-    Effect.flatMap(SqlClient.SqlClient, (sql) =>
-      sql.unsafe<FlatRow>(query.sql, [...query.params])))
+  driver({
+    execute: (query: CoreRenderer.RenderedQuery<any, "postgres">) =>
+      Effect.flatMap(SqlClient.SqlClient, (sql) =>
+        sql.unsafe<FlatRow>(query.sql, [...query.params])),
+    stream: (query: CoreRenderer.RenderedQuery<any, "postgres">) =>
+      CoreExecutor.streamFromSqlClient(query)
+  })
 
 /**
  * Creates the standard Postgres executor pipeline.
@@ -116,9 +148,9 @@ export function make<Error = never, Context = never>(
   options: MakeOptions<Error, Context> = {}
 ): QueryExecutor<any> {
   if (options.driver) {
-    return fromDriver(options.renderer ?? CoreRenderer.make("postgres"), options.driver, options.driverMode)
+    return fromDriver(options.renderer ?? CoreRenderer.make("postgres", renderPostgresPlan), options.driver, options.driverMode)
   }
-  return fromDriver(options.renderer ?? CoreRenderer.make("postgres"), sqlClientDriver(), options.driverMode)
+  return fromDriver(options.renderer ?? CoreRenderer.make("postgres", renderPostgresPlan), sqlClientDriver(), options.driverMode)
 }
 
 /** Creates a Postgres-specialized executor from a typed implementation callback. */

package/src/postgres/function/aggregate.ts

@@ -1,6 +1,2 @@
-import { postgresQuery } from "../private/query.js"
-
 /** Postgres aggregate functions. */
-export const count = postgresQuery.count
-export const max = postgresQuery.max
-export const min = postgresQuery.min
+export { count, max, min } from "../internal/dsl.js"

package/src/postgres/function/core.ts

@@ -1,4 +1,22 @@
-import { postgresQuery } from "../private/query.js"
+import type { ExpressionInput } from "../query.js"
+import {
+  call,
+  cast,
+  coalesce,
+  literal,
+  nextVal as nextValInternal,
+  type as postgresType,
+  uuidGenerateV4
+} from "../internal/dsl.js"
+import { isSequenceDefinition, type SequenceDefinition } from "../schema-management.js"
 
 /** Postgres scalar core functions. */
-export const coalesce = postgresQuery.coalesce
+export { coalesce, call, uuidGenerateV4 }
+export const nextVal = (
+  value: ExpressionInput | SequenceDefinition<string, string | undefined>
+) =>
+  nextValInternal(
+    isSequenceDefinition(value)
+      ? cast(literal(value.qualifiedName()), postgresType.regclass())
+      : value
+  )

package/src/postgres/function/index.ts

@@ -2,10 +2,10 @@ export * as core from "./core.js"
 export * as string from "./string.js"
 export * as aggregate from "./aggregate.js"
 export * as window from "./window.js"
-export { json } from "./json.js"
 export * as temporal from "./temporal.js"
 
 export { coalesce } from "./core.js"
+export { call, uuidGenerateV4, nextVal } from "./core.js"
 export { lower, upper, concat } from "./string.js"
 export { count, max, min } from "./aggregate.js"
 export { over, rowNumber, rank, denseRank } from "./window.js"

package/src/postgres/function/string.ts

@@ -1,6 +1,2 @@
-import { postgresQuery } from "../private/query.js"
-
 /** Postgres string functions. */
-export const lower = postgresQuery.lower
-export const upper = postgresQuery.upper
-export const concat = postgresQuery.concat
+export { lower, upper, concat } from "../internal/dsl.js"

package/src/postgres/function/temporal.ts

@@ -1,8 +1,9 @@
 import type * as Schema from "effect/Schema"
 
-import type * as Expression from "../../internal/expression.js"
+import type * as Expression from "../../internal/scalar.js"
 import type * as ExpressionAst from "../../internal/expression-ast.js"
 import { makeExpression } from "../../internal/query.js"
+import { postgresDatatypes } from "../datatypes/index.js"
 import {
   InstantStringSchema,
   LocalDateStringSchema,
@@ -14,21 +15,19 @@ import {
   type LocalDateTimeString,
   type LocalTimeString,
   type OffsetTimeString
-} from "../../internal/runtime-value.js"
+} from "../../internal/runtime/value.js"
 
 type TemporalExpression<
   Runtime,
   Db extends Expression.DbType.Any,
   Name extends string
-> = Expression.Expression<
+> = Expression.Scalar<
   Runtime,
   Db,
   "never",
   "postgres",
   "scalar",
-  never,
-  {},
-  "resolved"
+  never
 > & {
   readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<Name, readonly []>
 }
@@ -48,10 +47,8 @@ const makeTemporal = <
     runtimeSchema,
     nullability: "never",
     dialect: "postgres",
-    aggregation: "scalar",
-    source: undefined as never,
+    kind: "scalar",
     dependencies: {},
-    sourceNullability: "resolved"
   }, {
     kind: "function",
     name,
@@ -62,7 +59,7 @@ const makeTemporal = <
 export const now = () =>
   makeTemporal(
     "now",
-    { dialect: "postgres", kind: "timestamptz" } as Expression.DbType.PgTimestamptz,
+    postgresDatatypes.timestamptz(),
     InstantStringSchema
   )
 
@@ -70,7 +67,7 @@ export const now = () =>
 export const currentDate = () =>
   makeTemporal(
     "current_date",
-    { dialect: "postgres", kind: "date" } as Expression.DbType.PgDate,
+    postgresDatatypes.date(),
     LocalDateStringSchema
   )
 
@@ -78,7 +75,7 @@ export const currentDate = () =>
 export const currentTime = () =>
   makeTemporal(
     "current_time",
-    { dialect: "postgres", kind: "timetz" } as Expression.DbType.PgTimetz,
+    postgresDatatypes.timetz(),
     OffsetTimeStringSchema
   )
 
@@ -86,7 +83,7 @@ export const currentTime = () =>
 export const currentTimestamp = () =>
   makeTemporal(
     "current_timestamp",
-    { dialect: "postgres", kind: "timestamptz" } as Expression.DbType.PgTimestamptz,
+    postgresDatatypes.timestamptz(),
     InstantStringSchema
   )
 
@@ -94,7 +91,7 @@ export const currentTimestamp = () =>
 export const localTime = () =>
   makeTemporal(
     "localtime",
-    { dialect: "postgres", kind: "time" } as Expression.DbType.PgTime,
+    postgresDatatypes.time(),
     LocalTimeStringSchema
   )
 
@@ -102,6 +99,6 @@ export const localTime = () =>
 export const localTimestamp = () =>
   makeTemporal(
     "localtimestamp",
-    { dialect: "postgres", kind: "timestamp" } as Expression.DbType.PgTimestamp,
+    postgresDatatypes.timestamp(),
     LocalDateTimeStringSchema
   )

package/src/postgres/function/window.ts

@@ -1,7 +1,2 @@
-import { postgresQuery } from "../private/query.js"
-
 /** Postgres window functions. */
-export const over = postgresQuery.over
-export const rowNumber = postgresQuery.rowNumber
-export const rank = postgresQuery.rank
-export const denseRank = postgresQuery.denseRank
+export { over, rowNumber, rank, denseRank } from "../internal/dsl.js"

package/src/{internal/postgres-dialect.ts → postgres/internal/dialect.ts}

@@ -1,4 +1,4 @@
-import type { RenderState, SqlDialect } from "./dialect.js"
+import type { RenderState, SqlDialect } from "../../internal/dialect.js"
 
 const quoteIdentifier = (value: string): string => `"${value.replaceAll("\"", "\"\"")}"`