effect-qb 0.12.3 → 0.14.0

package/src/internal/sql-expression-renderer.ts

@@ -7,6 +7,8 @@ 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"
 
 const renderDbType = (
   dialect: SqlDialect,
@@ -44,35 +46,38 @@ const renderCastType = (
   }
 }
 
+const renderDdlExpression = (
+  expression: DdlExpressionLike,
+  state: RenderState,
+  dialect: SqlDialect
+): string =>
+  SchemaExpression.isSchemaExpression(expression)
+    ? SchemaExpression.render(expression)
+    : renderExpression(expression, state, dialect)
+
 const renderColumnDefinition = (
   dialect: SqlDialect,
+  state: RenderState,
   columnName: string,
   column: Table.AnyTable[typeof Table.TypeId]["fields"][string]
 ): string => {
   const clauses = [
     dialect.quoteIdentifier(columnName),
-    renderDbType(dialect, column.metadata.dbType)
+    column.metadata.ddlType ?? renderDbType(dialect, column.metadata.dbType)
   ]
+  if (column.metadata.identity) {
+    clauses.push(`generated ${column.metadata.identity.generation === "byDefault" ? "by default" : "always"} as identity`)
+  } else if (column.metadata.generatedValue) {
+    clauses.push(`generated always as (${renderDdlExpression(column.metadata.generatedValue, state, dialect)}) stored`)
+  } else if (column.metadata.defaultValue) {
+    clauses.push(`default ${renderDdlExpression(column.metadata.defaultValue, state, dialect)}`)
+  }
   if (!column.metadata.nullable) {
     clauses.push("not null")
   }
   return clauses.join(" ")
 }
 
-const renderCheckPredicate = (
-  predicate: unknown,
-  state: RenderState,
-  dialect: SqlDialect
-): string => {
-  if (typeof predicate === "string") {
-    return predicate
-  }
-  if (predicate !== null && typeof predicate === "object" && Expression.TypeId in predicate) {
-    return renderExpression(predicate as Expression.Any, state, dialect)
-  }
-  throw new Error("Unsupported check constraint predicate for DDL rendering")
-}
-
 const renderCreateTableSql = (
   targetSource: QueryAst.FromClause,
   state: RenderState,
@@ -82,26 +87,26 @@ const renderCreateTableSql = (
   const table = targetSource.source as Table.AnyTable
   const fields = table[Table.TypeId].fields
   const definitions = Object.entries(fields).map(([columnName, column]) =>
-    renderColumnDefinition(dialect, columnName, column)
+    renderColumnDefinition(dialect, state, columnName, column)
   )
   for (const option of table[Table.OptionsSymbol]) {
     switch (option.kind) {
       case "primaryKey":
-        definitions.push(`primary key (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})`)
+        definitions.push(`${option.name ? `constraint ${dialect.quoteIdentifier(option.name)} ` : ""}primary key (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${option.deferrable ? ` deferrable${option.initiallyDeferred ? " initially deferred" : ""}` : ""}`)
         break
       case "unique":
-        definitions.push(`unique (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})`)
+        definitions.push(`${option.name ? `constraint ${dialect.quoteIdentifier(option.name)} ` : ""}unique${option.nullsNotDistinct ? " nulls not distinct" : ""} (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${option.deferrable ? ` deferrable${option.initiallyDeferred ? " initially deferred" : ""}` : ""}`)
         break
       case "foreignKey": {
         const reference = option.references()
         definitions.push(
-          `foreign key (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")}) references ${dialect.renderTableReference(reference.tableName, reference.tableName, reference.schemaName)} (${reference.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})`
+          `${option.name ? `constraint ${dialect.quoteIdentifier(option.name)} ` : ""}foreign key (${option.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")}) references ${dialect.renderTableReference(reference.tableName, reference.tableName, reference.schemaName)} (${reference.columns.map((column) => dialect.quoteIdentifier(column)).join(", ")})${option.onDelete ? ` on delete ${option.onDelete.replace(/[A-Z]/g, (value) => ` ${value.toLowerCase()}`).trim()}` : ""}${option.onUpdate ? ` on update ${option.onUpdate.replace(/[A-Z]/g, (value) => ` ${value.toLowerCase()}`).trim()}` : ""}${option.deferrable ? ` deferrable${option.initiallyDeferred ? " initially deferred" : ""}` : ""}`
         )
         break
       }
       case "check":
         definitions.push(
-          `constraint ${dialect.quoteIdentifier(option.name)} check (${renderCheckPredicate(option.predicate, state, dialect)})`
+          `constraint ${dialect.quoteIdentifier(option.name)} check (${renderDdlExpression(option.predicate, state, dialect)})${option.noInherit ? " no inherit" : ""}`
         )
         break
       case "index":
@@ -258,6 +263,12 @@ const renderPostgresJsonPathArray = (
   }
 }).join(", ")}]`
 
+const renderPostgresTextLiteral = (
+  value: string,
+  state: RenderState,
+  dialect: SqlDialect
+): string => `cast(${dialect.renderLiteral(value, state)} as text)`
+
 const renderPostgresJsonAccessStep = (
   segment: JsonPath.AnySegment,
   textMode: boolean,
@@ -288,6 +299,10 @@ const renderPostgresJsonValue = (
     : `cast(${rendered} as jsonb)`
 }
 
+const renderPostgresJsonKind = (
+  value: Expression.Any
+): "json" | "jsonb" => value[Expression.TypeId].dbType.kind === "jsonb" ? "jsonb" : "json"
+
 const renderJsonOpaquePath = (
   value: unknown,
   state: RenderState,
@@ -305,7 +320,48 @@ const renderJsonOpaquePath = (
   throw new Error("Unsupported SQL/JSON path input")
 }
 
+const renderFunctionCall = (
+  name: string,
+  args: readonly Expression.Any[],
+  state: RenderState,
+  dialect: SqlDialect
+): string => {
+  if (name === "array") {
+    return `ARRAY[${args.map((arg) => renderExpression(arg, state, dialect)).join(", ")}]`
+  }
+  if (name === "extract" && args.length === 2) {
+    const field = args[0]
+    const source = args[1]
+    if (field === undefined) {
+      throw new Error("Unsupported SQL extract expression")
+    }
+    if (source === undefined) {
+      throw new Error("Unsupported SQL extract expression")
+    }
+    const fieldRuntime = isExpression(field) && field[Expression.TypeId].dbType.kind === "text" && typeof field[Expression.TypeId].runtime === "string"
+      ? field[Expression.TypeId].runtime
+      : undefined
+    const renderedField = fieldRuntime ?? renderExpression(field, state, dialect)
+    return `extract(${renderedField} from ${renderExpression(source, state, dialect)})`
+  }
+  const renderedArgs = args.map((arg) => renderExpression(arg, state, dialect)).join(", ")
+  if (args.length === 0) {
+    switch (name) {
+      case "current_date":
+      case "current_time":
+      case "current_timestamp":
+      case "localtime":
+      case "localtimestamp":
+        return name
+      default:
+        return `${name}()`
+    }
+  }
+  return `${name}(${renderedArgs})`
+}
+
 const renderJsonExpression = (
+  expression: Expression.Any,
   ast: Record<string, unknown>,
   state: RenderState,
   dialect: SqlDialect
@@ -318,6 +374,12 @@ const renderJsonExpression = (
   const base = extractJsonBase(ast)
   const segments = extractJsonPathSegments(ast)
   const exact = segments.every((segment) => segment.kind === "key" || segment.kind === "index")
+  const postgresExpressionKind = dialect.name === "postgres" && isJsonExpression(expression)
+    ? renderPostgresJsonKind(expression)
+    : undefined
+  const postgresBaseKind = dialect.name === "postgres" && isJsonExpression(base)
+    ? renderPostgresJsonKind(base)
+    : undefined
 
   switch (kind) {
     case "jsonGet":
@@ -341,7 +403,7 @@ const renderJsonExpression = (
         }
         const jsonPathLiteral = dialect.renderLiteral(renderJsonPathStringLiteral(segments), state)
         const queried = `jsonb_path_query_first(${renderPostgresJsonValue(base, state, dialect)}, ${jsonPathLiteral})`
-        return textMode ? `cast(${queried} as text)` : queried
+        return textMode ? `(${queried} #>> '{}')` : queried
       }
       if (dialect.name === "mysql") {
         const extracted = `json_extract(${baseSql}, ${renderMySqlJsonPath(segments, state, dialect)})`
@@ -365,12 +427,12 @@ const renderJsonExpression = (
       }
       if (dialect.name === "postgres") {
         if (kind === "jsonHasAnyKeys") {
-          return `(${baseSql} ?| ${renderPostgresJsonPathArray(keys, state, dialect)})`
+          return `(${baseSql} ?| array[${keys.map((key) => renderPostgresTextLiteral(String(key), state, dialect)).join(", ")}])`
         }
         if (kind === "jsonHasAllKeys") {
-          return `(${baseSql} ?& ${renderPostgresJsonPathArray(keys, state, dialect)})`
+          return `(${baseSql} ?& array[${keys.map((key) => renderPostgresTextLiteral(String(key), state, dialect)).join(", ")}])`
         }
-        return `(${baseSql} ? ${dialect.renderLiteral(keys[0]!, state)})`
+        return `(${baseSql} ? ${renderPostgresTextLiteral(String(keys[0]!), state, dialect)})`
       }
       if (dialect.name === "mysql") {
         const mode = kind === "jsonHasAllKeys" ? "all" : "one"
@@ -401,7 +463,7 @@ const renderJsonExpression = (
         renderExpression(entry.value, state, dialect)
       ])
       if (dialect.name === "postgres") {
-        return `jsonb_build_object(${renderedEntries.join(", ")})`
+        return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_object(${renderedEntries.join(", ")})`
       }
       if (dialect.name === "mysql") {
         return `json_object(${renderedEntries.join(", ")})`
@@ -414,7 +476,7 @@ const renderJsonExpression = (
         : []
       const renderedValues = values.map((value) => renderExpression(value, state, dialect)).join(", ")
       if (dialect.name === "postgres") {
-        return `jsonb_build_array(${renderedValues})`
+        return `${postgresExpressionKind === "jsonb" ? "jsonb" : "json"}_build_array(${renderedValues})`
       }
       if (dialect.name === "mysql") {
         return `json_array(${renderedValues})`
@@ -448,7 +510,8 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        return `jsonb_typeof(${renderPostgresJsonValue(base, state, dialect)})`
+        const baseSql = renderExpression(base, state, dialect)
+        return `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof(${baseSql})`
       }
       if (dialect.name === "mysql") {
         return `json_type(${renderExpression(base, state, dialect)})`
@@ -459,8 +522,11 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        const jsonb = renderPostgresJsonValue(base, state, dialect)
-        return `(case when jsonb_typeof(${jsonb}) = 'array' then jsonb_array_length(${jsonb}) when jsonb_typeof(${jsonb}) = 'object' then jsonb_object_length(${jsonb}) else null end)`
+        const baseSql = renderExpression(base, state, dialect)
+        const typeOf = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`
+        const arrayLength = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_array_length`
+        const objectKeys = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_object_keys`
+        return `(case when ${typeOf}(${baseSql}) = 'array' then ${arrayLength}(${baseSql}) when ${typeOf}(${baseSql}) = 'object' then (select count(*)::int from ${objectKeys}(${baseSql})) else null end)`
       }
       if (dialect.name === "mysql") {
         return `json_length(${renderExpression(base, state, dialect)})`
@@ -471,8 +537,10 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        const jsonb = renderPostgresJsonValue(base, state, dialect)
-        return `(case when jsonb_typeof(${jsonb}) = 'object' then array(select jsonb_object_keys(${jsonb})) else null end)`
+        const baseSql = renderExpression(base, state, dialect)
+        const typeOf = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_typeof`
+        const objectKeys = `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_object_keys`
+        return `(case when ${typeOf}(${baseSql}) = 'object' then array(select ${objectKeys}(${baseSql})) else null end)`
       }
       if (dialect.name === "mysql") {
         return `json_keys(${renderExpression(base, state, dialect)})`
@@ -483,7 +551,7 @@ const renderJsonExpression = (
         return undefined
       }
       if (dialect.name === "postgres") {
-        return `jsonb_strip_nulls(${renderPostgresJsonValue(base, state, dialect)})`
+        return `${postgresBaseKind === "jsonb" ? "jsonb" : "json"}_strip_nulls(${renderExpression(base, state, dialect)})`
       }
       unsupportedJsonFeature(dialect, "jsonStripNulls")
       return undefined
@@ -1162,7 +1230,7 @@ export const renderExpression = (
   const rawAst = (expression as Expression.Any & {
     readonly [ExpressionAst.TypeId]: ExpressionAst.Any
   })[ExpressionAst.TypeId] as ExpressionAst.Any | Record<string, unknown>
-  const jsonSql = renderJsonExpression(rawAst as Record<string, unknown>, state, dialect)
+  const jsonSql = renderJsonExpression(expression, rawAst as Record<string, unknown>, state, dialect)
   if (jsonSql !== undefined) {
     return jsonSql
   }
@@ -1179,9 +1247,11 @@ export const renderExpression = (
             : operator === "gt"
               ? ">"
               : ">="
-  switch (ast.kind) {
+    switch (ast.kind) {
     case "column":
-      return `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`
+      return ast.tableName.length === 0
+        ? dialect.quoteIdentifier(ast.columnName)
+        : `${dialect.quoteIdentifier(ast.tableName)}.${dialect.quoteIdentifier(ast.columnName)}`
     case "literal":
       return dialect.renderLiteral(ast.value, state)
     case "excluded":
@@ -1190,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 "function":
+      return renderFunctionCall(ast.name, Array.isArray(ast.args) ? ast.args : [], state, dialect)
     case "eq":
       return `(${renderExpression(ast.left, state, dialect)} = ${renderExpression(ast.right, state, dialect)})`
     case "neq":
@@ -1208,6 +1280,22 @@ export const renderExpression = (
       return dialect.name === "postgres"
         ? `(${renderExpression(ast.left, state, dialect)} ilike ${renderExpression(ast.right, state, dialect)})`
         : `(lower(${renderExpression(ast.left, state, dialect)}) like lower(${renderExpression(ast.right, state, dialect)}))`
+    case "regexMatch":
+      return dialect.name === "postgres"
+        ? `(${renderExpression(ast.left, state, dialect)} ~ ${renderExpression(ast.right, state, dialect)})`
+        : `(${renderExpression(ast.left, state, dialect)} regexp ${renderExpression(ast.right, state, dialect)})`
+    case "regexIMatch":
+      return dialect.name === "postgres"
+        ? `(${renderExpression(ast.left, state, dialect)} ~* ${renderExpression(ast.right, state, dialect)})`
+        : `(${renderExpression(ast.left, state, dialect)} regexp ${renderExpression(ast.right, state, dialect)})`
+    case "regexNotMatch":
+      return dialect.name === "postgres"
+        ? `(${renderExpression(ast.left, state, dialect)} !~ ${renderExpression(ast.right, state, dialect)})`
+        : `(${renderExpression(ast.left, state, dialect)} not regexp ${renderExpression(ast.right, state, dialect)})`
+    case "regexNotIMatch":
+      return dialect.name === "postgres"
+        ? `(${renderExpression(ast.left, state, dialect)} !~* ${renderExpression(ast.right, state, dialect)})`
+        : `(${renderExpression(ast.left, state, dialect)} not regexp ${renderExpression(ast.right, state, dialect)})`
     case "isDistinctFrom":
       return dialect.name === "mysql"
         ? `(not (${renderExpression(ast.left, state, dialect)} <=> ${renderExpression(ast.right, state, dialect)}))`

package/src/internal/table-options.ts

@@ -4,39 +4,78 @@ import {
   type AnyColumnDefinition,
   type IsNullable
 } from "./column-state.js"
+import type { Any as AnyExpression } from "./expression.js"
+import type { Any as AnySchemaExpression } from "./schema-expression.js"
 import type { TableFieldMap } from "./schema-derivation.js"
 
 /** Non-empty list of column names. */
 export type ColumnList = readonly [string, ...string[]]
 
+export type DdlExpressionLike = AnyExpression | AnySchemaExpression
+
+export type ReferentialAction = "noAction" | "restrict" | "cascade" | "setNull" | "setDefault"
+
+export type IndexKeySpec =
+  | {
+      readonly kind: "column"
+      readonly column: string
+      readonly order?: "asc" | "desc"
+      readonly nulls?: "first" | "last"
+    }
+  | {
+      readonly kind: "expression"
+      readonly expression: DdlExpressionLike
+      readonly order?: "asc" | "desc"
+      readonly nulls?: "first" | "last"
+    }
+
 /** Normalized table-level option record. */
 export type TableOptionSpec =
   | {
       readonly kind: "index"
-      readonly columns: ColumnList
+      readonly columns?: ColumnList
+      readonly name?: string
+      readonly unique?: boolean
+      readonly method?: string
+      readonly include?: readonly string[]
+      readonly predicate?: DdlExpressionLike
+      readonly keys?: readonly [IndexKeySpec, ...IndexKeySpec[]]
     }
   | {
       readonly kind: "unique"
       readonly columns: ColumnList
+      readonly name?: string
+      readonly nullsNotDistinct?: boolean
+      readonly deferrable?: boolean
+      readonly initiallyDeferred?: boolean
     }
   | {
       readonly kind: "primaryKey"
       readonly columns: ColumnList
+      readonly name?: string
+      readonly deferrable?: boolean
+      readonly initiallyDeferred?: boolean
     }
   | {
       readonly kind: "foreignKey"
       readonly columns: ColumnList
+      readonly name?: string
       readonly references: () => {
         readonly tableName: string
         readonly schemaName?: string
         readonly columns: ColumnList
         readonly knownColumns?: readonly string[]
       }
+      readonly onUpdate?: ReferentialAction
+      readonly onDelete?: ReferentialAction
+      readonly deferrable?: boolean
+      readonly initiallyDeferred?: boolean
     }
   | {
       readonly kind: "check"
       readonly name: string
-      readonly predicate: unknown
+      readonly predicate: DdlExpressionLike
+      readonly noInherit?: boolean
     }
 
 /** Thin wrapper used by the public `Table.*` option builders. */
@@ -108,7 +147,11 @@ export const collectInlineOptions = <Fields extends TableFieldMap>(
     if (column.metadata.unique && !column.metadata.primaryKey) {
       options.push({
         kind: "unique",
-        columns: [columnName]
+        columns: [columnName],
+        name: column.metadata.uniqueConstraint?.name,
+        nullsNotDistinct: column.metadata.uniqueConstraint?.nullsNotDistinct,
+        deferrable: column.metadata.uniqueConstraint?.deferrable,
+        initiallyDeferred: column.metadata.uniqueConstraint?.initiallyDeferred
       })
     }
     if (column.metadata.references) {
@@ -124,7 +167,27 @@ export const collectInlineOptions = <Fields extends TableFieldMap>(
             schemaName: bound.schemaName,
             columns: [bound.columnName]
           }
-        }
+        },
+        name: column.metadata.references.name,
+        onUpdate: column.metadata.references.onUpdate,
+        onDelete: column.metadata.references.onDelete,
+        deferrable: column.metadata.references.deferrable,
+        initiallyDeferred: column.metadata.references.initiallyDeferred
+      })
+    }
+    if (column.metadata.index) {
+      options.push({
+        kind: "index",
+        keys: [{
+          kind: "column",
+          column: columnName,
+          order: column.metadata.index.order,
+          nulls: column.metadata.index.nulls
+        }],
+        name: column.metadata.index.name,
+        method: column.metadata.index.method,
+        include: column.metadata.index.include,
+        predicate: column.metadata.index.predicate
       })
     }
   }
@@ -173,17 +236,20 @@ export const validateOptions = <Fields extends TableFieldMap>(
       case "primaryKey":
       case "unique":
       case "foreignKey": {
-        if (option.columns.length === 0) {
+        const columns = option.kind === "index"
+          ? option.columns ?? []
+          : option.columns
+        if (columns.length === 0 && option.kind !== "index") {
           throw new Error(`Option '${option.kind}' on table '${tableName}' requires at least one column`)
         }
-        for (const column of option.columns) {
+        for (const column of columns) {
           if (!knownColumns.has(column)) {
             throw new Error(`Unknown column '${column}' on table '${tableName}'`)
           }
         }
         if (option.kind === "foreignKey") {
           const reference = option.references()
-          if (reference.columns.length !== option.columns.length) {
+          if (reference.columns.length !== columns.length) {
             throw new Error(`Foreign key on table '${tableName}' must reference the same number of columns`)
           }
           if (reference.knownColumns) {
@@ -195,6 +261,21 @@ export const validateOptions = <Fields extends TableFieldMap>(
             }
           }
         }
+        if (option.kind === "index") {
+          for (const column of option.include ?? []) {
+            if (!knownColumns.has(column)) {
+              throw new Error(`Unknown included column '${column}' on table '${tableName}'`)
+            }
+          }
+          for (const key of option.keys ?? []) {
+            if (key.kind === "column" && !knownColumns.has(key.column)) {
+              throw new Error(`Unknown index key column '${key.column}' on table '${tableName}'`)
+            }
+          }
+          if (option.columns === undefined && (option.keys === undefined || option.keys.length === 0)) {
+            throw new Error(`Index on table '${tableName}' requires at least one column or key`)
+          }
+        }
         break
       }
       case "check": {