effect-qb 0.14.0 → 0.15.0

package/src/mysql/errors/index.ts

@@ -2,6 +2,7 @@ export * from "./catalog.js"
 export * from "./fields.js"
 export * from "./normalize.js"
 export * from "./requirements.js"
+export * from "./types.js"
 
 export {
   findMysqlErrorDescriptorsByNumber as findMySqlErrorDescriptorsByNumber,

package/src/mysql/errors/normalize.ts

@@ -9,14 +9,35 @@ import {
   type MysqlErrorSymbol,
   type MysqlErrorTag
 } from "./catalog.js"
+import {
+  mysqlKnownErrorClassesBySymbol,
+  type KnownMysqlErrorBySymbol as ExactKnownMysqlErrorBySymbol
+} from "./generated.js"
 import type {
   MysqlErrorFields,
   MysqlQueryContext
 } from "./fields.js"
+import type {
+  MysqlErrorLike,
+  MysqlKnownErrorBase
+} from "./types.js"
 
 const isRecord = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null
 
+const unwrapMysqlDriverCause = (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
 
@@ -46,36 +67,16 @@ const normalizeFields = (error: Record<string, unknown>): MysqlErrorFields => ({
   hostname: asString(error.hostname)
 })
 
-/** Raw MySQL-like error shape as commonly exposed by client libraries. */
-export interface MysqlErrorLike {
-  readonly code?: string
-  readonly errno?: string | number
-  readonly sqlState?: string
-  readonly sqlMessage?: string
-  readonly message?: string
-  readonly fatal?: boolean
-  readonly sql?: string
-  readonly syscall?: string
-  readonly address?: string
-  readonly port?: string | number
-  readonly hostname?: string
-}
+export type { MysqlErrorLike } from "./types.js"
 
 /** Structured known MySQL error derived from the generated official catalog. */
-export type KnownMysqlError<Symbol extends MysqlErrorSymbol = MysqlErrorSymbol> = Readonly<{
-  readonly _tag: MysqlErrorTag<Symbol>
-  readonly category: MysqlErrorDescriptor<Symbol>["category"]
-  readonly number: MysqlErrorDescriptor<Symbol>["number"]
-  readonly symbol: Symbol
-  readonly documentedSqlState: MysqlErrorDescriptor<Symbol>["sqlState"]
-  readonly messageTemplate: MysqlErrorDescriptor<Symbol>["messageTemplate"]
-  readonly message: string
-  readonly query?: MysqlQueryContext
-  readonly raw: MysqlErrorLike
-} & MysqlErrorFields>
+export type KnownMysqlError<Symbol extends MysqlErrorSymbol = MysqlErrorSymbol> =
+  [MysqlErrorSymbol] extends [Symbol]
+    ? MysqlKnownErrorBase
+    : ExactKnownMysqlErrorBySymbol<Symbol>
 
 /** Extracts the normalized MySQL error variant for a specific symbol. */
-export type KnownMysqlErrorBySymbol<Symbol extends MysqlErrorSymbol> = KnownMysqlError<Symbol>
+export type KnownMysqlErrorBySymbol<Symbol extends MysqlErrorSymbol> = ExactKnownMysqlErrorBySymbol<Symbol>
 
 /** MySQL-like error whose symbol or number is not in the current catalog. */
 export type UnknownMysqlCodeError = Readonly<{
@@ -153,64 +154,62 @@ const findDescriptor = (error: MysqlErrorLike): MysqlErrorDescriptor | undefined
   return undefined
 }
 
-const makeKnownMysqlError = <Symbol extends MysqlErrorSymbol>(
-  descriptor: MysqlErrorDescriptor<Symbol>,
+const makeKnownMysqlError = (
+  descriptor: MysqlErrorDescriptor,
   raw: MysqlErrorLike,
   query?: MysqlQueryContext
-): KnownMysqlError<Symbol> => ({
-  _tag: descriptor.tag,
-  category: descriptor.category,
-  number: descriptor.number,
-  symbol: descriptor.symbol,
-  documentedSqlState: descriptor.sqlState,
-  messageTemplate: descriptor.messageTemplate,
-  message: errorMessageOf(raw),
-  query,
-  raw,
-  ...normalizeFields(raw as Record<string, unknown>),
-  sqlState: asString(raw.sqlState) ?? descriptor.sqlState
-}) as KnownMysqlError<Symbol>
+): MysqlKnownErrorBase => {
+  const ErrorClass = mysqlKnownErrorClassesBySymbol[descriptor.symbol]
+  return new ErrorClass({
+    message: errorMessageOf(raw),
+    query,
+    raw,
+    ...normalizeFields(raw as Record<string, unknown>),
+    sqlState: asString(raw.sqlState) ?? descriptor.sqlState
+  }) as MysqlKnownErrorBase
+}
 
 /** Normalizes an unknown failure into a structured MySQL driver error. */
 export const normalizeMysqlDriverError = (
   cause: unknown,
   query?: MysqlQueryContext | Renderer.RenderedQuery<any, "mysql">
 ): MysqlDriverError => {
+  const normalizedCause = unwrapMysqlDriverCause(cause)
   const context = query === undefined
     ? undefined
     : "sql" in query
       ? { sql: query.sql, params: query.params }
       : query
 
-  if (!isMysqlErrorLike(cause)) {
+  if (!isMysqlErrorLike(normalizedCause)) {
     return {
       _tag: "@mysql/unknown/driver",
-      message: cause instanceof Error ? cause.message : "Unknown MySQL driver failure",
+      message: normalizedCause instanceof Error ? normalizedCause.message : "Unknown MySQL driver failure",
       query: context,
       cause
     } as UnknownMysqlDriverError
   }
 
-  const descriptor = findDescriptor(cause)
+  const descriptor = findDescriptor(normalizedCause)
   if (descriptor !== undefined) {
-    return makeKnownMysqlError(descriptor, cause, context)
+    return makeKnownMysqlError(descriptor, normalizedCause, context)
   }
 
-  if (typeof cause.code === "string" || numberOf(cause) !== undefined) {
+  if (typeof normalizedCause.code === "string" || numberOf(normalizedCause) !== undefined) {
     return {
       _tag: "@mysql/unknown/code",
-      code: asString(cause.code),
-      errno: cause.errno,
-      message: errorMessageOf(cause),
+      code: asString(normalizedCause.code),
+      errno: normalizedCause.errno,
+      message: errorMessageOf(normalizedCause),
       query: context,
-      raw: cause,
-      ...normalizeFields(cause as Record<string, unknown>)
+      raw: normalizedCause,
+      ...normalizeFields(normalizedCause as Record<string, unknown>)
     } as UnknownMysqlCodeError
   }
 
   return {
     _tag: "@mysql/unknown/driver",
-    message: errorMessageOf(cause),
+    message: errorMessageOf(normalizedCause),
     query: context,
     cause
   } as UnknownMysqlDriverError
@@ -221,7 +220,10 @@ export const hasSymbol = <Symbol extends MysqlErrorSymbol>(
   error: MysqlDriverError | { readonly symbol?: string },
   symbol: Symbol
 ): error is KnownMysqlErrorBySymbol<Symbol> =>
-  "symbol" in error && error.symbol === symbol
+  (typeof error === "object" &&
+    error !== null &&
+    error instanceof mysqlKnownErrorClassesBySymbol[symbol]) ||
+  ("symbol" in error && error.symbol === symbol)
 
 /** Type guard for a specific documented MySQL error number. */
 export const hasNumber = <Number extends MysqlErrorNumber>(

package/src/mysql/errors/types.ts

@@ -0,0 +1,74 @@
+import type { MysqlErrorNumber, MysqlErrorSymbol, MysqlErrorTag } from "./catalog.js"
+import type { MysqlErrorFields, MysqlQueryContext } from "./fields.js"
+
+/** Raw MySQL-like error shape as commonly exposed by client libraries. */
+export interface MysqlErrorLike {
+  readonly code?: string
+  readonly errno?: string | number
+  readonly sqlState?: string
+  readonly sqlMessage?: string
+  readonly message?: string
+  readonly fatal?: boolean
+  readonly sql?: string
+  readonly syscall?: string
+  readonly address?: string
+  readonly port?: string | number
+  readonly hostname?: string
+}
+
+/** Broad known-MySQL error surface used by the normalizer return type. */
+export interface MysqlKnownErrorBase extends Error, MysqlErrorFields {
+  readonly _tag: MysqlErrorTag
+  readonly category: "server" | "client" | "global"
+  readonly number: MysqlErrorNumber
+  readonly symbol: MysqlErrorSymbol
+  readonly documentedSqlState?: string
+  readonly messageTemplate: string
+  readonly message: string
+  readonly query?: MysqlQueryContext
+  readonly raw: MysqlErrorLike
+}
+
+/** Shared constructor payload for generated MySQL error classes. */
+export type MysqlKnownErrorArgs = Readonly<{
+  readonly message: string
+  readonly query?: MysqlQueryContext
+  readonly raw: MysqlErrorLike
+} & MysqlErrorFields>
+
+/** Runtime base class shared by generated MySQL error classes. */
+export abstract class MysqlKnownErrorClass extends Error implements MysqlKnownErrorBase {
+  abstract readonly _tag: MysqlErrorTag
+  abstract readonly category: "server" | "client" | "global"
+  abstract readonly number: MysqlErrorNumber
+  abstract readonly symbol: MysqlErrorSymbol
+  abstract readonly documentedSqlState?: string
+  abstract readonly messageTemplate: string
+  readonly errno?
+  readonly sqlState?
+  readonly sqlMessage?
+  readonly fatal?
+  readonly sql?
+  readonly syscall?
+  readonly address?
+  readonly port?
+  readonly hostname?
+  readonly query?
+  readonly raw
+
+  constructor(args: MysqlKnownErrorArgs) {
+    super(args.message)
+    this.name = new.target.name
+    this.errno = args.errno
+    this.sqlState = args.sqlState
+    this.sqlMessage = args.sqlMessage
+    this.fatal = args.fatal
+    this.sql = args.sql
+    this.syscall = args.syscall
+    this.address = args.address
+    this.port = args.port
+    this.hostname = args.hostname
+    this.query = args.query
+    this.raw = args.raw
+  }
+}

package/src/mysql/executor.ts

@@ -1,10 +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 { renderMysqlPlan } from "../internal/mysql-renderer.js"
+import { renderMysqlPlan } from "./internal/renderer.js"
 import {
   narrowMysqlDriverErrorForReadQuery,
   normalizeMysqlDriverError,
@@ -45,18 +46,54 @@ export interface QueryExecutor<Context = never> {
   execute<PlanValue extends CoreQuery.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
     plan: CoreQuery.DialectCompatiblePlan<PlanValue, "mysql">
   ): Effect.Effect<CoreQuery.ResultRows<PlanValue>, MysqlQueryError<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, "mysql">
+      : never
+  ): Stream.Stream<CoreQuery.ResultRow<PlanValue>, MysqlQueryError<PlanValue>, Context>
 }
 
 /** Constructs a MySQL-specialized SQL driver. */
-export const driver = <
+export function driver<
   Error = never,
   Context = never
 >(
   execute: <Row>(
     query: CoreRenderer.RenderedQuery<Row, "mysql">
   ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
-): Driver<Error, Context> =>
-  CoreExecutor.driver("mysql", execute)
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  handlers: {
+    readonly execute: <Row>(
+      query: CoreRenderer.RenderedQuery<Row, "mysql">
+    ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+    readonly stream: <Row>(
+      query: CoreRenderer.RenderedQuery<Row, "mysql">
+    ) => Stream.Stream<FlatRow, Error, Context>
+  }
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  executeOrHandlers:
+    | (<Row>(
+      query: CoreRenderer.RenderedQuery<Row, "mysql">
+    ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>)
+    | {
+      readonly execute: <Row>(
+        query: CoreRenderer.RenderedQuery<Row, "mysql">
+      ) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+      readonly stream: <Row>(
+        query: CoreRenderer.RenderedQuery<Row, "mysql">
+      ) => Stream.Stream<FlatRow, Error, Context>
+    }
+): Driver<Error, Context> {
+  return CoreExecutor.driver("mysql", executeOrHandlers as any)
+}
 
 const fromDriver = <
   Error = never,
@@ -87,13 +124,38 @@ const fromDriver = <
           : narrowMysqlDriverErrorForReadQuery(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 = normalizeMysqlDriverError(error, rendered)
+        return CoreExecutor.hasWriteCapability(plan)
+          ? normalized
+          : narrowMysqlDriverErrorForReadQuery(normalized)
+      }
+    ) as Stream.Stream<any, any, Context>
   }
 })
 
 const sqlClientDriver = (): Driver<any, SqlClient.SqlClient> =>
-  driver((query) =>
-    Effect.flatMap(SqlClient.SqlClient, (sql) =>
-      sql.unsafe<FlatRow>(query.sql, [...query.params])))
+  driver({
+    execute: (query) =>
+      Effect.flatMap(SqlClient.SqlClient, (sql) =>
+        sql.unsafe<FlatRow>(query.sql, [...query.params])),
+    stream: (query) =>
+      CoreExecutor.streamFromSqlClient(query)
+  })
 
 /**
  * Creates the standard MySQL executor pipeline.

package/src/mysql/function/aggregate.ts

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

package/src/mysql/function/core.ts

@@ -1,5 +1,2 @@
-import { mysqlQuery } from "../private/query.js"
-
 /** MySQL scalar core functions. */
-export const coalesce = mysqlQuery.coalesce
-export const call = mysqlQuery.call
+export { coalesce, call } from "../internal/dsl.js"

package/src/mysql/function/index.ts

@@ -2,7 +2,6 @@ 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"

package/src/mysql/function/string.ts

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

package/src/mysql/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 { mysqlDatatypes } from "../datatypes/index.js"
 import {
   LocalDateStringSchema,
   LocalDateTimeStringSchema,
@@ -10,21 +11,19 @@ import {
   type LocalDateString,
   type LocalDateTimeString,
   type LocalTimeString
-} 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",
   "mysql",
   "scalar",
-  never,
-  {},
-  "resolved"
+  never
 > & {
   readonly [ExpressionAst.TypeId]: ExpressionAst.FunctionCallNode<Name, readonly []>
 }
@@ -44,10 +43,8 @@ const makeTemporal = <
     runtimeSchema,
     nullability: "never",
     dialect: "mysql",
-    aggregation: "scalar",
-    source: undefined as never,
+    kind: "scalar",
     dependencies: {},
-    sourceNullability: "resolved"
   }, {
     kind: "function",
     name,
@@ -58,7 +55,7 @@ const makeTemporal = <
 export const currentDate = () =>
   makeTemporal(
     "current_date",
-    { dialect: "mysql", kind: "date" } as Expression.DbType.MySqlDate,
+    mysqlDatatypes.date(),
     LocalDateStringSchema
   )
 
@@ -66,7 +63,7 @@ export const currentDate = () =>
 export const currentTime = () =>
   makeTemporal(
     "current_time",
-    { dialect: "mysql", kind: "time" } as Expression.DbType.MySqlTime,
+    mysqlDatatypes.time(),
     LocalTimeStringSchema
   )
 
@@ -74,7 +71,7 @@ export const currentTime = () =>
 export const currentTimestamp = () =>
   makeTemporal(
     "current_timestamp",
-    { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
+    mysqlDatatypes.timestamp(),
     LocalDateTimeStringSchema
   )
 
@@ -82,7 +79,7 @@ export const currentTimestamp = () =>
 export const localTime = () =>
   makeTemporal(
     "localtime",
-    { dialect: "mysql", kind: "time" } as Expression.DbType.MySqlTime,
+    mysqlDatatypes.time(),
     LocalTimeStringSchema
   )
 
@@ -90,7 +87,7 @@ export const localTime = () =>
 export const localTimestamp = () =>
   makeTemporal(
     "localtimestamp",
-    { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
+    mysqlDatatypes.timestamp(),
     LocalDateTimeStringSchema
   )
 
@@ -98,6 +95,6 @@ export const localTimestamp = () =>
 export const now = () =>
   makeTemporal(
     "now",
-    { dialect: "mysql", kind: "timestamp" } as Expression.DbType.MySqlTimestamp,
+    mysqlDatatypes.timestamp(),
     LocalDateTimeStringSchema
   )

package/src/mysql/function/window.ts

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

package/src/{internal/mysql-dialect.ts → mysql/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("`", "``")}\``