effect-qb 0.14.0 → 0.15.0

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

@@ -1,7 +1,7 @@
-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 RenderState } from "../../internal/dialect.js"
+import { postgresDialect } from "./dialect.js"
+import { type Projection } from "../../internal/projections.js"
 import { renderQueryAst } from "./sql-expression-renderer.js"
 
 /**
@@ -19,7 +19,7 @@ export interface PostgresRenderResult {
 /**
  * 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>>(
+export const renderPostgresPlan = <PlanValue extends Query.Plan.Any>(
   plan: Query.DialectCompatiblePlan<PlanValue, "postgres">
 ): PostgresRenderResult => {
   const state: RenderState = {
@@ -28,7 +28,7 @@ export const renderPostgresPlan = <PlanValue extends Query.QueryPlan<any, any, a
     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
   )

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,14 @@
-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 { 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,
@@ -818,7 +818,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 +831,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 +858,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
@@ -1151,7 +1151,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 +1168,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 +1178,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)}`
   }
@@ -1260,6 +1260,8 @@ export const renderExpression = (
         : `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":