effect-qb 0.14.0 → 0.16.0

package/src/postgres/schema-expression.ts

@@ -1,6 +1,7 @@
 export {
   TypeId,
   fromAst,
+  fromSql,
   isSchemaExpression,
   normalize,
   parseExpression,
@@ -13,4 +14,4 @@ export {
 export {
   normalizeDdlExpressionSql,
   renderDdlExpressionSql
-} from "../internal/schema-ddl.js"
+} from "./internal/schema-ddl.js"

package/src/postgres/schema-management.ts

@@ -1,7 +1,7 @@
 import * as Schema from "effect/Schema"
 import { pipeArguments, type Pipeable } from "effect/Pipeable"
 
-import type * as Expression from "../internal/expression.js"
+import type * as Expression from "../internal/scalar.js"
 import { makeColumnDefinition, type ColumnDefinition } from "../internal/column-state.js"
 
 export const EnumTypeId: unique symbol = Symbol.for("effect-qb/SchemaManagement/Enum")

package/src/postgres/table.ts

@@ -1,6 +1,6 @@
 import type * as Schema from "effect/Schema"
 
-import type * as Expression from "../internal/expression.js"
+import type * as Expression from "../internal/scalar.js"
 import { ColumnTypeId, type AnyColumnDefinition } from "../internal/column-state.js"
 import * as BaseTable from "../internal/table.js"
 
@@ -144,11 +144,15 @@ type RichIndexKeyInput =
       readonly column: string
       readonly order?: "asc" | "desc"
       readonly nulls?: "first" | "last"
+      readonly operatorClass?: string
+      readonly collation?: string
     }
   | {
       readonly expression: DdlExpressionLike
       readonly order?: "asc" | "desc"
       readonly nulls?: "first" | "last"
+      readonly operatorClass?: string
+      readonly collation?: string
     }
 
 type RichIndexInput<Columns extends string | readonly string[] = string | readonly string[]> = {
@@ -208,17 +212,21 @@ const normalizeIndexKeys = (
   keys: readonly [RichIndexKeyInput, ...RichIndexKeyInput[]]
 ): readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]] =>
   keys.map((key) => "expression" in key
-    ? {
+      ? {
         kind: "expression",
         expression: key.expression,
         order: key.order,
-        nulls: key.nulls
+        nulls: key.nulls,
+        operatorClass: key.operatorClass,
+        collation: key.collation
       }
     : {
         kind: "column",
         column: key.column,
         order: key.order,
-        nulls: key.nulls
+        nulls: key.nulls,
+        operatorClass: key.operatorClass,
+        collation: key.collation
       }) as unknown as readonly [BaseTable.IndexKeySpec, ...BaseTable.IndexKeySpec[]]
 
 export const primaryKey: {

package/src/postgres/type.ts

@@ -1,4 +1,35 @@
-import { postgresQuery } from "./private/query.js"
+import type * as Expression from "../internal/scalar.js"
+import { postgresDatatypes } from "./datatypes/index.js"
+import { type as postgresType } from "./internal/dsl.js"
+
+type PostgresTypeNamespace = typeof postgresDatatypes & {
+  readonly array: <Element extends Expression.DbType.Any>(
+    element: Element
+  ) => Expression.DbType.Array<"postgres", Element, `${Element["kind"]}[]`>
+  readonly range: <Kind extends string, Subtype extends Expression.DbType.Any>(
+    kind: Kind,
+    subtype: Subtype
+  ) => Expression.DbType.Range<"postgres", Subtype, Kind>
+  readonly multirange: <Kind extends string, Subtype extends Expression.DbType.Any>(
+    kind: Kind,
+    subtype: Subtype
+  ) => Expression.DbType.Multirange<"postgres", Subtype, Kind>
+  readonly record: <Kind extends string, Fields extends Record<string, Expression.DbType.Any>>(
+    kind: Kind,
+    fields: Fields
+  ) => Expression.DbType.Composite<"postgres", Fields, Kind>
+  readonly domain: <Kind extends string, Base extends Expression.DbType.Any>(
+    kind: Kind,
+    base: Base
+  ) => Expression.DbType.Domain<"postgres", Base, Kind>
+  readonly enum: <Kind extends string>(kind: Kind) => Expression.DbType.Enum<"postgres", Kind>
+  readonly set: <Kind extends string>(kind: Kind) => Expression.DbType.Set<"postgres", Kind>
+  readonly custom: <Kind extends string>(kind: Kind) => Expression.DbType.Base<"postgres", Kind>
+  readonly driverValueMapping: <Db extends Expression.DbType.Any>(
+    dbType: Db,
+    mapping: Expression.DriverValueMapping
+  ) => Db
+}
 
 /** Postgres database-type constructors for casts and typed column references. */
-export const type = postgresQuery.type
+export const type: PostgresTypeNamespace = postgresType

package/src/postgres.ts

@@ -4,16 +4,18 @@ export * as Column from "./postgres/column.js"
 export * as Datatypes from "./postgres/datatypes/index.js"
 /** Postgres SQLSTATE catalog and error normalization helpers. */
 export * as Errors from "./postgres/errors/index.js"
-/** Shared scalar SQL expression interfaces and DB-type descriptors. */
-export * as Expression from "./internal/expression.js"
+/** Shared scalar SQL interfaces and DB-type descriptors. */
+export * as Scalar from "./internal/scalar.js"
 /** Postgres cast helpers. */
 export { cast as Cast } from "./postgres/cast.js"
 /** Postgres-specialized SQL function expressions. */
 export * as Function from "./postgres/function/index.js"
+/** Postgres-specialized JSON expression helpers. */
+export * as Json from "./postgres/json.js"
 /** Postgres-specialized typed query execution contracts. */
 export * as Executor from "./postgres/executor.js"
-/** Shared logical query-plan interfaces. */
-export * as Plan from "./internal/plan.js"
+/** Shared logical row-set interfaces. */
+export * as RowSet from "./internal/row-set.js"
 /** Postgres-specialized query-construction DSL. */
 export * as Query from "./postgres/query.js"
 /** Postgres database-type constructors for casts and typed references. */

package/src/internal/expression.ts

@@ -1,327 +0,0 @@
-import type { Pipeable } from "effect/Pipeable"
-import type * as Schema from "effect/Schema"
-import type { RuntimeOfDbType as RuntimeOfDbTypeLookup } from "./datatypes/lookup.js"
-
-export type {
-  BigIntString,
-  DecimalString,
-  InstantString,
-  JsonPrimitive,
-  JsonValue,
-  LocalDateString,
-  LocalDateTimeString,
-  LocalTimeString,
-  OffsetTimeString,
-  YearString
-} from "./runtime-value.js"
-
-/** Symbol used to attach expression metadata to runtime values. */
-export const TypeId: unique symbol = Symbol.for("effect-qb/Expression")
-
-export type TypeId = typeof TypeId
-
-/**
- * Bound source provenance for a column-like expression.
- *
- * `tableName` is the logical source identity currently visible to the query
- * layer. For aliased sources this is the alias, while `baseTableName` retains
- * the underlying physical table name for downstream renderer work.
- */
-export interface ColumnSource<
-  TableName extends string = string,
-  ColumnName extends string = string,
-  BaseTableName extends string = TableName
-> {
-  readonly tableName: TableName
-  readonly columnName: ColumnName
-  readonly baseTableName: BaseTableName
-}
-
-/**
- * Three-state nullability lattice.
- *
- * `"never"` means non-null, `"maybe"` means nullable, and `"always"` means the
- * expression is known to be `null`.
- */
-export type Nullability = "never" | "maybe" | "always"
-
-/**
- * High-level classification of an expression.
- *
- * - `scalar`: regular per-row expression
- * - `aggregate`: grouped expression such as `count(*)`
- * - `window`: windowed expression such as `row_number() over (...)`
- */
-export type AggregationKind = "scalar" | "aggregate" | "window"
-
-/**
- * Whether an expression should still be promoted by optional-source scope.
- *
- * Most expressions propagate optional-source nullability because a missing
- * joined row turns their inputs into `null`. Some expressions, such as
- * `coalesce(...)`, `is null`, and aggregates, already model their own
- * null-handling semantics and should not be promoted again by plan scope.
- */
-export type SourceNullabilityMode = "propagate" | "resolved"
-
-/**
- * Phantom dependency map of source names referenced by an expression.
- *
- * This is intentionally separate from runtime provenance (`source`). The
- * dependency map is the cheap, composable type-level representation used by the
- * query layer to resolve scope-sensitive nullability after joins. Dependencies
- * are tracked by logical source identity, which means aliased sources are kept
- * distinct from one another even when they point at the same base table.
- */
-export type SourceDependencies = Record<string, true>
-
-/** Database-type descriptors carried alongside decoded runtime types. */
-export declare namespace DbType {
-  /** Base SQL type descriptor. */
-  export interface Base<Dialect extends string, Kind extends string> {
-    readonly dialect: Dialect
-    readonly kind: Kind
-  }
-
-  /** JSON-like database type. */
-  export interface Json<
-    Dialect extends string = "postgres",
-    SchemaName extends string = "json"
-  > extends Base<Dialect, SchemaName>
-  {
-    readonly variant: SchemaName extends "jsonb" ? "jsonb" : "json"
-  }
-
-  /** Array database type. */
-  export interface Array<
-    Dialect extends string = string,
-    Element extends Any = any,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly element: Element
-  }
-
-  /** Range database type. */
-  export interface Range<
-    Dialect extends string = string,
-    Subtype extends Any = any,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly subtype: Subtype
-  }
-
-  /** Multirange database type. */
-  export interface Multirange<
-    Dialect extends string = string,
-    Subtype extends Any = any,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly subtype: Subtype
-  }
-
-  /** Composite/record database type. */
-  export interface Composite<
-    Dialect extends string = string,
-    Fields extends Record<string, Any> = Record<string, any>,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly fields: Fields
-  }
-
-  /** Named domain database type. */
-  export interface Domain<
-    Dialect extends string = string,
-    BaseType extends Any = any,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly base: BaseType
-  }
-
-  /** Enumeration database type. */
-  export interface Enum<
-    Dialect extends string = string,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly variant: "enum"
-  }
-
-  /** Set database type. */
-  export interface Set<
-    Dialect extends string = string,
-    Kind extends string = string
-  > extends Base<Dialect, Kind> {
-    readonly variant: "set"
-  }
-
-  export type PgUuid = Base<"postgres", "uuid">
-  export type PgText = Base<"postgres", "text">
-  export type PgVarchar = Base<"postgres", "varchar">
-  export type PgChar = Base<"postgres", "char">
-  export type PgCitext = Base<"postgres", "citext">
-  export type PgInt2 = Base<"postgres", "int2">
-  export type PgInt4 = Base<"postgres", "int4">
-  export type PgInt8 = Base<"postgres", "int8">
-  export type PgNumeric = Base<"postgres", "numeric">
-  export type PgFloat4 = Base<"postgres", "float4">
-  export type PgFloat8 = Base<"postgres", "float8">
-  export type PgBool = Base<"postgres", "bool">
-  export type PgDate = Base<"postgres", "date">
-  export type PgTime = Base<"postgres", "time">
-  export type PgTimestamp = Base<"postgres", "timestamp">
-  export type PgTimetz = Base<"postgres", "timetz">
-  export type PgTimestamptz = Base<"postgres", "timestamptz">
-  export type PgInterval = Base<"postgres", "interval">
-  export type PgBytea = Base<"postgres", "bytea">
-  export type PgJsonb = Base<"postgres", "jsonb">
-  export type PgArray<Element extends Any = any> = Array<"postgres", Element, string>
-  export type PgRange<Subtype extends Any = any, Kind extends string = string> = Range<"postgres", Subtype, Kind>
-  export type PgMultirange<Subtype extends Any = any, Kind extends string = string> = Multirange<"postgres", Subtype, Kind>
-  export type PgComposite<Fields extends Record<string, Any> = Record<string, any>, Kind extends string = string> = Composite<"postgres", Fields, Kind>
-  export type PgDomain<BaseType extends Any = any, Kind extends string = string> = Domain<"postgres", BaseType, Kind>
-
-  export type MySqlUuid = Base<"mysql", "uuid">
-  export type MySqlText = Base<"mysql", "text">
-  export type MySqlVarchar = Base<"mysql", "varchar">
-  export type MySqlChar = Base<"mysql", "char">
-  export type MySqlTinyInt = Base<"mysql", "tinyint">
-  export type MySqlSmallInt = Base<"mysql", "smallint">
-  export type MySqlMediumInt = Base<"mysql", "mediumint">
-  export type MySqlInt = Base<"mysql", "int">
-  export type MySqlBigInt = Base<"mysql", "bigint">
-  export type MySqlNumeric = Base<"mysql", "decimal">
-  export type MySqlFloat = Base<"mysql", "float">
-  export type MySqlDouble = Base<"mysql", "double">
-  export type MySqlBool = Base<"mysql", "boolean">
-  export type MySqlDate = Base<"mysql", "date">
-  export type MySqlTime = Base<"mysql", "time">
-  export type MySqlDatetime = Base<"mysql", "datetime">
-  export type MySqlTimestamp = Base<"mysql", "timestamp">
-  export type MySqlBinary = Base<"mysql", "binary">
-  export type MySqlVarBinary = Base<"mysql", "varbinary">
-  export type MySqlBlob = Base<"mysql", "blob">
-  export type MySqlArray<Element extends Any = any> = Array<"mysql", Element, string>
-  export type MySqlComposite<Fields extends Record<string, Any> = Record<string, any>, Kind extends string = string> = Composite<"mysql", Fields, Kind>
-  export type MySqlDomain<BaseType extends Any = any, Kind extends string = string> = Domain<"mysql", BaseType, Kind>
-
-  export type Any =
-    | PgUuid
-    | PgText
-    | PgVarchar
-    | PgChar
-    | PgCitext
-    | PgInt2
-    | PgInt4
-    | PgInt8
-    | PgNumeric
-    | PgFloat4
-    | PgFloat8
-    | PgBool
-    | PgDate
-    | PgTime
-    | PgTimestamp
-    | PgInterval
-    | PgBytea
-    | PgJsonb
-    | PgArray
-    | PgRange
-    | PgMultirange
-    | PgComposite
-    | PgDomain
-    | MySqlUuid
-    | MySqlText
-    | MySqlVarchar
-    | MySqlChar
-    | MySqlTinyInt
-    | MySqlSmallInt
-    | MySqlMediumInt
-    | MySqlInt
-    | MySqlBigInt
-    | MySqlNumeric
-    | MySqlFloat
-    | MySqlDouble
-    | MySqlBool
-    | MySqlDate
-    | MySqlTime
-    | MySqlDatetime
-    | MySqlTimestamp
-    | MySqlBinary
-    | MySqlVarBinary
-    | MySqlBlob
-    | MySqlArray
-    | MySqlComposite
-    | MySqlDomain
-    | Json
-    | Base<string, string>
-    | Array<string, any, string>
-    | Range<string, any, string>
-    | Multirange<string, any, string>
-    | Composite<string, Record<string, any>, string>
-    | Domain<string, any, string>
-    | Enum<string, string>
-    | Set<string, string>
-  }
-
-/** Canonical static metadata stored on an expression. */
-export interface State<
-  Runtime,
-  Db extends DbType.Any,
-  Nullable extends Nullability,
-  Dialect extends string,
-  Aggregation extends AggregationKind,
-  Source = never,
-  Dependencies extends SourceDependencies = {},
-  SourceNullability extends SourceNullabilityMode = "propagate"
-> {
-  readonly runtime: Runtime
-  readonly dbType: Db
-  readonly runtimeSchema?: Schema.Schema.Any
-  readonly nullability: Nullable
-  readonly dialect: Dialect
-  readonly aggregation: Aggregation
-  readonly source: Source
-  readonly sourceNullability: SourceNullability
-  /**
-   * Type-level source dependency map used for lazy nullability resolution.
-   *
-   * Unlike `source`, which preserves runtime provenance detail for diagnostics
-   * and plan assembly, `dependencies` only needs to record which tables are
-   * referenced at all.
-   */
-  readonly dependencies: Dependencies
-}
-
-/**
- * A typed SQL expression.
- *
- * `Runtime` is the decoded TypeScript type while `Db` captures the SQL-level
- * type identity. Both are needed: multiple SQL types may decode to the same
- * runtime type but still have different comparison/cast semantics.
- */
-export interface Expression<
-  Runtime,
-  Db extends DbType.Any,
-  Nullable extends Nullability = "never",
-  Dialect extends string = Db["dialect"],
-  Aggregation extends AggregationKind = "scalar",
-  Source = never,
-  Dependencies extends SourceDependencies = {},
-  SourceNullability extends SourceNullabilityMode = "propagate"
-> extends Pipeable {
-  readonly [TypeId]: State<Runtime, Db, Nullable, Dialect, Aggregation, Source, Dependencies, SourceNullability>
-}
-
-/** Convenience alias for any expression-like value. */
-export type Any = Expression<any, DbType.Any, Nullability, string, AggregationKind, any, SourceDependencies, SourceNullabilityMode>
-/** Extracts an expression's decoded runtime type. */
-export type RuntimeOf<Value extends Any> = Value[typeof TypeId]["runtime"]
-/** Extracts an expression's database-type descriptor. */
-export type DbTypeOf<Value extends Any> = Value[typeof TypeId]["dbType"]
-/** Extracts an expression's nullability state. */
-export type NullabilityOf<Value extends Any> = Value[typeof TypeId]["nullability"]
-/** Extracts an expression's source dependency map. */
-export type DependenciesOf<Value extends Any> = Value[typeof TypeId]["dependencies"]
-/** Extracts how plan-scope nullability should apply to an expression. */
-export type SourceNullabilityOf<Value extends Any> = Value[typeof TypeId]["sourceNullability"]
-
-/** Maps a database type descriptor back to its decoded runtime type. */
-export type RuntimeOfDbType<Db extends DbType.Any> = RuntimeOfDbTypeLookup<Db>

package/src/internal/mysql-renderer.ts

@@ -1,37 +0,0 @@
-import * as Query from "./query.js"
-import { type RenderState } from "./dialect.js"
-import { mysqlDialect } from "./mysql-dialect.js"
-import { type Projection } from "./projections.js"
-import { renderQueryAst } from "./sql-expression-renderer.js"
-
-/**
- * Internal rendered-query payload produced by the built-in MySQL renderer.
- */
-export interface MysqlRenderResult {
-  readonly sql: string
-  readonly params: readonly unknown[]
-  readonly projections: readonly Projection[]
-}
-
-/**
- * Renders the current query AST into MySQL-shaped SQL plus bind parameters.
- */
-export const renderMysqlPlan = <PlanValue extends Query.QueryPlan<any, any, any, any, any, any, any, any, any, any>>(
-  plan: Query.DialectCompatiblePlan<PlanValue, "mysql">
-): MysqlRenderResult => {
-  const state: RenderState = {
-    params: [],
-    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,
-    state,
-    mysqlDialect
-  )
-  return {
-    sql: rendered.sql,
-    params: state.params,
-    projections: rendered.projections
-  }
-}

package/src/internal/predicate-analysis.ts

@@ -1,81 +0,0 @@
-import type { AnalyzeFormula } from "./predicate-context.js"
-import type { FormulaOfPredicate } from "./predicate-normalize.js"
-import type { And, Not, PredicateFormula, TrueFormula } from "./predicate-formula.js"
-
-type ContextOf<Formula extends PredicateFormula> = AnalyzeFormula<Formula>
-
-export type GuaranteedNonNullKeys<
-  Assumptions extends PredicateFormula
-> = ContextOf<Assumptions>["nonNullKeys"]
-
-export type GuaranteedNullKeys<
-  Assumptions extends PredicateFormula
-> = ContextOf<Assumptions>["nullKeys"]
-
-export type GuaranteedSourceNames<
-  Assumptions extends PredicateFormula
-> = ContextOf<Assumptions>["sourceNames"]
-
-export type GuaranteedEqLiteral<
-  Assumptions extends PredicateFormula,
-  Key extends string
-> = Key extends keyof ContextOf<Assumptions>["eqLiterals"]
-  ? ContextOf<Assumptions>["eqLiterals"][Key]
-  : never
-
-type IsContradiction<Formula extends PredicateFormula> =
-  ContextOf<Formula>["contradiction"] extends true ? true : false
-
-type ContradictoryAssumption<
-  Assumptions extends PredicateFormula,
-  Formula extends PredicateFormula
-> = IsContradiction<And<Assumptions, Formula>>
-
-type ContradictionFromNegation<
-  Assumptions extends PredicateFormula,
-  Formula extends PredicateFormula
-> = IsContradiction<And<Assumptions, Not<Formula>>>
-
-export type ContradictsFormula<
-  Assumptions extends PredicateFormula,
-  Formula extends PredicateFormula
-> = ContradictoryAssumption<Assumptions, Formula>
-
-export type ImpliesFormula<
-  Assumptions extends PredicateFormula,
-  Formula extends PredicateFormula
-> = ContradictionFromNegation<Assumptions, Formula>
-
-export type AssumeFormulaTrue<
-  Assumptions extends PredicateFormula,
-  Formula extends PredicateFormula
-> = Assumptions extends TrueFormula
-  ? Formula
-  : And<Assumptions, Formula>
-
-export type AssumeFormulaFalse<
-  Assumptions extends PredicateFormula,
-  Formula extends PredicateFormula
-> = Assumptions extends TrueFormula
-  ? Not<Formula>
-  : And<Assumptions, Not<Formula>>
-
-export type AssumeTrue<
-  Assumptions extends PredicateFormula,
-  Predicate
-> = AssumeFormulaTrue<Assumptions, FormulaOfPredicate<Predicate>>
-
-export type AssumeFalse<
-  Assumptions extends PredicateFormula,
-  Predicate
-> = AssumeFormulaFalse<Assumptions, FormulaOfPredicate<Predicate>>
-
-export type Contradicts<
-  Assumptions extends PredicateFormula,
-  Predicate
-> = ContradictoryAssumption<Assumptions, FormulaOfPredicate<Predicate>>
-
-export type Implies<
-  Assumptions extends PredicateFormula,
-  Predicate
-> = ContradictionFromNegation<Assumptions, FormulaOfPredicate<Predicate>>

package/src/internal/predicate-key.ts

@@ -1,28 +0,0 @@
-import type * as Expression from "./expression.js"
-import type * as ExpressionAst from "./expression-ast.js"
-
-export type ColumnKey<
-  TableName extends string,
-  ColumnName extends string
-> = `${TableName}.${ColumnName}`
-
-export type ColumnKeyOfAst<Ast extends ExpressionAst.Any> =
-  Ast extends ExpressionAst.ColumnNode<infer TableName extends string, infer ColumnName extends string>
-    ? ColumnKey<TableName, ColumnName>
-    : never
-
-type AstOf<Value extends Expression.Any> = Value extends {
-  readonly [ExpressionAst.TypeId]: infer Ast extends ExpressionAst.Any
-} ? Ast : never
-
-export type ColumnKeyOfExpression<Value extends Expression.Any> = ColumnKeyOfAst<AstOf<Value>>
-
-export type LiteralKey<Value> =
-  Value extends string ? `string:${Value}` :
-    Value extends number ? `number:${Value}` :
-      Value extends boolean ? `boolean:${Value}` :
-        Value extends null ? "null" :
-          Value extends Date ? `date:${string}` :
-            "unknown"
-
-export type ValueKey<Value> = LiteralKey<Value>

package/src/internal/schema-ddl.ts

@@ -1,55 +0,0 @@
-import type * as Expression from "./expression.js"
-import type { RenderState, SqlDialect } from "./dialect.js"
-import { postgresDialect } from "./postgres-dialect.js"
-import * as SchemaExpression from "./schema-expression.js"
-import { renderExpression } from "./sql-expression-renderer.js"
-import type { DdlExpressionLike } from "./table-options.js"
-import { parse, toSql } from "pgsql-ast-parser"
-
-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)
-
-export const normalizeDdlExpressionSql = (expression: DdlExpressionLike): string => {
-  const rendered = renderDdlExpressionSql(expression)
-  try {
-    return toSql.expr(parse(rendered, "expr"))
-  } catch {
-    return rendered.trim()
-  }
-}

package/src/mysql/function/json.ts

@@ -1,4 +0,0 @@
-import { mysqlQuery } from "../private/query.js"
-
-/** MySQL JSON expression helpers. */
-export const json = mysqlQuery.json

package/src/mysql/private/query.ts

@@ -1 +0,0 @@
-export { mysqlQuery } from "../../internal/mysql-query.js"

package/src/postgres/private/query.ts

@@ -1 +0,0 @@
-export { postgresQuery } from "../../internal/postgres-query.js"