effect-qb 4.0.0-beta.66 → 4.0.0-beta.92

package/src/postgres/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 { postgresDialect } 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"
 
 /**
  * Minimal rendered-query payload produced by the built-in Postgres renderer.
@@ -20,6 +21,7 @@ export interface PostgresRenderResult {
 
 export interface PostgresRenderOptions {
   readonly valueMappings?: Expression.DriverValueMappings
+  readonly casing?: Casing.Options
 }
 
 /**
@@ -32,9 +34,11 @@ export const renderPostgresPlan = <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/postgres/internal/schema-ddl.ts

@@ -1,7 +1,7 @@
 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 { renderExpression } from "../../internal/sql-expression-renderer.js"
 import type { DdlExpressionLike } from "../../internal/table-options.js"
 import { parse, toSql } from "pgsql-ast-parser"
 import { postgresDialect } from "./dialect.js"
@@ -30,21 +30,30 @@ const inlineLiteralDialect: SqlDialect<"postgres"> = {
       return String(value)
     }
     if (value instanceof Date) {
+      if (Number.isNaN(value.getTime())) {
+        throw new Error("Expected a valid Date value")
+      }
       return escapeString(value.toISOString())
     }
     return escapeString(String(value))
   }
 }
 
-export const renderDdlExpressionSql = (expression: DdlExpressionLike): string =>
+const makeExpressionState = (state: Partial<RenderState> = {}): RenderState => ({
+  ...state,
+  params: [],
+  ctes: [],
+  cteNames: new Set(),
+  cteSources: new Map()
+})
+
+export const renderDdlExpressionSql = (
+  expression: DdlExpressionLike,
+  state?: Partial<RenderState>
+): string =>
   SchemaExpression.isSchemaExpression(expression)
     ? SchemaExpression.render(expression)
-    : renderExpression(expression as Expression.Any, {
-        params: [],
-        ctes: [],
-        cteNames: new Set(),
-        cteSources: new Map()
-      }, inlineLiteralDialect)
+    : renderExpression(expression as Expression.Any, makeExpressionState(state), inlineLiteralDialect)
 
 const stripRedundantOuterParens = (value: string): string => {
   let current = value.trim()
@@ -99,8 +108,11 @@ const canonicalizeDdlExpressionSql = (value: string): string =>
       )
   )
 
-export const normalizeDdlExpressionSql = (expression: DdlExpressionLike): string => {
-  const rendered = renderDdlExpressionSql(expression)
+export const normalizeDdlExpressionSql = (
+  expression: DdlExpressionLike,
+  state?: Partial<RenderState>
+): string => {
+  const rendered = renderDdlExpressionSql(expression, state)
   try {
     return canonicalizeDdlExpressionSql(toSql.expr(parse(rendered, "expr")))
   } catch {

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

@@ -1,7 +1,11 @@
 import * as Table from "../../internal/table.js"
 import type { AnyColumnDefinition } from "../../internal/column-state.js"
+import type { RenderState } from "../../internal/dialect.js"
+import * as Casing from "../../internal/casing.js"
+import * as Expression from "../../internal/scalar.js"
+import * as SchemaExpression from "../../internal/schema-expression.js"
 import { normalizeDdlExpressionSql } from "./schema-ddl.js"
-import type { TableOptionSpec } from "../../internal/table-options.js"
+import { validateOptions, type ColumnList, type DdlExpressionLike, type IndexKeySpec, type TableOptionSpec } from "../../internal/table-options.js"
 import type { EnumDefinition } from "../schema-management.js"
 import { EnumTypeId } from "../schema-management.js"
 
@@ -52,15 +56,238 @@ export const isTableDefinition = (value: unknown): value is Table.AnyTable =>
 export const isEnumDefinition = (value: unknown): value is EnumDefinition =>
   typeof value === "object" && value !== null && EnumTypeId in value
 
+const applyCasing = (
+  casing: Casing.Options | undefined,
+  category: Casing.Category,
+  name: string
+): string =>
+  Casing.applyCategory(casing, category, name)
+
+const mapColumnList = (
+  columns: ColumnList,
+  casing: Casing.Options | undefined
+): ColumnList =>
+  !Array.isArray(columns)
+    ? columns
+    : columns.length === 0
+      ? columns
+      : [
+          mapCasedValue(columns[0], casing, "columns"),
+          ...columns.slice(1).map((column) => mapCasedValue(column, casing, "columns"))
+        ] as ColumnList
+
+const expressionStateForTable = (
+  state: Table.AnyTable[typeof Table.TypeId],
+  tableName: string,
+  columns: ReadonlyMap<string, string>,
+  casing: Casing.Options | undefined
+): Partial<RenderState> => ({
+  casing,
+  rowLocalColumns: true,
+  sourceNames: new Map([
+    [state.name, { tableName, columns }],
+    [state.baseName, { tableName, columns }]
+  ])
+})
+
+const mapDdlExpression = (
+  expression: DdlExpressionLike,
+  state: Partial<RenderState>
+): SchemaExpression.SchemaExpression =>
+  SchemaExpression.fromSql(normalizeDdlExpressionSql(expression, state))
+
+function mapOptionName(
+  name: string,
+  casing: Casing.Options | undefined,
+  category: "indexes" | "constraints"
+): string
+function mapOptionName(
+  name: unknown,
+  casing: Casing.Options | undefined,
+  category: "indexes" | "constraints"
+): unknown
+function mapOptionName(
+  name: unknown,
+  casing: Casing.Options | undefined,
+  category: "indexes" | "constraints"
+): unknown {
+  return typeof name === "string"
+    ? applyCasing(casing, category, name)
+    : name
+}
+
+function mapCasedValue(
+  value: string,
+  casing: Casing.Options | undefined,
+  category: Casing.Category
+): string
+function mapCasedValue(
+  value: unknown,
+  casing: Casing.Options | undefined,
+  category: Casing.Category
+): unknown
+function mapCasedValue(
+  value: unknown,
+  casing: Casing.Options | undefined,
+  category: Casing.Category
+): unknown {
+  return typeof value === "string"
+    ? applyCasing(casing, category, value)
+    : value
+}
+
+const isDdlExpressionLike = (value: unknown): value is DdlExpressionLike =>
+  typeof value === "object" &&
+  value !== null &&
+  (Expression.TypeId in value || SchemaExpression.TypeId in value)
+
+function mapIndexKey(
+  key: IndexKeySpec,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): IndexKeySpec
+function mapIndexKey(
+  key: unknown,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): unknown
+function mapIndexKey(
+  key: unknown,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): unknown {
+  if (typeof key !== "object" || key === null || !("kind" in key)) {
+    return key
+  }
+  const kind = (key as { readonly kind?: unknown }).kind
+  if (kind === "column") {
+    const column = (key as { readonly column?: unknown }).column
+    return typeof column === "string"
+      ? {
+          ...key,
+          column: applyCasing(casing, "columns", column)
+        }
+      : key
+  }
+  if (kind === "expression") {
+    const expression = (key as { readonly expression?: unknown }).expression
+    return isDdlExpressionLike(expression)
+      ? {
+          ...key,
+          expression: mapDdlExpression(expression, expressionState)
+        }
+      : key
+  }
+  return key
+}
+
+const mapOption = (
+  option: TableOptionSpec,
+  casing: Casing.Options | undefined,
+  expressionState: Partial<RenderState>
+): TableOptionSpec => {
+  switch (option.kind) {
+    case "index":
+      return {
+        ...option,
+        columns: option.columns === undefined ? undefined : mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "indexes"),
+        include: option.include === undefined
+          ? undefined
+          : Array.isArray(option.include)
+            ? option.include.map((column) => mapCasedValue(column, casing, "columns")) as unknown as readonly string[]
+            : option.include,
+        predicate: option.predicate === undefined
+          ? undefined
+          : isDdlExpressionLike(option.predicate)
+            ? mapDdlExpression(option.predicate, expressionState)
+            : option.predicate,
+        keys: option.keys === undefined
+          ? undefined
+          : Array.isArray(option.keys)
+            ? option.keys.length === 0
+              ? option.keys
+              : [
+                  mapIndexKey(option.keys[0], casing, expressionState),
+                  ...option.keys.slice(1).map((key) => mapIndexKey(key, casing, expressionState))
+                ] as unknown as readonly [IndexKeySpec, ...IndexKeySpec[]]
+            : option.keys
+      }
+    case "primaryKey":
+      return {
+        ...option,
+        columns: mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "constraints")
+      }
+    case "unique":
+      return {
+        ...option,
+        columns: mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "constraints")
+      }
+    case "foreignKey":
+      return {
+        ...option,
+        columns: mapColumnList(option.columns, casing),
+        name: option.name === undefined ? undefined : mapOptionName(option.name, casing, "constraints"),
+        references: () => {
+          const reference = typeof option.references === "function"
+            ? option.references()
+            : option.references
+          if (typeof reference !== "object" || reference === null) {
+            return reference
+          }
+          const referenceCasing = reference.casing
+          return {
+            ...reference,
+            tableName: mapCasedValue(reference.tableName, referenceCasing, "tables"),
+            schemaName: reference.schemaName === undefined
+              ? undefined
+              : mapCasedValue(reference.schemaName, referenceCasing, "schemas"),
+            columns: mapColumnList(reference.columns, referenceCasing),
+            knownColumns: reference.knownColumns === undefined
+              ? undefined
+              : Array.isArray(reference.knownColumns)
+                ? reference.knownColumns.map((column) =>
+                  mapCasedValue(column, referenceCasing, "columns")) as unknown as readonly string[]
+                : reference.knownColumns
+          }
+        }
+      }
+    case "check":
+      return {
+        ...option,
+        name: mapOptionName(option.name, casing, "constraints"),
+        predicate: isDdlExpressionLike(option.predicate)
+          ? mapDdlExpression(option.predicate, expressionState)
+          : option.predicate
+      }
+    default:
+      return option
+  }
+}
+
 export const toTableModel = (table: Table.AnyTable): TableModel => {
   const state = table[Table.TypeId]
+  const casing = state.casing
+  const tableName = applyCasing(casing, "tables", state.baseName)
+  const schemaName = state.schemaName === undefined
+    ? undefined
+    : applyCasing(casing, "schemas", state.schemaName)
   const fields = state.fields as Record<string, AnyColumnDefinition>
+  const options = table[Table.OptionsSymbol] as unknown
+  const normalizedOptions = (Array.isArray(options) ? options : [options]) as readonly TableOptionSpec[]
+  validateOptions(state.name, fields, normalizedOptions)
+  const columnNames = new Map(
+    Object.keys(fields).map((name) => [name, applyCasing(casing, "columns", name)] as const)
+  )
+  const expressionState = expressionStateForTable(state, tableName, columnNames, casing)
   const columns = Object.entries(fields).map(([name, column]) => {
     const metadata = column.metadata
     const enumDefinition = metadata.enum
     const ddlType = metadata.ddlType ?? metadata.dbType.kind
     return {
-      name,
+      name: columnNames.get(name) ?? name,
       ddlType,
       dbTypeKind: enumDefinition?.name ?? column.metadata.dbType.kind,
       typeKind: enumDefinition === undefined ? undefined : "e",
@@ -70,20 +297,24 @@ export const toTableModel = (table: Table.AnyTable): TableModel => {
       generated: column.metadata.generated,
       defaultSql: column.metadata.defaultValue === undefined
         ? undefined
-        : normalizeDdlExpressionSql(column.metadata.defaultValue),
+        : normalizeDdlExpressionSql(column.metadata.defaultValue, expressionState),
       generatedSql: column.metadata.generatedValue === undefined
         ? undefined
-        : normalizeDdlExpressionSql(column.metadata.generatedValue),
+        : normalizeDdlExpressionSql(column.metadata.generatedValue, expressionState),
       identity: column.metadata.identity,
       column
     }
   }) satisfies ReadonlyArray<ColumnModel>
   return {
     kind: "table",
-    schemaName: state.schemaName,
-    name: state.baseName,
+    schemaName,
+    name: tableName,
     columns,
-    options: table[Table.OptionsSymbol],
+    options: normalizedOptions.map((option) =>
+      typeof option === "object" && option !== null && "kind" in option
+        ? mapOption(option, casing, expressionState)
+        : option as TableOptionSpec
+    ),
     table
   }
 }

package/src/postgres/json-extension.ts

@@ -0,0 +1,7 @@
+import { json } from "./json.js"
+
+/** Removes null object fields using Postgres json/jsonb strip-null functions. */
+export const stripNulls = json.stripNulls
+
+/** Evaluates a Postgres SQL/JSON path predicate with the @@ operator. */
+export const pathMatch = json.pathMatch