effect-qb 0.15.0 → 0.17.0

package/src/mysql/query.ts

@@ -16,7 +16,6 @@ import {
   type HavingPredicateInput,
   type OrderDirection,
   type OutputOfSelection,
-  type MutationInputOf,
   type MutationTargetLike,
   type NumericExpressionInput,
   type PredicateInput,
@@ -136,8 +135,17 @@ export {
   orderBy,
   groupBy
 } from "./internal/dsl.js"
+import type * as Expression from "../internal/scalar.js"
 export { mysqlType as type }
 
+type MysqlMutationValueInput<Value> =
+  | Value
+  | Expression.Scalar<Value, Expression.DbType.Any, Expression.Nullability, "mysql", Expression.ScalarKind, Expression.BindingId>
+
+export type MutationInputOf<Shape> = {
+  readonly [K in keyof Shape]: MysqlMutationValueInput<Shape[K]>
+}
+
 type StructuredSource = AnyValuesSource | AnyUnnestSource | AnyTableFunctionSource
 
 type StructuredFromApi = <CurrentSource extends StructuredSource>(
@@ -163,7 +171,6 @@ export type {
   HavingPredicateInput,
   OrderDirection,
   OutputOfSelection,
-  MutationInputOf,
   MutationTargetLike,
   NumericExpressionInput,
   PredicateInput,

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/mysql/table.ts

@@ -53,17 +53,31 @@ type SchemaNameOfTable<Table> = Table extends BaseTable.TableDefinition<any, any
     ? SchemaName
     : never
 
+type ApplySchemaTableOptions<
+  Name extends string,
+  Fields extends DialectFieldMap,
+  PrimaryKeyColumns extends keyof Fields & string,
+  SchemaName extends string,
+  Options extends BaseTable.DeclaredTableOptions
+> = BaseTable.ApplyDeclaredOptions<
+  BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>,
+  Options
+> extends BaseTable.TableDefinition<any, any, infer AppliedPrimaryKeyColumns extends keyof Fields & string, "schema", any>
+  ? TableDefinition<Name, Fields, AppliedPrimaryKeyColumns, "schema", SchemaName>
+  : TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+
 export type TableSchemaNamespace<SchemaName extends string> = {
   readonly schemaName: SchemaName
   readonly table: <
     Name extends string,
     Fields extends DialectFieldMap,
+    const Options extends BaseTable.DeclaredTableOptions,
     PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
   >(
     name: Name,
     fields: Fields,
-    ...options: BaseTable.DeclaredTableOptions
-  ) => TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
+    ...options: Options & BaseTable.ValidateDeclaredOptions<BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
+  ) => ApplySchemaTableOptions<Name, Fields, PrimaryKeyColumns, SchemaName, Options>
 }
 
 export type TableOption = BaseTable.TableOption
@@ -85,23 +99,31 @@ export const make = <
 
 export const schema = <SchemaName extends string>(
   schemaName: SchemaName
-): TableSchemaNamespace<SchemaName> => ({
-  schemaName,
-  table: <
+): TableSchemaNamespace<SchemaName> => {
+  const table = <
     Name extends string,
     Fields extends DialectFieldMap,
+    const Options extends BaseTable.DeclaredTableOptions,
     PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>
   >(
     name: Name,
     fields: Fields,
-    ...declaredOptions: BaseTable.DeclaredTableOptions
+    ...declaredOptions: Options & BaseTable.ValidateDeclaredOptions<BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>, Options>
   ) =>
-    BaseTable.schema(schemaName).table(
+    (BaseTable.schema(schemaName).table as (
+      name: Name,
+      fields: Fields,
+      ...options: BaseTable.DeclaredTableOptions
+    ) => BaseTable.TableDefinition<any, any, any, "schema", any>)(
       name,
       fields,
       ...declaredOptions
-    ) as TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>
-})
+    ) as ApplySchemaTableOptions<Name, Fields, PrimaryKeyColumns, SchemaName, Options>
+  return {
+    schemaName,
+    table
+  } as unknown as TableSchemaNamespace<SchemaName>
+}
 
 export const alias = <
   Table extends AnyTable,
@@ -144,11 +166,15 @@ export const foreignKey = <
   TargetTable extends AnyTable,
   TargetColumns extends string | readonly string[]
 >(
-  columns: LocalColumns,
+  columns: LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
   target: () => TargetTable,
-  referencedColumns: TargetColumns
+  referencedColumns: TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
 ): BaseTable.TableOption =>
-  BaseTable.foreignKey(columns, target as () => BaseTable.AnyTable, referencedColumns)
+  BaseTable.foreignKey<LocalColumns, BaseTable.AnyTable, TargetColumns>(
+    columns as LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
+    target as () => BaseTable.AnyTable,
+    referencedColumns as TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
+  )
 
 export const check = BaseTable.check
 

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

@@ -59,6 +59,8 @@ const boundedString = (length?: number): Schema.Schema<string> =>
     ? Schema.String
     : Schema.String.pipe(Schema.maxLength(length))
 
+const finiteNumber = Schema.Number.pipe(Schema.finite())
+
 export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expression.DbType.Any>(
   schema: SchemaType,
   dbType: Db
@@ -92,8 +94,8 @@ export const number = (options?: BaseColumn.NumericOptions) =>
     ddlType: renderNumericDdlType("numeric", options),
     identity: undefined
   })
-export const float4 = () => primitive(Schema.Number, postgresDatatypes.float4())
-export const float8 = () => primitive(Schema.Number, postgresDatatypes.float8())
+export const float4 = () => primitive(finiteNumber, postgresDatatypes.float4())
+export const float8 = () => primitive(finiteNumber, postgresDatatypes.float8())
 export const boolean = () => primitive(Schema.Boolean, postgresDatatypes.boolean())
 export const date = () => primitive(LocalDateStringSchema, postgresDatatypes.date())
 export const timestamp = () => primitive(LocalDateTimeStringSchema, postgresDatatypes.timestamp())
@@ -165,6 +167,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/errors/normalize.ts

@@ -44,8 +44,8 @@ const asNumber = (value: unknown): number | undefined => {
   if (typeof value === "number" && Number.isFinite(value)) {
     return value
   }
-  if (typeof value === "string" && value.trim() !== "") {
-    const parsed = Number(value)
+  if (typeof value === "string" && /^[+-]?\d+$/.test(value.trim())) {
+    const parsed = Number(value.trim())
     return Number.isFinite(parsed) ? parsed : undefined
   }
   return undefined

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
@@ -53,12 +55,55 @@ export interface QueryExecutor<Context = never> {
   ): Stream.Stream<CoreQuery.ResultRow<PlanValue>, PostgresQueryError<PlanValue>, Context>
 }
 
+type DriverExecute<Error, Context> = <Row>(
+  query: CoreRenderer.RenderedQuery<Row, "postgres">
+) => Effect.Effect<ReadonlyArray<FlatRow>, Error, Context>
+
+type DriverHandlers<Error, Context> = {
+  readonly execute: DriverExecute<Error, Context>
+  readonly stream: <Row>(
+    query: CoreRenderer.RenderedQuery<Row, "postgres">
+  ) => Stream.Stream<FlatRow, Error, Context>
+}
+
 /** Constructs a Postgres-specialized SQL driver. */
-export function driver(execute: any): Driver<any, any>
-export function driver(dialect: "postgres", execute: any): Driver<any, any>
-export function driver(dialectOrExecute: "postgres" | any, maybeExecute?: any): Driver<any, any> {
-  const execute = typeof dialectOrExecute === "string" ? maybeExecute : dialectOrExecute
-  return CoreExecutor.driver("postgres", execute as any)
+export function driver<
+  Error = never,
+  Context = never
+>(
+  execute: DriverExecute<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  handlers: DriverHandlers<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  dialect: "postgres",
+  execute: DriverExecute<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  dialect: "postgres",
+  handlers: DriverHandlers<Error, Context>
+): Driver<Error, Context>
+export function driver<
+  Error = never,
+  Context = never
+>(
+  dialectOrExecute: "postgres" | DriverExecute<Error, Context> | DriverHandlers<Error, Context>,
+  maybeExecute?: DriverExecute<Error, Context> | DriverHandlers<Error, Context>
+): Driver<Error, Context> {
+  const executeOrHandlers = typeof dialectOrExecute === "string" ? maybeExecute : dialectOrExecute
+  return typeof executeOrHandlers === "function"
+    ? CoreExecutor.driver("postgres", executeOrHandlers)
+    : CoreExecutor.driver("postgres", executeOrHandlers as DriverHandlers<Error, Context>)
 }
 
 const fromDriver = <
@@ -67,7 +112,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 +122,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 +143,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 +181,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 +189,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/function/core.ts

@@ -12,11 +12,29 @@ import { isSequenceDefinition, type SequenceDefinition } from "../schema-managem
 
 /** Postgres scalar core functions. */
 export { coalesce, call, uuidGenerateV4 }
+
+const safeUnquotedIdentifier = /^[a-z_][a-z0-9_$]*$/
+
+const quoteIdentifier = (value: string): string =>
+  `"${value.replaceAll("\"", "\"\"")}"`
+
+const renderIdentifier = (value: string): string =>
+  safeUnquotedIdentifier.test(value)
+    ? value
+    : quoteIdentifier(value)
+
+const renderQualifiedSequenceName = (
+  value: SequenceDefinition<string, string | undefined>
+): string =>
+  value.schemaName === undefined || value.schemaName === "public"
+    ? renderIdentifier(value.name)
+    : `${renderIdentifier(value.schemaName)}.${renderIdentifier(value.name)}`
+
 export const nextVal = (
   value: ExpressionInput | SequenceDefinition<string, string | undefined>
 ) =>
   nextValInternal(
     isSequenceDefinition(value)
-      ? cast(literal(value.qualifiedName()), postgresType.regclass())
+      ? cast(literal(renderQualifiedSequenceName(value)), postgresType.regclass())
       : value
   )

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}`
 }