effect-qb 0.14.0 → 0.16.0

package/src/{internal/postgres-renderer.ts → postgres/internal/renderer.ts}

@@ -1,7 +1,8 @@
-import * as Query from "./query.js"
-import { type RenderState } from "./dialect.js"
-import { postgresDialect } from "./postgres-dialect.js"
-import { type Projection } from "./projections.js"
+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"
 import { renderQueryAst } from "./sql-expression-renderer.js"
 
 /**
@@ -14,27 +15,35 @@ 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.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-  plan: Query.DialectCompatiblePlan<PlanValue, "postgres">
+export const renderPostgresPlan = <PlanValue extends Query.Plan.Any>(
+  plan: Query.DialectCompatiblePlan<PlanValue, "postgres">,
+  options: PostgresRenderOptions = {}
 ): PostgresRenderResult => {
   const state: RenderState = {
     params: [],
+    valueMappings: options.valueMappings,
     ctes: [],
     cteNames: new Set<string>()
   }
   const rendered = renderQueryAst(
-    Query.getAst(plan as Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>) as any,
+    Query.getAst(plan as Query.Plan.Any) as any,
     state,
     postgresDialect
   )
   return {
     sql: rendered.sql,
     params: state.params,
-    projections: rendered.projections
+    projections: rendered.projections,
+    valueMappings: state.valueMappings
   }
 }

package/src/postgres/internal/schema-ddl.ts

@@ -0,0 +1,108 @@
+import type * as Expression from "../../internal/scalar.js"
+import type { RenderState, SqlDialect } from "../../internal/dialect.js"
+import * as SchemaExpression from "../../internal/schema-expression.js"
+import { renderExpression } from "./sql-expression-renderer.js"
+import type { DdlExpressionLike } from "../../internal/table-options.js"
+import { parse, toSql } from "pgsql-ast-parser"
+import { postgresDialect } from "./dialect.js"
+
+export const renderDdlExpression = (
+  expression: DdlExpressionLike,
+  state: RenderState,
+  dialect: SqlDialect
+): string =>
+  SchemaExpression.isSchemaExpression(expression)
+    ? SchemaExpression.render(expression)
+    : renderExpression(expression as Expression.Any, state, dialect)
+
+const escapeString = (value: string): string => `'${value.replaceAll("'", "''")}'`
+
+const inlineLiteralDialect: SqlDialect<"postgres"> = {
+  ...postgresDialect,
+  renderLiteral(value) {
+    if (value === null) {
+      return "null"
+    }
+    if (typeof value === "boolean") {
+      return value ? "true" : "false"
+    }
+    if (typeof value === "number" || typeof value === "bigint") {
+      return String(value)
+    }
+    if (value instanceof Date) {
+      return escapeString(value.toISOString())
+    }
+    return escapeString(String(value))
+  }
+}
+
+export const renderDdlExpressionSql = (expression: DdlExpressionLike): string =>
+  SchemaExpression.isSchemaExpression(expression)
+    ? SchemaExpression.render(expression)
+    : renderExpression(expression as Expression.Any, {
+        params: [],
+        ctes: [],
+        cteNames: new Set()
+      }, inlineLiteralDialect)
+
+const stripRedundantOuterParens = (value: string): string => {
+  let current = value.trim()
+  while (current.startsWith("(") && current.endsWith(")")) {
+    let depth = 0
+    let wrapsWholeExpression = true
+    let inSingleQuote = false
+    let inDoubleQuote = false
+    for (let index = 0; index < current.length; index++) {
+      const char = current[index]!
+      const previous = index > 0 ? current[index - 1] : undefined
+      if (char === "'" && !inDoubleQuote && previous !== "\\") {
+        inSingleQuote = !inSingleQuote
+        continue
+      }
+      if (char === "\"" && !inSingleQuote && previous !== "\\") {
+        inDoubleQuote = !inDoubleQuote
+        continue
+      }
+      if (inSingleQuote || inDoubleQuote) {
+        continue
+      }
+      if (char === "(") {
+        depth += 1
+      } else if (char === ")") {
+        depth -= 1
+        if (depth === 0 && index < current.length - 1) {
+          wrapsWholeExpression = false
+          break
+        }
+      }
+    }
+    if (!wrapsWholeExpression) {
+      break
+    }
+    current = current.slice(1, -1).trim()
+  }
+  return current
+}
+
+const canonicalizeDdlExpressionSql = (value: string): string =>
+  stripRedundantOuterParens(
+    value
+      .trim()
+      .replace(/\s+/g, " ")
+      .replace(/"[^"]+"\./g, "")
+      .replace(/"([A-Za-z_][A-Za-z0-9_]*)"/g, "$1")
+      .replace(/\bCOLLATE\b/g, "collate")
+      .replace(
+        /cast\(((?:'(?:[^']|'')*'|"[^"]+"|[a-zA-Z_][a-zA-Z0-9_]*|\([^()]+\))) as ([^)]+)\)/gi,
+        (_, expression: string, target: string) => `${expression}::${target.trim()}`
+      )
+  )
+
+export const normalizeDdlExpressionSql = (expression: DdlExpressionLike): string => {
+  const rendered = renderDdlExpressionSql(expression)
+  try {
+    return canonicalizeDdlExpressionSql(toSql.expr(parse(rendered, "expr")))
+  } catch {
+    return canonicalizeDdlExpressionSql(rendered)
+  }
+}

package/src/{internal/postgres-schema-model.ts → postgres/internal/schema-model.ts}

@@ -1,9 +1,9 @@
-import * as Table from "./table.js"
-import type { AnyColumnDefinition } from "./column-state.js"
+import * as Table from "../../internal/table.js"
+import type { AnyColumnDefinition } from "../../internal/column-state.js"
 import { normalizeDdlExpressionSql } from "./schema-ddl.js"
-import type { TableOptionSpec } from "./table-options.js"
-import type { EnumDefinition } from "../postgres/schema-management.js"
-import { EnumTypeId } from "../postgres/schema-management.js"
+import type { TableOptionSpec } from "../../internal/table-options.js"
+import type { EnumDefinition } from "../schema-management.js"
+import { EnumTypeId } from "../schema-management.js"
 
 export interface EnumModel {
   readonly kind: "enum"
@@ -88,7 +88,13 @@ export const toTableModel = (table: Table.AnyTable): TableModel => {
   }
 }
 
-export const toEnumModel = (definition: EnumDefinition): EnumModel => ({
+export const toEnumModel = <
+  Name extends string,
+  Values extends readonly [string, ...string[]],
+  SchemaName extends string | undefined
+>(
+  definition: EnumDefinition<Name, Values, SchemaName>
+): EnumModel => ({
   kind: "enum",
   schemaName: definition.schemaName,
   name: definition.name,

package/src/{internal → postgres/internal}/sql-expression-renderer.ts

@@ -1,14 +1,19 @@
-import * as Query from "./query.js"
-import * as Expression from "./expression.js"
-import * as Table from "./table.js"
-import * as QueryAst from "./query-ast.js"
-import type { RenderState, SqlDialect } from "./dialect.js"
-import * as ExpressionAst from "./expression-ast.js"
-import * as JsonPath from "./json/path.js"
-import { flattenSelection, type Projection } from "./projections.js"
-import { type SelectionValue, validateAggregationSelection } from "./aggregation-validation.js"
-import * as SchemaExpression from "./schema-expression.js"
-import type { DdlExpressionLike } from "./table-options.js"
+import * as Query from "../../internal/query.js"
+import * as Expression from "../../internal/scalar.js"
+import * as Table from "../../internal/table.js"
+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"
+import type { DdlExpressionLike } from "../../internal/table-options.js"
 
 const renderDbType = (
   dialect: SqlDialect,
@@ -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
@@ -818,7 +866,7 @@ export const renderQueryAst = (
     case "set": {
       const setAst = ast as QueryAst.Ast<Record<string, unknown>, any, "set">
       const base = renderQueryAst(
-        Query.getAst(setAst.setBase as Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>) as QueryAst.Ast<
+        Query.getAst(setAst.setBase as Query.Plan.Any) as QueryAst.Ast<
           Record<string, unknown>,
           any,
           QueryAst.QueryStatement
@@ -831,7 +879,7 @@ export const renderQueryAst = (
         `(${base.sql})`,
         ...(setAst.setOperations ?? []).map((entry) => {
           const rendered = renderQueryAst(
-            Query.getAst(entry.query as Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>) as QueryAst.Ast<
+            Query.getAst(entry.query as Query.Plan.Any) as QueryAst.Ast<
               Record<string, unknown>,
               any,
               QueryAst.QueryStatement
@@ -858,7 +906,7 @@ export const renderQueryAst = (
       } else if (insertAst.insertSource?.kind === "query") {
         const columns = insertAst.insertSource.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")
         const renderedQuery = renderQueryAst(
-          Query.getAst(insertAst.insertSource.query as Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>) as QueryAst.Ast<
+          Query.getAst(insertAst.insertSource.query as Query.Plan.Any) as QueryAst.Ast<
             Record<string, unknown>,
             any,
             QueryAst.QueryStatement
@@ -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}`
@@ -1151,7 +1203,7 @@ const renderSourceReference = (
   if (typeof source === "object" && source !== null && "kind" in source && (source as { readonly kind?: string }).kind === "cte") {
     const cte = source as unknown as {
       readonly name: string
-      readonly plan: Query.QueryPlan<any, any, any, any, any, any, any, any, any>
+      readonly plan: Query.Plan.Any
       readonly recursive?: boolean
     }
     if (!state.cteNames.has(cte.name)) {
@@ -1168,7 +1220,7 @@ const renderSourceReference = (
   if (typeof source === "object" && source !== null && "kind" in source && (source as { readonly kind?: string }).kind === "derived") {
     const derived = source as unknown as {
       readonly name: string
-      readonly plan: Query.QueryPlan<any, any, any, any, any, any, any, any, any>
+      readonly plan: Query.Plan.Any
     }
     if (!state.cteNames.has(derived.name)) {
       // derived tables are inlined, so no CTE registration is needed
@@ -1178,7 +1230,7 @@ const renderSourceReference = (
   if (typeof source === "object" && source !== null && "kind" in source && (source as { readonly kind?: string }).kind === "lateral") {
     const lateral = source as unknown as {
       readonly name: string
-      readonly plan: Query.QueryPlan<any, any, any, any, any, any, any, any, any>
+      readonly plan: Query.Plan.Any
     }
     return `lateral (${renderQueryAst(Query.getAst(lateral.plan) as QueryAst.Ast<Record<string, unknown>, any, QueryAst.QueryStatement>, state, dialect).sql}) as ${dialect.quoteIdentifier(lateral.name)}`
   }
@@ -1253,13 +1305,15 @@ 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)})`
         : `excluded.${dialect.quoteIdentifier(ast.columnName)}`
     case "cast":
       return `cast(${renderExpression(ast.value, state, dialect)} as ${renderCastType(dialect, ast.target)})`
+    case "collate":
+      return `(${renderExpression(ast.value, state, dialect)} collate ${ast.collation.map((segment) => dialect.quoteIdentifier(segment)).join(".")})`
     case "function":
       return renderFunctionCall(ast.name, Array.isArray(ast.args) ? ast.args : [], state, dialect)
     case "eq":