effect-qb 0.15.0 → 0.16.0

package/src/postgres/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 { postgresDialect } from "./dialect.js"
 import { type Projection } from "../../internal/projections.js"
@@ -14,16 +15,23 @@ export interface PostgresRenderResult {
   readonly sql: string
   readonly params: readonly unknown[]
   readonly projections: readonly Projection[]
+  readonly valueMappings?: Expression.DriverValueMappings
+}
+
+export interface PostgresRenderOptions {
+  readonly valueMappings?: Expression.DriverValueMappings
 }
 
 /**
  * Renders the current query AST into Postgres SQL plus bind parameters.
  */
 export const renderPostgresPlan = <PlanValue extends Query.Plan.Any>(
-  plan: Query.DialectCompatiblePlan<PlanValue, "postgres">
+  plan: Query.DialectCompatiblePlan<PlanValue, "postgres">,
+  options: PostgresRenderOptions = {}
 ): PostgresRenderResult => {
   const state: RenderState = {
     params: [],
+    valueMappings: options.valueMappings,
     ctes: [],
     cteNames: new Set<string>()
   }
@@ -35,6 +43,7 @@ export const renderPostgresPlan = <PlanValue extends Query.Plan.Any>(
   return {
     sql: rendered.sql,
     params: state.params,
-    projections: rendered.projections
+    projections: rendered.projections,
+    valueMappings: state.valueMappings
   }
 }

package/src/postgres/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"
@@ -294,11 +299,54 @@ const renderPostgresJsonValue = (
     throw new Error("Expected a JSON expression")
   }
   const rendered = renderExpression(value, state, dialect)
+  const ast = (value as Expression.Any & {
+    readonly [ExpressionAst.TypeId]: ExpressionAst.Any
+  })[ExpressionAst.TypeId]
+  if (ast.kind === "literal") {
+    return `cast(${rendered} as jsonb)`
+  }
   return value[Expression.TypeId].dbType.kind === "jsonb"
     ? rendered
     : `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"
@@ -460,7 +508,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(", ")})`
@@ -474,7 +522,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})`
       }
@@ -488,7 +536,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)`
@@ -499,7 +547,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)`
@@ -753,7 +801,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
@@ -874,14 +922,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}`
@@ -1253,7 +1305,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/postgres/renderer.ts

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

package/src/postgres/type.ts

@@ -25,6 +25,10 @@ type PostgresTypeNamespace = typeof postgresDatatypes & {
   readonly enum: <Kind extends string>(kind: Kind) => Expression.DbType.Enum<"postgres", Kind>
   readonly set: <Kind extends string>(kind: Kind) => Expression.DbType.Set<"postgres", Kind>
   readonly custom: <Kind extends string>(kind: Kind) => Expression.DbType.Base<"postgres", Kind>
+  readonly driverValueMapping: <Db extends Expression.DbType.Any>(
+    dbType: Db,
+    mapping: Expression.DriverValueMapping
+  ) => Db
 }
 
 /** Postgres database-type constructors for casts and typed column references. */