effect-qb 0.15.0 → 0.16.0

package/src/internal/renderer.ts

@@ -1,4 +1,5 @@
 import * as Query from "./query.js"
+import type * as Expression from "./scalar.js"
 import { type Projection, validateProjections } from "./projections.js"
 
 /** Symbol used to attach rendered-query phantom row metadata. */
@@ -21,6 +22,7 @@ export interface RenderedQuery<Row, Dialect extends string = string> {
   readonly params: readonly unknown[]
   readonly dialect: Dialect
   readonly projections: readonly Projection[]
+  readonly valueMappings?: Expression.DriverValueMappings
   readonly [TypeId]: {
     readonly row: Row
     readonly dialect: Dialect
@@ -51,6 +53,7 @@ type CustomRender<Dialect extends string> = <PlanValue extends Query.Plan.Any>(
   readonly sql: string
   readonly params?: readonly unknown[]
   readonly projections?: readonly Projection[]
+  readonly valueMappings?: Expression.DriverValueMappings
 }
 
 /**
@@ -77,6 +80,7 @@ export function make<Dialect extends string>(
         sql: rendered.sql,
         params: rendered.params ?? [],
         projections,
+        valueMappings: rendered.valueMappings,
         dialect,
         [TypeId]: {
           row: undefined as any,

package/src/internal/runtime/driver-value-mapping.ts

@@ -0,0 +1,186 @@
+import * as Schema from "effect/Schema"
+
+import type * as Expression from "../scalar.js"
+import { normalizeDbValue } from "./normalize.js"
+
+export type DriverValueMapping = Expression.DriverValueMapping
+export type DriverValueMappings = Expression.DriverValueMappings
+
+export interface DriverValueContext {
+  readonly dialect?: string
+  readonly dbType?: Expression.DbType.Any
+  readonly runtimeSchema?: Schema.Schema.Any
+  readonly driverValueMapping?: DriverValueMapping
+  readonly valueMappings?: DriverValueMappings
+}
+
+type MappingKey =
+  | "fromDriver"
+  | "toDriver"
+  | "selectSql"
+  | "jsonSelectSql"
+
+const runtimeTagOfDbType = (
+  dbType: Expression.DbType.Any | undefined
+): string | undefined => {
+  if (dbType === undefined) {
+    return undefined
+  }
+  if ("base" in dbType) {
+    return runtimeTagOfDbType(dbType.base)
+  }
+  if ("element" in dbType) {
+    return "array"
+  }
+  if ("fields" in dbType) {
+    return "record"
+  }
+  if ("variant" in dbType && dbType.variant === "json") {
+    return "json"
+  }
+  if ("variant" in dbType && (dbType.variant === "enum" || dbType.variant === "set")) {
+    return "string"
+  }
+  return dbType.runtime
+}
+
+const familyOfDbType = (
+  dbType: Expression.DbType.Any | undefined
+): string | undefined => {
+  if (dbType === undefined) {
+    return undefined
+  }
+  if ("base" in dbType) {
+    return familyOfDbType(dbType.base)
+  }
+  return dbType.family
+}
+
+const mappingCandidates = (
+  context: DriverValueContext
+): readonly (DriverValueMapping | undefined)[] => {
+  const dbType = context.dbType
+  const runtimeTag = runtimeTagOfDbType(dbType)
+  const family = familyOfDbType(dbType)
+  return [
+    context.driverValueMapping,
+    dbType?.driverValueMapping,
+    dbType === undefined ? undefined : context.valueMappings?.[dbType.kind],
+    family === undefined ? undefined : context.valueMappings?.[family],
+    runtimeTag === undefined ? undefined : context.valueMappings?.[runtimeTag]
+  ]
+}
+
+const findMapping = <Key extends MappingKey>(
+  context: DriverValueContext,
+  key: Key
+): NonNullable<DriverValueMapping[Key]> | undefined => {
+  for (const candidate of mappingCandidates(context)) {
+    const value = candidate?.[key]
+    if (value !== undefined) {
+      return value as NonNullable<DriverValueMapping[Key]>
+    }
+  }
+  return undefined
+}
+
+const encodeWithSchema = (
+  schema: Schema.Schema.Any | undefined,
+  value: unknown
+): { readonly value: unknown; readonly encoded: boolean } => {
+  if (schema === undefined) {
+    return { value, encoded: false }
+  }
+  if (!(Schema.is(schema) as (value: unknown) => boolean)(value)) {
+    return { value, encoded: false }
+  }
+  return {
+    value: (Schema.encodeUnknownSync as any)(schema)(value),
+    encoded: true
+  }
+}
+
+export const toDriverValue = (
+  value: unknown,
+  context: DriverValueContext
+): unknown => {
+  if (value === null) {
+    return null
+  }
+  const dbType = context.dbType
+  const encoded = encodeWithSchema(context.runtimeSchema, value)
+  let current = encoded.value
+  const custom = findMapping(context, "toDriver")
+  if (custom !== undefined && dbType !== undefined) {
+    return custom(current, dbType)
+  }
+  return dbType === undefined || !encoded.encoded
+    ? current
+    : normalizeDbValue(dbType, current)
+}
+
+export const fromDriverValue = (
+  value: unknown,
+  context: DriverValueContext
+): unknown => {
+  if (value === null) {
+    return null
+  }
+  const dbType = context.dbType
+  const custom = findMapping(context, "fromDriver")
+  if (custom !== undefined && dbType !== undefined) {
+    return custom(value, dbType)
+  }
+  return dbType === undefined
+    ? value
+    : normalizeDbValue(dbType, value)
+}
+
+const textCast = (sql: string): string => `(${sql})::text`
+
+const postgresJsonSql = (
+  sql: string,
+  dbType: Expression.DbType.Any
+): string => {
+  const runtimeTag = runtimeTagOfDbType(dbType)
+  switch (runtimeTag) {
+    case "bigintString":
+    case "decimalString":
+    case "localDate":
+    case "localTime":
+    case "offsetTime":
+    case "localDateTime":
+    case "instant":
+    case "year":
+      return textCast(sql)
+    case "bytes":
+      return `encode(${sql}, 'base64')`
+    default:
+      return sql
+  }
+}
+
+export const renderSelectSql = (
+  sql: string,
+  context: DriverValueContext
+): string => {
+  const dbType = context.dbType
+  const custom = findMapping(context, "selectSql")
+  return custom !== undefined && dbType !== undefined
+    ? custom(sql, dbType)
+    : sql
+}
+
+export const renderJsonSelectSql = (
+  sql: string,
+  context: DriverValueContext
+): string => {
+  const dbType = context.dbType
+  const custom = findMapping(context, "jsonSelectSql")
+  if (custom !== undefined && dbType !== undefined) {
+    return custom(sql, dbType)
+  }
+  return context.dialect === "postgres" && dbType !== undefined
+    ? postgresJsonSql(sql, dbType)
+    : sql
+}

package/src/internal/scalar.ts

@@ -51,6 +51,7 @@ export declare namespace DbType {
     readonly compareGroup?: string
     readonly castTargets?: readonly string[]
     readonly traits?: DatatypeTraits
+    readonly driverValueMapping?: DriverValueMapping
   }
 
   /** JSON-like database type. */
@@ -135,6 +136,15 @@ export declare namespace DbType {
     | Set<string, string>
   }
 
+export interface DriverValueMapping {
+  readonly fromDriver?: (value: unknown, dbType: DbType.Any) => unknown
+  readonly toDriver?: (value: unknown, dbType: DbType.Any) => unknown
+  readonly selectSql?: (sql: string, dbType: DbType.Any) => string
+  readonly jsonSelectSql?: (sql: string, dbType: DbType.Any) => string
+}
+
+export type DriverValueMappings = Readonly<Record<string, DriverValueMapping | undefined>>
+
 /** Canonical static metadata stored on an expression. */
 export interface State<
   Runtime,
@@ -147,6 +157,7 @@ export interface State<
   readonly runtime: Runtime
   readonly dbType: Db
   readonly runtimeSchema?: Schema.Schema.Any
+  readonly driverValueMapping?: DriverValueMapping
   readonly nullability: Nullable
   readonly dialect: Dialect
   readonly kind: Kind

package/src/mysql/column.ts

@@ -100,6 +100,7 @@ export const primaryKey = BaseColumn.primaryKey
 export const unique = BaseColumn.unique
 const default_ = BaseColumn.default_
 export const generated = BaseColumn.generated
+export const driverValueMapping = BaseColumn.driverValueMapping
 export const references = BaseColumn.references
 export const schema = BaseColumn.schema
 export { default_ as default }

package/src/mysql/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 { renderMysqlPlan } from "./internal/renderer.js"
 import {
   narrowMysqlDriverErrorForReadQuery,
@@ -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 MySQL executors. */
 export type MysqlExecutorError = MysqlDriverError | RowDecodeError
@@ -101,7 +103,8 @@ const fromDriver = <
 >(
   renderer: Renderer,
   sqlDriver: Driver<Error, Context>,
-  driverMode: CoreExecutor.DriverMode = "raw"
+  driverMode: CoreExecutor.DriverMode = "raw",
+  valueMappings?: Expression.DriverValueMappings
 ): QueryExecutor<Context> => ({
   dialect: "mysql",
   execute(plan) {
@@ -110,7 +113,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
         })
       ),
@@ -131,7 +134,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
         })
       ),
@@ -169,6 +172,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>(
@@ -176,15 +180,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("mysql", renderMysqlPlan), options.driver, options.driverMode)
+    return fromDriver(
+      options.renderer ?? CoreRenderer.make("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options.valueMappings })),
+      options.driver,
+      options.driverMode,
+      options.valueMappings
+    )
   }
-  return fromDriver(options.renderer ?? CoreRenderer.make("mysql", renderMysqlPlan), sqlClientDriver(), options.driverMode)
+  return fromDriver(
+    options.renderer ?? CoreRenderer.make("mysql", (plan) => renderMysqlPlan(plan, { valueMappings: options.valueMappings })),
+    sqlClientDriver(),
+    options.driverMode,
+    options.valueMappings
+  )
 }
 
 /** Creates a MySQL-specialized executor from a typed implementation callback. */

package/src/mysql/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: "mysql",
+    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 "?"
 }