effect-qb 0.15.0 → 0.16.0

package/src/mysql/internal/renderer.ts

@@ -1,4 +1,5 @@
 import * as Query from "../../internal/query.js"
+import type * as Expression from "../../internal/scalar.js"
 import { type RenderState } from "../../internal/dialect.js"
 import { mysqlDialect } from "./dialect.js"
 import { type Projection } from "../../internal/projections.js"
@@ -11,16 +12,23 @@ export interface MysqlRenderResult {
   readonly sql: string
   readonly params: readonly unknown[]
   readonly projections: readonly Projection[]
+  readonly valueMappings?: Expression.DriverValueMappings
+}
+
+export interface MysqlRenderOptions {
+  readonly valueMappings?: Expression.DriverValueMappings
 }
 
 /**
  * Renders the current query AST into MySQL-shaped SQL plus bind parameters.
  */
 export const renderMysqlPlan = <PlanValue extends Query.Plan.Any>(
-  plan: Query.DialectCompatiblePlan<PlanValue, "mysql">
+  plan: Query.DialectCompatiblePlan<PlanValue, "mysql">,
+  options: MysqlRenderOptions = {}
 ): MysqlRenderResult => {
   const state: RenderState = {
     params: [],
+    valueMappings: options.valueMappings,
     ctes: [],
     cteNames: new Set<string>()
   }
@@ -32,6 +40,7 @@ export const renderMysqlPlan = <PlanValue extends Query.Plan.Any>(
   return {
     sql: rendered.sql,
     params: state.params,
-    projections: rendered.projections
+    projections: rendered.projections,
+    valueMappings: state.valueMappings
   }
 }

package/src/mysql/internal/sql-expression-renderer.ts

@@ -5,6 +5,11 @@ import * as QueryAst from "../../internal/query-ast.js"
 import type { RenderState, SqlDialect } from "../../internal/dialect.js"
 import * as ExpressionAst from "../../internal/expression-ast.js"
 import * as JsonPath from "../../internal/json/path.js"
+import {
+  renderJsonSelectSql,
+  renderSelectSql,
+  toDriverValue
+} from "../../internal/runtime/driver-value-mapping.js"
 import { flattenSelection, type Projection } from "../../internal/projections.js"
 import { type SelectionValue, validateAggregationSelection } from "../../internal/aggregation-validation.js"
 import * as SchemaExpression from "../../internal/schema-expression.js"
@@ -313,6 +318,43 @@ const renderPostgresJsonValue = (
     : `cast(${rendered} as jsonb)`
 }
 
+const expressionDriverContext = (
+  expression: Expression.Any,
+  state: RenderState,
+  dialect: SqlDialect
+) => ({
+  dialect: dialect.name,
+  valueMappings: state.valueMappings,
+  dbType: expression[Expression.TypeId].dbType,
+  runtimeSchema: expression[Expression.TypeId].runtimeSchema,
+  driverValueMapping: expression[Expression.TypeId].driverValueMapping
+})
+
+const renderJsonInputExpression = (
+  expression: Expression.Any,
+  state: RenderState,
+  dialect: SqlDialect
+): string =>
+  renderJsonSelectSql(
+    renderExpression(expression, state, dialect),
+    expressionDriverContext(expression, state, dialect)
+  )
+
+const encodeArrayValues = (
+  values: readonly unknown[],
+  column: Table.AnyTable[typeof Table.TypeId]["fields"][string],
+  state: RenderState,
+  dialect: SqlDialect
+): readonly unknown[] =>
+  values.map((value) =>
+    toDriverValue(value, {
+      dialect: dialect.name,
+      valueMappings: state.valueMappings,
+      dbType: column.metadata.dbType,
+      runtimeSchema: column.schema,
+      driverValueMapping: column.metadata.driverValueMapping
+    }))
+
 const renderPostgresJsonKind = (
   value: Expression.Any
 ): "json" | "jsonb" => value[Expression.TypeId].dbType.kind === "jsonb" ? "jsonb" : "json"
@@ -474,7 +516,7 @@ const renderJsonExpression = (
         : []
       const renderedEntries = entries.flatMap((entry) => [
         dialect.renderLiteral(entry.key, state),
-        renderExpression(entry.value, state, dialect)
+        renderJsonInputExpression(entry.value, state, dialect)
       ])
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_object(${renderedEntries.join(", ")})`
@@ -488,7 +530,7 @@ const renderJsonExpression = (
       const values = Array.isArray((ast as { readonly values?: readonly Expression.Any[] }).values)
         ? (ast as { readonly values: readonly Expression.Any[] }).values
         : []
-      const renderedValues = values.map((value) => renderExpression(value, state, dialect)).join(", ")
+      const renderedValues = values.map((value) => renderJsonInputExpression(value, state, dialect)).join(", ")
       if (dialect.name === "postgres") {
         return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`
       }
@@ -502,7 +544,7 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        return `to_json(${renderExpression(base, state, dialect)})`
+        return `to_json(${renderJsonInputExpression(base, state, dialect)})`
       }
       if (dialect.name === "mysql") {
         return `cast(${renderExpression(base, state, dialect)} as json)`
@@ -513,7 +555,7 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        return `to_jsonb(${renderExpression(base, state, dialect)})`
+        return `to_jsonb(${renderJsonInputExpression(base, state, dialect)})`
       }
       if (dialect.name === "mysql") {
         return `cast(${renderExpression(base, state, dialect)} as json)`
@@ -767,7 +809,7 @@ const renderSelectionList = (
   const flattened = flattenSelection(selection)
   const projections = selectionProjections(selection)
   const sql = flattened.map(({ expression, alias }) =>
-    `${renderExpression(expression, state, dialect)} as ${dialect.quoteIdentifier(alias)}`).join(", ")
+    `${renderSelectSql(renderExpression(expression, state, dialect), expressionDriverContext(expression, state, dialect))} as ${dialect.quoteIdentifier(alias)}`).join(", ")
   return {
     sql,
     projections
@@ -888,14 +930,18 @@ export const renderQueryAst = (
           const table = targetSource.source as Table.AnyTable
           const fields = table[Table.TypeId].fields
           const rendered = unnestSource.values.map((entry) =>
-            `cast(${dialect.renderLiteral(entry.values, state)} as ${renderCastType(dialect, fields[entry.columnName]!.metadata.dbType)}[])`
+            `cast(${dialect.renderLiteral(encodeArrayValues(entry.values, fields[entry.columnName]!, state, dialect), state)} as ${renderCastType(dialect, fields[entry.columnName]!.metadata.dbType)}[])`
           ).join(", ")
           sql += ` (${columns}) select * from unnest(${rendered})`
         } else {
           const rowCount = unnestSource.values[0]?.values.length ?? 0
           const rows = Array.from({ length: rowCount }, (_, index) =>
             `(${unnestSource.values.map((entry) =>
-              dialect.renderLiteral(entry.values[index], state)
+              dialect.renderLiteral(
+                entry.values[index],
+                state,
+                (targetSource.source as Table.AnyTable)[Table.TypeId].fields[entry.columnName]![Expression.TypeId]
+              )
             ).join(", ")})`
           ).join(", ")
           sql += ` (${columns}) values ${rows}`
@@ -1267,7 +1313,7 @@ export const renderExpression = (
         ? dialect.quoteIdentifier(ast.columnName)
         : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`
     case "literal":
-      return dialect.renderLiteral(ast.value, state)
+      return dialect.renderLiteral(ast.value, state, expression[Expression.TypeId])
     case "excluded":
       return dialect.name === "mysql"
         ? `values(${dialect.quoteIdentifier(ast.columnName)})`

package/src/mysql/renderer.ts

@@ -1,4 +1,5 @@
 import * as CoreRenderer from "../internal/renderer.js"
+import type * as Expression from "../internal/scalar.js"
 import { renderMysqlPlan } from "./internal/renderer.js"
 
 /** MySQL-specialized rendered query shape. */
@@ -8,12 +9,16 @@ export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
 /** MySQL-specialized renderer contract. */
 export type Renderer = CoreRenderer.Renderer<"mysql">
 
+export interface MakeOptions {
+  readonly valueMappings?: Expression.DriverValueMappings
+}
+
 export { TypeId } from "../internal/renderer.js"
 export type { Projection } from "../internal/renderer.js"
 
 /** Creates the built-in MySQL renderer. */
-export const make = (): Renderer =>
-  CoreRenderer.make("mysql", renderMysqlPlan)
+export const make = (options: MakeOptions = {}): Renderer =>
+  CoreRenderer.make("mysql", (plan) => renderMysqlPlan(plan, options))
 
 /** Shared built-in MySQL renderer instance. */
 export const mysql = make()

package/src/postgres/cast.ts

@@ -1,26 +1,41 @@
 import type * as Expression from "../internal/scalar.js"
+import type * as ExpressionAst from "../internal/expression-ast.js"
 import type { ExpressionInput } from "../internal/query.js"
 import { cast as postgresCast } from "./internal/dsl.js"
 
 type CastInput = ExpressionInput
 type CastTarget = Expression.DbType.Any
-type CastExpression<Target extends CastTarget> = Expression.Scalar<
+type CastNullability<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.NullabilityOf<Value>
+  : Value extends null ? "always" : "never"
+type CastKind<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.KindOf<Value>
+  : "scalar"
+type CastDependencies<Value extends CastInput> = Value extends Expression.Any
+  ? Expression.DependenciesOf<Value>
+  : never
+type CastExpression<
+  Value extends CastInput,
+  Target extends CastTarget
+> = Expression.Scalar<
   Expression.RuntimeOfDbType<Target>,
   Target,
-  Expression.Nullability,
+  CastNullability<Value>,
   Target["dialect"],
-  Expression.ScalarKind,
-  Expression.BindingId
->
+  CastKind<Value>,
+  CastDependencies<Value>
+> & {
+  readonly [ExpressionAst.TypeId]: ExpressionAst.CastNode<Value extends Expression.Any ? Value : Expression.Any, Target>
+}
 
 const to: {
   <Value extends CastInput, Target extends CastTarget>(
     value: Value,
     target: Target
-  ): CastExpression<Target>
+  ): CastExpression<Value, Target>
   <Target extends CastTarget>(
     target: Target
-  ): <Value extends CastInput>(value: Value) => CastExpression<Target>
+  ): <Value extends CastInput>(value: Value) => CastExpression<Value, Target>
 } = ((...args: [CastInput, CastTarget] | [CastTarget]) =>
   args.length === 1
     ? ((value: CastInput) => postgresCast(value as never, args[0] as never))

package/src/postgres/column.ts

@@ -165,6 +165,7 @@ export const unique = BaseColumn.unique
 const default_ = BaseColumn.default_
 export const generated = BaseColumn.generated
 export const ddlType = BaseColumn.ddlType
+export const driverValueMapping = BaseColumn.driverValueMapping
 export const array = BaseColumn.array
 export const identityAlways = BaseColumn.identityAlways
 export const identityByDefault = BaseColumn.identityByDefault

package/src/postgres/executor.ts

@@ -5,6 +5,7 @@ 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 type * as Expression from "../internal/scalar.js"
 import { renderPostgresPlan } from "./internal/renderer.js"
 import {
   narrowPostgresDriverErrorForReadQuery,
@@ -28,6 +29,7 @@ export interface MakeOptions<Error = never, Context = never> {
   readonly renderer?: Renderer
   readonly driver?: Driver<Error, Context>
   readonly driverMode?: CoreExecutor.DriverMode
+  readonly valueMappings?: Expression.DriverValueMappings
 }
 /** Standard composed error shape for Postgres executors. */
 export type PostgresExecutorError = PostgresDriverError | RowDecodeError
@@ -67,7 +69,8 @@ const fromDriver = <
 >(
   renderer: Renderer,
   sqlDriver: Driver<Error, Context>,
-  driverMode: CoreExecutor.DriverMode = "raw"
+  driverMode: CoreExecutor.DriverMode = "raw",
+  valueMappings?: Expression.DriverValueMappings
 ): QueryExecutor<Context> => ({
   dialect: "postgres",
   execute(plan) {
@@ -76,7 +79,7 @@ const fromDriver = <
       Effect.flatMap(
         sqlDriver.execute(rendered),
         (rows) => Effect.try({
-          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode }),
+          try: () => CoreExecutor.decodeRows(rendered, plan, rows, { driverMode, valueMappings }),
           catch: (error) => error as RowDecodeError
         })
       ),
@@ -97,7 +100,7 @@ const fromDriver = <
       Stream.mapChunksEffect(
         sqlDriver.stream(rendered),
         (rows) => Effect.try({
-          try: () => CoreExecutor.decodeChunk(rendered, plan, rows, { driverMode }),
+          try: () => CoreExecutor.decodeChunk(rendered, plan, rows, { driverMode, valueMappings }),
           catch: (error) => error as RowDecodeError
         })
       ),
@@ -135,6 +138,7 @@ export function make(
   options: {
     readonly renderer?: Renderer
     readonly driverMode?: CoreExecutor.DriverMode
+    readonly valueMappings?: Expression.DriverValueMappings
   }
 ): QueryExecutor<SqlClient.SqlClient>
 export function make<Error = never, Context = never>(
@@ -142,15 +146,26 @@ export function make<Error = never, Context = never>(
     readonly renderer?: Renderer
     readonly driver: Driver<Error, Context>
     readonly driverMode?: CoreExecutor.DriverMode
+    readonly valueMappings?: Expression.DriverValueMappings
   }
 ): QueryExecutor<Context>
 export function make<Error = never, Context = never>(
   options: MakeOptions<Error, Context> = {}
 ): QueryExecutor<any> {
   if (options.driver) {
-    return fromDriver(options.renderer ?? CoreRenderer.make("postgres", renderPostgresPlan), options.driver, options.driverMode)
+    return fromDriver(
+      options.renderer ?? CoreRenderer.make("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options.valueMappings })),
+      options.driver,
+      options.driverMode,
+      options.valueMappings
+    )
   }
-  return fromDriver(options.renderer ?? CoreRenderer.make("postgres", renderPostgresPlan), sqlClientDriver(), options.driverMode)
+  return fromDriver(
+    options.renderer ?? CoreRenderer.make("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options.valueMappings })),
+    sqlClientDriver(),
+    options.driverMode,
+    options.valueMappings
+  )
 }
 
 /** Creates a Postgres-specialized executor from a typed implementation callback. */

package/src/postgres/internal/dialect.ts

@@ -1,15 +1,21 @@
-import type { RenderState, SqlDialect } from "../../internal/dialect.js"
+import type { RenderState, RenderValueContext, SqlDialect } from "../../internal/dialect.js"
+import { toDriverValue } from "../../internal/runtime/driver-value-mapping.js"
 
 const quoteIdentifier = (value: string): string => `"${value.replaceAll("\"", "\"\"")}"`
 
-const renderLiteral = (value: unknown, state: RenderState): string => {
-  if (value === null) {
+const renderLiteral = (value: unknown, state: RenderState, context: RenderValueContext = {}): string => {
+  const driverValue = toDriverValue(value, {
+    dialect: "postgres",
+    valueMappings: state.valueMappings,
+    ...context
+  })
+  if (driverValue === null) {
     return "null"
   }
-  if (typeof value === "boolean") {
-    return value ? "true" : "false"
+  if (typeof driverValue === "boolean") {
+    return driverValue ? "true" : "false"
   }
-  state.params.push(value)
+  state.params.push(driverValue)
   return `$${state.params.length}`
 }