effect-qb 0.16.0 → 0.19.0

package/src/mysql/internal/renderer.ts

@@ -1,9 +1,10 @@
 import * as Query from "../../internal/query.js"
 import type * as Expression from "../../internal/scalar.js"
+import type * as Casing from "../../internal/casing.js"
 import { type RenderState } from "../../internal/dialect.js"
 import { mysqlDialect } from "./dialect.js"
 import { type Projection } from "../../internal/projections.js"
-import { renderQueryAst } from "./sql-expression-renderer.js"
+import { renderQueryAst } from "../../internal/sql-expression-renderer.js"
 
 /**
  * Internal rendered-query payload produced by the built-in MySQL renderer.
@@ -17,6 +18,7 @@ export interface MysqlRenderResult {
 
 export interface MysqlRenderOptions {
   readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
 }
 
 /**
@@ -29,8 +31,11 @@ export const renderMysqlPlan = <PlanValue extends Query.Plan.Any>(
   const state: RenderState = {
     params: [],
     valueMappings: options.valueMappings,
+    casing: options.casing,
     ctes: [],
-    cteNames: new Set<string>()
+    cteNames: new Set<string>(),
+    cteSources: new Map<string, unknown>(),
+    sourceNames: new Map()
   }
   const rendered = renderQueryAst(
     Query.getAst(plan as Query.Plan.Any) as any,

package/src/mysql/json.ts

@@ -1,2 +1,39 @@
 /** MySQL JSON expression helpers. */
 export { json } from "./internal/dsl.js"
+import { json } from "./internal/dsl.js"
+
+export const key = json.key
+export const index = json.index
+export const wildcard = json.wildcard
+export const slice = json.slice
+export const descend = json.descend
+export const path = json.path
+export const get = json.get
+export const access = json.access
+export const traverse = json.traverse
+export const text = json.text
+export const accessText = json.accessText
+export const traverseText = json.traverseText
+export const contains = json.contains
+export const containedBy = json.containedBy
+export const hasKey = json.hasKey
+export const keyExists = json.keyExists
+export const hasAnyKeys = json.hasAnyKeys
+export const hasAllKeys = json.hasAllKeys
+export const delete_ = json.delete
+export { delete_ as delete }
+export const remove = json.remove
+export const set = json.set
+export const insert = json.insert
+export const concat = json.concat
+export const merge = json.merge
+export const buildObject = json.buildObject
+export const buildArray = json.buildArray
+export const toJson = json.toJson
+export const toJsonb = json.toJsonb
+export const typeOf = json.typeOf
+export const length = json.length
+export const keys = json.keys
+export const stripNulls = json.stripNulls
+export const pathExists = json.pathExists
+export const pathMatch = json.pathMatch

package/src/mysql/query-extension.ts

@@ -0,0 +1,16 @@
+import { lock } from "./query.js"
+
+/** MySQL-only mutation modifier for UPDATE IGNORE. */
+export const ignore = lock("ignore")
+
+/** MySQL-only mutation modifier for DELETE QUICK. */
+export const quick = lock("quick")
+
+/** MySQL-only mutation modifier for LOW_PRIORITY mutations. */
+export const lowPriority = lock("lowPriority")
+
+/** MySQL-only mutation ordering and limiting. */
+export { orderBy, limit } from "./query.js"
+
+/** MySQL-only multi-target mutation forms. */
+export { update, delete } from "./query.js"

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,5 +1,9 @@
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
 import * as CoreRenderer from "../internal/renderer.js"
+import * as Casing from "../internal/casing.js"
 import type * as Expression from "../internal/scalar.js"
+import type { MysqlDatatypeFamily, MysqlDatatypeKind } from "./datatypes/spec.js"
 import { renderMysqlPlan } from "./internal/renderer.js"
 
 /** MySQL-specialized rendered query shape. */
@@ -7,18 +11,41 @@ export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "mysql">
 /** Extracts the row type carried by a MySQL rendered query. */
 export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
 /** MySQL-specialized renderer contract. */
-export type Renderer = CoreRenderer.Renderer<"mysql">
+export type Renderer = CoreRenderer.Renderer<"mysql"> & Pipeable & {
+  readonly [Casing.TypeId]: Casing.State
+  readonly withCasing: (options: Casing.Options) => Renderer
+}
+
+export type ValueMappings = Expression.DriverValueMappingsFor<MysqlDatatypeKind | "uuid", MysqlDatatypeFamily | "uuid">
 
 export interface MakeOptions {
-  readonly valueMappings?: Expression.DriverValueMappings
+  readonly valueMappings?: ValueMappings
+  readonly casing?: Casing.Options
 }
 
 export { TypeId } from "../internal/renderer.js"
 export type { Projection } from "../internal/renderer.js"
 
+const RendererProto = {
+  pipe(this: Pipeable) {
+    return pipeArguments(this, arguments)
+  }
+}
+
 /** Creates the built-in MySQL renderer. */
-export const make = (options: MakeOptions = {}): Renderer =>
-  CoreRenderer.make("mysql", (plan) => renderMysqlPlan(plan, options))
+export const make = (options: MakeOptions = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("mysql", (plan) => renderMysqlPlan(plan, options))
+  return Object.assign(Object.create(RendererProto), renderer, {
+    [Casing.TypeId]: {
+      casing: options.casing
+    },
+    withCasing: (override: Casing.Options) =>
+      make({
+        ...options,
+        casing: Casing.merge(options.casing, override)
+      })
+  }) as Renderer
+}
 
 /** Shared built-in MySQL renderer instance. */
 export const mysql = make()

package/src/mysql.ts

@@ -1,22 +1,14 @@
-/** MySQL-specialized column-definition DSL. */
-export * as Column from "./mysql/column.js"
+/** MySQL-specific column extensions. Portable columns are exported from `effect-qb`. */
+export * as Column from "./mysql/column-extension.js"
 /** MySQL datatype witnesses and coercion families. */
 export * as Datatypes from "./mysql/datatypes/index.js"
 /** MySQL error catalog and error normalization helpers. */
 export * as Errors from "./mysql/errors/index.js"
-/** Shared scalar SQL interfaces and DB-type descriptors. */
-export * as Scalar from "./internal/scalar.js"
-/** MySQL-specialized SQL function expressions. */
-export * as Function from "./mysql/function/index.js"
 /** MySQL-specialized JSON expression helpers. */
 export * as Json from "./mysql/json.js"
 /** MySQL-specialized typed query execution contracts. */
 export * as Executor from "./mysql/executor.js"
-/** Shared logical row-set interfaces. */
-export * as RowSet from "./internal/row-set.js"
-/** MySQL-specialized query-construction DSL. */
-export * as Query from "./mysql/query.js"
-/** MySQL-specialized table-definition DSL. */
-export * as Table from "./mysql/table.js"
+/** MySQL-specific query helpers. Portable queries are exported from the root package. */
+export * as Query from "./mysql/query-extension.js"
 /** MySQL-specialized built-in renderer entrypoint. */
 export * as Renderer from "./mysql/renderer.js"

package/src/postgres/column-extension.ts

@@ -0,0 +1,28 @@
+export {
+  array,
+  bit,
+  bytea,
+  custom,
+  ddlType,
+  float4,
+  float8,
+  foreignKey,
+  identityAlways,
+  identityByDefault,
+  index,
+  int2,
+  int8,
+  interval,
+  jsonb,
+  name,
+  oid,
+  pg_lsn,
+  regclass,
+  timetz,
+  timestamptz,
+  unique,
+  varbit,
+  xml
+} from "./column.js"
+
+export type { Any, AnyBound } from "./column.js"

package/src/postgres/column.ts

@@ -3,6 +3,7 @@ import * as Schema from "effect/Schema"
 import * as BaseColumn from "../internal/column.js"
 import { makeColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
 import type * as Expression from "../internal/scalar.js"
+import { enrichDbType } from "../internal/datatypes/enrich.js"
 import {
   BigIntStringSchema,
   DecimalStringSchema,
@@ -21,13 +22,6 @@ import {
 } from "../internal/runtime/value.js"
 import { postgresDatatypes } from "./datatypes/index.js"
 
-const enrichDbType = <Db extends Expression.DbType.Any>(dbType: Db): Db => {
-  const candidate = (postgresDatatypes as unknown as Record<string, (() => Expression.DbType.Any) | undefined>)[dbType.kind]
-  return typeof candidate === "function"
-    ? { ...candidate(), ...dbType } as Db
-    : dbType
-}
-
 const primitive = <Type, Db extends Expression.DbType.Any>(
   schema: Schema.Schema<Type, any, any>,
   dbType: Db
@@ -59,12 +53,14 @@ 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
 ) =>
-  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
-    dbType: enrichDbType(dbType),
+  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+    dbType: enrichDbType(postgresDatatypes, dbType),
     nullable: false,
     hasDefault: false,
     generated: false,
@@ -92,8 +88,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())
@@ -134,7 +130,7 @@ export const varchar = (length?: number) =>
     identity: undefined
   })
 export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
-  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
     dbType: postgresDatatypes.json(),
     nullable: false,
     hasDefault: false,
@@ -146,7 +142,7 @@ export const json = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =
     identity: undefined
   })
 export const jsonb = <SchemaType extends Schema.Schema.Any>(schema: SchemaType) =>
-  makeColumnDefinition(schema as unknown as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
+  makeColumnDefinition(schema as Schema.Schema<NonNullable<Schema.Schema.Type<SchemaType>>, any, any>, {
     dbType: postgresDatatypes.jsonb(),
     nullable: false,
     hasDefault: false,

package/src/postgres/datatypes/index.d.ts

@@ -1,7 +1,8 @@
 import type * as Expression from "../../internal/scalar.js";
+import type { NonEmptyStringInput } from "../../internal/table-options.js";
 import { postgresDatatypeFamilies, postgresDatatypeKinds } from "./spec.js";
 export declare const postgresDatatypes: {
-    custom: <Kind extends string>(kind: Kind) => Expression.DbType.Base<"postgres", Kind>;
+    custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => Expression.DbType.Base<"postgres", Kind>;
     text: () => Expression.DbType.Base<"postgres", "text"> & {
         readonly family: "text";
         readonly runtime: "string";

package/src/postgres/datatypes/index.ts

@@ -1,5 +1,6 @@
 import type { DatatypeModule } from "../../internal/datatypes/define.js"
 import type * as Expression from "../../internal/scalar.js"
+import type { NonEmptyStringInput } from "../../internal/table-options.js"
 import { postgresDatatypeFamilies, postgresDatatypeKinds } from "./spec.js"
 
 const withMetadata = <Kind extends keyof typeof postgresDatatypeKinds & string>(
@@ -19,9 +20,9 @@ const withMetadata = <Kind extends keyof typeof postgresDatatypeKinds & string>(
 }
 
 const postgresDatatypeModule = {
-  custom: (kind: string) => ({
+  custom: <Kind extends string>(kind: NonEmptyStringInput<Kind>) => ({
     dialect: "postgres",
-    kind
+    kind: kind as Kind
   }),
   boolean: () => withMetadata("bool")
 } as Record<string, (...args: readonly any[]) => Expression.DbType.Base<"postgres", string>>

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

@@ -6,6 +6,7 @@ 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 type { PostgresDatatypeFamily, PostgresDatatypeKind } from "./datatypes/spec.js"
 import { renderPostgresPlan } from "./internal/renderer.js"
 import {
   narrowPostgresDriverErrorForReadQuery,
@@ -24,12 +25,13 @@ export type Driver<Error = never, Context = never> = CoreExecutor.Driver<"postgr
 export type Executor<Error = never, Context = never> = CoreExecutor.Executor<"postgres", Error, Context>
 /** Postgres-specialized renderer contract. */
 export type Renderer = CoreRenderer.Renderer<"postgres">
+export type ValueMappings = Expression.DriverValueMappingsFor<PostgresDatatypeKind, PostgresDatatypeFamily>
 /** Optional renderer / driver overrides for the standard Postgres executor pipeline. */
 export interface MakeOptions<Error = never, Context = never> {
   readonly renderer?: Renderer
   readonly driver?: Driver<Error, Context>
   readonly driverMode?: CoreExecutor.DriverMode
-  readonly valueMappings?: Expression.DriverValueMappings
+  readonly valueMappings?: ValueMappings
 }
 /** Standard composed error shape for Postgres executors. */
 export type PostgresExecutorError = PostgresDriverError | RowDecodeError
@@ -55,12 +57,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 = <
@@ -138,7 +183,7 @@ export function make(
   options: {
     readonly renderer?: Renderer
     readonly driverMode?: CoreExecutor.DriverMode
-    readonly valueMappings?: Expression.DriverValueMappings
+    readonly valueMappings?: ValueMappings
   }
 ): QueryExecutor<SqlClient.SqlClient>
 export function make<Error = never, Context = never>(
@@ -146,7 +191,7 @@ export function make<Error = never, Context = never>(
     readonly renderer?: Renderer
     readonly driver: Driver<Error, Context>
     readonly driverMode?: CoreExecutor.DriverMode
-    readonly valueMappings?: Expression.DriverValueMappings
+    readonly valueMappings?: ValueMappings
   }
 ): QueryExecutor<Context>
 export function make<Error = never, Context = never>(
@@ -154,14 +199,14 @@ export function make<Error = never, Context = never>(
 ): QueryExecutor<any> {
   if (options.driver) {
     return fromDriver(
-      options.renderer ?? CoreRenderer.make("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options.valueMappings })),
+      options.renderer ?? CoreRenderer.makeTrusted("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options.valueMappings })),
       options.driver,
       options.driverMode,
       options.valueMappings
     )
   }
   return fromDriver(
-    options.renderer ?? CoreRenderer.make("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options.valueMappings })),
+    options.renderer ?? CoreRenderer.makeTrusted("postgres", (plan) => renderPostgresPlan(plan, { valueMappings: options.valueMappings })),
     sqlClientDriver(),
     options.driverMode,
     options.valueMappings

package/src/postgres/function/core.ts

@@ -1,8 +1,6 @@
 import type { ExpressionInput } from "../query.js"
 import {
-  call,
   cast,
-  coalesce,
   literal,
   nextVal as nextValInternal,
   type as postgresType,
@@ -11,12 +9,30 @@ import {
 import { isSequenceDefinition, type SequenceDefinition } from "../schema-management.js"
 
 /** Postgres scalar core functions. */
-export { coalesce, call, uuidGenerateV4 }
+export { 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/function/index.ts

@@ -1,19 +1,3 @@
 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 * as temporal from "./temporal.js"
 
-export { coalesce } from "./core.js"
-export { call, uuidGenerateV4, nextVal } from "./core.js"
-export { lower, upper, concat } from "./string.js"
-export { count, max, min } from "./aggregate.js"
-export { over, rowNumber, rank, denseRank } from "./window.js"
-export {
-  currentDate,
-  currentTime,
-  currentTimestamp,
-  localTime,
-  localTimestamp,
-  now
-} from "./temporal.js"
+export { uuidGenerateV4, nextVal } from "./core.js"

package/src/postgres/internal/dialect.ts

@@ -1,7 +1,9 @@
-import type { RenderState, RenderValueContext, SqlDialect } from "../../internal/dialect.js"
+import { quoteDoubleQuotedIdentifier, type RenderState, type RenderValueContext, type SqlDialect } from "../../internal/dialect.js"
+import { renderExpression, renderQueryAst } from "../../internal/dialect-renderers/postgres.js"
 import { toDriverValue } from "../../internal/runtime/driver-value-mapping.js"
+import { standardDialect } from "../../standard/dialect.js"
 
-const quoteIdentifier = (value: string): string => `"${value.replaceAll("\"", "\"\"")}"`
+const quoteIdentifier = quoteDoubleQuotedIdentifier
 
 const renderLiteral = (value: unknown, state: RenderState, context: RenderValueContext = {}): string => {
   const driverValue = toDriverValue(value, {
@@ -23,11 +25,12 @@ const renderLiteral = (value: unknown, state: RenderState, context: RenderValueC
  * Built-in runtime dialect implementation for Postgres.
  */
 export const postgresDialect: SqlDialect<"postgres"> = {
+  ...standardDialect,
   name: "postgres",
   quoteIdentifier,
   renderLiteral,
   renderTableReference(tableName, baseTableName, schemaName) {
-    const renderedBase = schemaName
+    const renderedBase = schemaName && schemaName !== "public"
       ? `${quoteIdentifier(schemaName)}.${quoteIdentifier(baseTableName)}`
       : quoteIdentifier(baseTableName)
     return tableName === baseTableName
@@ -36,5 +39,7 @@ export const postgresDialect: SqlDialect<"postgres"> = {
   },
   renderConcat(values) {
     return `(${values.join(" || ")})`
-  }
+  },
+  renderQueryAst,
+  renderExpression
 }