effect-qb 0.17.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,9 +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>(),
-    cteSources: new Map<string, unknown>()
+    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/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
@@ -65,8 +59,8 @@ export const custom = <SchemaType extends Schema.Schema.Any, Db extends Expressi
   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,
@@ -136,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,
@@ -148,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/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
@@ -181,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>(
@@ -189,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>(
@@ -197,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,7 +9,7 @@ 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_$]*$/
 

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
 }