effect-qb 0.19.0 → 0.20.0

package/src/standard/primary-key.ts

@@ -0,0 +1,17 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type PrimaryKeySpec = Extract<TableOptionSpec, { readonly kind: "primaryKey" }>
+
+export const make = BaseTable.primaryKey
+
+export const named = <const Name extends string>(
+  name: BaseTable.NonEmptyStringInput<Name>
+) =>
+  <Spec extends PrimaryKeySpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      name
+    } as Spec & { readonly name: Name }))

package/src/standard/renderer.ts

@@ -1,5 +1,7 @@
+import { pipeArguments, type Pipeable } from "effect/Pipeable"
+
 import * as CoreRenderer from "../internal/renderer.js"
-import type * as Casing from "../internal/casing.js"
+import * as Casing from "../internal/casing.js"
 import type * as Expression from "../internal/scalar.js"
 import type { StandardDatatypeFamily, StandardDatatypeKind } from "./datatypes/spec.js"
 import { renderStandardPlan } from "./internal/renderer.js"
@@ -8,14 +10,40 @@ export type RenderedQuery<Row> = CoreRenderer.RenderedQuery<Row, "standard">
 
 export type RowOf<Value extends RenderedQuery<any>> = CoreRenderer.RowOf<Value>
 
-export type Renderer = CoreRenderer.Renderer<"standard">
+export type Renderer = CoreRenderer.Renderer<"standard"> & Pipeable & {
+  readonly [Casing.TypeId]: Casing.State
+  readonly withCasing: (options: Casing.Options) => Renderer
+}
 
 export type ValueMappings = Expression.DriverValueMappingsFor<StandardDatatypeKind | "uuid", StandardDatatypeFamily | "uuid">
 
 export interface MakeOptions {
   readonly valueMappings?: ValueMappings
+}
+
+interface RendererState extends MakeOptions {
   readonly casing?: Casing.Options
 }
 
+const RendererProto = {
+  pipe(this: Pipeable) {
+    return pipeArguments(this, arguments)
+  }
+}
+
+const makeWithState = (state: RendererState = {}): Renderer => {
+  const renderer = CoreRenderer.makeTrusted("standard", (plan) => renderStandardPlan(plan, state))
+  return Object.assign(Object.create(RendererProto), renderer, {
+    [Casing.TypeId]: {
+      casing: state.casing
+    },
+    withCasing: (override: Casing.Options) =>
+      makeWithState({
+        ...state,
+        casing: Casing.merge(state.casing, override)
+      })
+  }) as Renderer
+}
+
 export const make = (options: MakeOptions = {}): Renderer =>
-  CoreRenderer.makeTrusted("standard", (plan) => renderStandardPlan(plan, options))
+  makeWithState({ valueMappings: options.valueMappings })

package/src/standard/table.ts

@@ -16,15 +16,28 @@ export type TableDefinition<
   Fields extends DialectFieldMap,
   PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
   Kind extends "schema" | "alias" = "schema",
-  SchemaName extends string = "public"
-> = BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>
+  SchemaName extends string = "public",
+  ConflictArbiters extends BaseTable.ConflictArbiter = BaseTable.TableDefinition<
+    Name,
+    Fields,
+    PrimaryKeyColumns,
+    Kind,
+    SchemaName
+  >[typeof BaseTable.TypeId]["conflictArbiters"][number]
+> = BaseTable.TableDefinition<Name, Fields, PrimaryKeyColumns, Kind, SchemaName, ConflictArbiters>
 
 export type TableClassStatic<
   Name extends string,
   Fields extends DialectFieldMap,
   PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>,
-  SchemaName extends string = "public"
-> = BaseTable.TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName>
+  SchemaName extends string = "public",
+  ConflictArbiters extends BaseTable.ConflictArbiter = BaseTable.TableClassStatic<
+    Name,
+    Fields,
+    PrimaryKeyColumns,
+    SchemaName
+  >[typeof BaseTable.TypeId]["conflictArbiters"][number]
+> = BaseTable.TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName, ConflictArbiters>
 
 export type AnyTable = BaseTable.AnyTable<Dialect>
 
@@ -37,6 +50,8 @@ type PrimaryKeyOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTabl
 type SchemaNameOfTable<Table extends BaseTable.AnyTable> =
   Table[typeof BaseTable.TypeId]["schemaName"] extends infer SchemaName extends string ? SchemaName : "public"
 
+type ConflictArbiterOfTable<Table extends BaseTable.AnyTable> = Table[typeof BaseTable.TypeId]["conflictArbiters"][number]
+
 export type TableOption = BaseTable.TableOption
 
 export const TypeId = BaseTable.TypeId
@@ -64,7 +79,7 @@ export function make(
   name: string,
   fields: DialectFieldMap,
   schemaName?: string
-): TableDefinition<string, DialectFieldMap, string, "schema", string> {
+): any {
   return arguments.length >= 3
     ? BaseTable.make(name, fields, schemaName as string) as TableDefinition<string, DialectFieldMap, string, "schema", string>
     : BaseTable.make(name, fields) as TableDefinition<string, DialectFieldMap, string, "schema", string>
@@ -81,14 +96,16 @@ export const alias = <
   FieldsOfTable<Table>,
   PrimaryKeyOfTable<Table>,
   "alias",
-  SchemaNameOfTable<Table>
+  SchemaNameOfTable<Table>,
+  ConflictArbiterOfTable<Table>
 > =>
   BaseTable.alias(table as any, aliasName) as TableDefinition<
     AliasName,
     FieldsOfTable<Table>,
     PrimaryKeyOfTable<Table>,
     "alias",
-    SchemaNameOfTable<Table>
+    SchemaNameOfTable<Table>,
+    ConflictArbiterOfTable<Table>
   >
 
 type ClassApi = {
@@ -121,20 +138,7 @@ export const Class: ClassApi = ((
 export const primaryKey = BaseTable.primaryKey
 export const unique = BaseTable.unique
 export const index = BaseTable.index
-export const foreignKey = <
-  LocalColumns extends string | readonly string[],
-  TargetTable extends AnyTable,
-  TargetColumns extends string | readonly string[]
->(
-  columns: LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
-  target: () => TargetTable,
-  referencedColumns: TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
-) =>
-  BaseTable.foreignKey<LocalColumns, TargetTable, TargetColumns>(
-    columns as LocalColumns & BaseTable.NonEmptyColumnInput<LocalColumns>,
-    target,
-    referencedColumns as TargetColumns & BaseTable.NonEmptyColumnInput<TargetColumns> & BaseTable.MatchingColumnArityInput<LocalColumns, TargetColumns>
-  )
+export const foreignKey = BaseTable.foreignKey
 
 export const check = BaseTable.check
 

package/src/standard/unique.ts

@@ -0,0 +1,17 @@
+import * as BaseTable from "../internal/table.js"
+import type { TableOptionSpec } from "../internal/table-options.js"
+
+type UniqueSpec = Extract<TableOptionSpec, { readonly kind: "unique" }>
+
+export const make = BaseTable.unique
+
+export const named = <const Name extends string>(
+  name: BaseTable.NonEmptyStringInput<Name>
+) =>
+  <Spec extends UniqueSpec, TableContext extends BaseTable.TableDefinition<any, any, any, "schema", any>>(
+    option: BaseTable.TableOption<Spec, TableContext>
+  ): BaseTable.TableOption<Spec & { readonly name: Name }, TableContext> =>
+    BaseTable.mapOption(option, (spec) => ({
+      ...spec,
+      name
+    } as Spec & { readonly name: Name }))

package/src/standard.ts

@@ -1,11 +1,15 @@
 /** Standard SQL column-definition DSL. */
 export * as Column from "./standard/column.js"
+/** Standard SQL cast helpers. */
+export * as Cast from "./standard/cast.js"
 /** Standard SQL datatype witnesses and coercion families. */
 export * as Datatypes from "./standard/datatypes/index.js"
 /** Shared scalar SQL interfaces and DB-type descriptors. */
 export * as Scalar from "./internal/scalar.js"
 /** Standard SQL function expressions. */
 export * as Function from "./standard/function/index.js"
+/** Standard SQL JSON expression helpers and path segments. */
+export * as Json from "./standard/json.js"
 /** Standard SQL typed query execution contracts. */
 export * as Executor from "./internal/executor.js"
 /** Shared logical row-set interfaces. */
@@ -14,5 +18,15 @@ export * as RowSet from "./internal/row-set.js"
 export * as Query from "./standard/query.js"
 /** Standard SQL table-definition DSL. */
 export * as Table from "./standard/table.js"
+/** Standard SQL table-level primary-key options. */
+export * as PrimaryKey from "./standard/primary-key.js"
+/** Standard SQL table-level unique-constraint options. */
+export * as Unique from "./standard/unique.js"
+/** Standard SQL table-level index options. */
+export * as Index from "./standard/index.js"
+/** Standard SQL table-level foreign-key options. */
+export * as ForeignKey from "./standard/foreign-key.js"
+/** Standard SQL table-level check-constraint options. */
+export * as Check from "./standard/check.js"
 /** Standard SQL built-in renderer entrypoint. */
 export * as Renderer from "./standard/renderer.js"

package/src/internal/table.d.ts

@@ -1,174 +0,0 @@
-import { type Pipeable } from "effect/Pipeable";
-import * as Schema from "effect/Schema";
-import * as Plan from "./row-set.js";
-import type { TrueFormula } from "./predicate/formula.js";
-import type { BoundColumnFrom } from "./column-state.js";
-import { type DdlExpressionLike, type NonEmptyStringInput, type NormalizeColumns, type TableOptionSpec, type ValidateKnownColumns, type ValidatePrimaryKeyColumns } from "./table-options.js";
-import { type InsertRow, type SelectRow, type TableFieldMap, type UpdateRow } from "./schema-derivation.js";
-/** Symbol used to attach table-definition metadata. */
-export declare const TypeId: unique symbol;
-/** Symbol for the normalized table option list. */
-export declare const OptionsSymbol: unique symbol;
-/** Symbol used by `Table.Class` to declare table-level options. */
-export declare const options: unique symbol;
-declare const DeclaredOptionsSymbol: unique symbol;
-type InlinePrimaryKeyKeys<Fields extends TableFieldMap> = Extract<{
-    [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never;
-}[keyof Fields], string>;
-type TableDialect<Fields extends TableFieldMap> = Fields[keyof Fields][typeof import("./column-state.js").ColumnTypeId]["dbType"]["dialect"];
-type TableKind = "schema" | "alias";
-type DefaultSchemaName = "public";
-type ClassOptionSpec = Exclude<TableOptionSpec, {
-    readonly kind: "primaryKey";
-}>;
-interface TableOptionBuilderLike<Spec extends TableOptionSpec = TableOptionSpec> {
-    (table: TableDefinition<any, any, any, "schema", any>): TableDefinition<any, any, any, "schema", any>;
-    readonly option: Spec;
-}
-type ClassTableOption = TableOptionBuilderLike<ClassOptionSpec>;
-type ClassDeclaredTableOptions = readonly ClassTableOption[];
-type BuildPrimaryKey<Table extends TableDefinition<any, any, any, "schema", any>, Spec extends TableOptionSpec> = Spec extends {
-    readonly kind: "primaryKey";
-    readonly columns: infer Columns extends readonly string[];
-} ? Columns[number] & keyof Table[typeof TypeId]["fields"] & string : Table[typeof TypeId]["primaryKey"][number];
-type OptionInputTable<Table extends TableDefinition<any, any, any, "schema", any>, Spec extends TableOptionSpec> = Spec extends {
-    readonly kind: "primaryKey";
-    readonly columns: infer Columns extends readonly string[];
-} ? ValidatePrimaryKeyColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table : Spec extends {
-    readonly columns: infer Columns extends readonly string[];
-} ? ValidateKnownColumns<Table[typeof TypeId]["fields"], Columns> extends never ? never : Table : Table;
-type ApplyOption<Table extends TableDefinition<any, any, any, "schema", any>, Spec extends TableOptionSpec> = Spec extends {
-    readonly kind: "primaryKey";
-} ? TableDefinition<Table[typeof TypeId]["name"], Table[typeof TypeId]["fields"], BuildPrimaryKey<Table, Spec>, "schema"> : TableDefinition<Table[typeof TypeId]["name"], Table[typeof TypeId]["fields"], Table[typeof TypeId]["primaryKey"][number], "schema">;
-export type MissingSelfGeneric = "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`";
-/** Bound columns keyed by field name for a particular table. */
-export type BoundColumns<Name extends string, Fields extends TableFieldMap> = {
-    readonly [K in keyof Fields]: BoundColumnFrom<Fields[K], Name, Extract<K, string>>;
-};
-/** Derived runtime schemas exposed by a table definition. */
-export interface TableSchemas<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string> {
-    readonly select: Schema.Schema<SelectRow<Name, Fields>>;
-    readonly insert: Schema.Schema<InsertRow<Name, Fields>>;
-    readonly update: Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>;
-}
-interface TableState<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string, Kind extends TableKind = "schema", SchemaName extends string | undefined = DefaultSchemaName> {
-    readonly name: Name;
-    readonly baseName: string;
-    readonly schemaName: SchemaName;
-    readonly fields: Fields;
-    readonly primaryKey: readonly PrimaryKeyColumns[];
-    readonly kind: Kind;
-}
-export type DeclaredTableOptions = readonly TableOptionBuilderLike[];
-export type { DdlExpressionLike, IndexKeySpec, NormalizeColumns, ReferentialAction } from "./table-options.js";
-export type NonEmptySchemaNameInput<Value extends string | undefined> = Value extends string ? NonEmptyStringInput<Value> : Value;
-export type TableDefinition<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>, Kind extends TableKind = "schema", SchemaName extends string | undefined = DefaultSchemaName> = Pipeable & {
-    readonly name: Name;
-    readonly columns: BoundColumns<Name, Fields>;
-    readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>;
-    readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, Kind, SchemaName>;
-    readonly [Plan.TypeId]: Plan.State<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
-    readonly [OptionsSymbol]: readonly TableOptionSpec[];
-    readonly [DeclaredOptionsSymbol]: readonly TableOptionSpec[];
-} & BoundColumns<Name, Fields> & Plan.RowSet<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
-/**
- * Static class-based table definition.
- *
- * The class object itself acts as the table definition, exposing static bound
- * columns, derived schemas, and plan metadata.
- */
-export type TableClassStatic<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string = InlinePrimaryKeyKeys<Fields>, SchemaName extends string | undefined = DefaultSchemaName> = (abstract new (...args: any[]) => any) & Pipeable & {
-    readonly columns: BoundColumns<Name, Fields>;
-    readonly schemas: TableSchemas<Name, Fields, PrimaryKeyColumns>;
-    readonly [TypeId]: TableState<Name, Fields, PrimaryKeyColumns, "schema", SchemaName>;
-    readonly [Plan.TypeId]: Plan.State<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
-    readonly [OptionsSymbol]: readonly TableOptionSpec[];
-    readonly [DeclaredOptionsSymbol]?: readonly TableOptionSpec[];
-    readonly [options]?: ClassDeclaredTableOptions;
-    readonly tableName: Name;
-} & BoundColumns<Name, Fields> & Plan.RowSet<BoundColumns<Name, Fields>, never, Record<Name, Plan.Source<Name, "required", TrueFormula>>, TableDialect<Fields>>;
-/** Minimal structural table-like contract used across helper APIs. */
-export type AnyTable<Dialect extends string = string> = {
-    readonly [TypeId]: TableState<string, TableFieldMap, string, TableKind, string | undefined>;
-    readonly [OptionsSymbol]: readonly TableOptionSpec[];
-} & Plan.RowSet<any, any, Record<string, Plan.AnySource>, Dialect>;
-/** Public table-option builder type used by `Table.index`, `Table.primaryKey`, and friends. */
-export type TableOption<Spec extends TableOptionSpec = TableOptionSpec> = {
-    <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(table: OptionInputTable<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", any>, Spec>): ApplyOption<TableDefinition<Name, Fields, PrimaryKeyColumns, "schema", any>, Spec>;
-    readonly option: Spec;
-};
-export declare const option: <Spec extends TableOptionSpec>(spec: Spec) => TableOption<Spec>;
-export declare const optionFromTable: <Spec extends TableOptionSpec>(spec: Spec, resolve: (table: TableDefinition<any, any, any, "schema", any>) => Spec) => TableOption<Spec>;
-/** Creates a table definition from a name and field map. */
-export declare function make<Name extends string, Fields extends TableFieldMap, const SchemaName extends string | undefined = DefaultSchemaName>(name: NonEmptyStringInput<Name>, fields: Fields, schemaName?: NonEmptySchemaNameInput<SchemaName>): TableDefinition<Name, Fields, InlinePrimaryKeyKeys<Fields>, "schema", SchemaName>;
-/**
- * Creates an aliased source from an existing table definition.
- *
- * The alias becomes the logical source identity used by the query layer while
- * the original physical table name is retained in bound-column provenance for
- * downstream SQL rendering work.
- */
-export declare const alias: <Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string, SchemaName extends string, AliasName extends string>(table: TableClassStatic<Name, Fields, PrimaryKeyColumns, SchemaName> | TableDefinition<Name, Fields, PrimaryKeyColumns, any, SchemaName>, aliasName: AliasName) => TableDefinition<AliasName, Fields, PrimaryKeyColumns, "alias", SchemaName>;
-/** Returns the lazily derived select schema for a table. */
-export declare function selectSchema<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>): Schema.Schema<SelectRow<Name, Fields>>;
-/** Returns the lazily derived insert schema for a table. */
-export declare function insertSchema<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>): Schema.Schema<InsertRow<Name, Fields>>;
-/** Returns the lazily derived update schema for a table. */
-export declare function updateSchema<Name extends string, Fields extends TableFieldMap, PrimaryKeyColumns extends keyof Fields & string>(table: TableDefinition<Name, Fields, PrimaryKeyColumns, any, any> | TableClassStatic<Name, Fields, PrimaryKeyColumns, any>): Schema.Schema<UpdateRow<Name, Fields, PrimaryKeyColumns>>;
-/**
- * Class-based table constructor mirroring `Schema.Class`.
- *
- * The returned base class can be extended and configured with
- * `static readonly [Table.options]`.
- */
-export declare function Class<Self = never>(name: "", schemaName?: string | undefined): never;
-export declare function Class<Self = never>(name: string, schemaName: ""): never;
-export declare function Class<Self = never, const SchemaName extends string | undefined = DefaultSchemaName, const Name extends string = string>(name: NonEmptyStringInput<Name>, schemaName?: NonEmptySchemaNameInput<SchemaName>): <Fields extends TableFieldMap>(fields: Fields) => [Self] extends [never] ? "Missing `Self` generic - use `class Self extends Table.Class<Self>(...) {}`" : TableClassStatic<Name, Fields, Extract<{ [K in keyof Fields]: Fields[K]["metadata"]["primaryKey"] extends true ? K : never; }[keyof Fields], string>, SchemaName>;
-/** Declares a table-level primary key. */
-export declare const primaryKey: <const Columns extends string | readonly string[]>(columns: Columns) => TableOption<{
-    readonly kind: "primaryKey";
-    readonly columns: NormalizeColumns<Columns>;
-}>;
-/** Declares a table-level unique constraint. */
-export declare const unique: <const Columns extends string | readonly string[]>(columns: Columns) => TableOption<{
-    readonly kind: "unique";
-    readonly columns: NormalizeColumns<Columns>;
-}>;
-/** Declares a table-level index. */
-export declare const index: <const Columns extends string | readonly string[]>(columns: Columns) => TableOption<{
-    readonly kind: "index";
-    readonly columns: NormalizeColumns<Columns>;
-}>;
-/** Declares a table-level foreign key. */
-export declare const foreignKey: <const LocalColumns extends string | readonly string[], TargetTable extends AnyTable, const TargetColumns extends string | readonly string[]>(columns: LocalColumns, target: () => TargetTable, referencedColumns: TargetColumns) => TableOption<{
-    readonly kind: "foreignKey";
-    readonly columns: NormalizeColumns<LocalColumns>;
-    readonly references: () => {
-        readonly tableName: string;
-        readonly schemaName?: string | undefined;
-        readonly columns: NormalizeColumns<TargetColumns>;
-        readonly knownColumns: readonly string[];
-    };
-}>;
-/** Declares a check constraint expression. */
-export declare const check: <const Name extends string>(name: NonEmptyStringInput<Name>, predicate: DdlExpressionLike) => TableOption<{
-    readonly kind: "check";
-    readonly name: Name;
-    readonly predicate: DdlExpressionLike;
-}>;
-/** Extracts the row type produced by `selectSchema(table)`. */
-export type SelectOf<Table extends AnyTable> = Table[typeof TypeId] extends {
-    readonly name: infer Name extends string;
-    readonly fields: infer Fields extends TableFieldMap;
-} ? SelectRow<Name, Fields> : never;
-/** Extracts the payload type produced by `insertSchema(table)`. */
-export type InsertOf<Table extends AnyTable> = Table[typeof TypeId] extends {
-    readonly name: infer Name extends string;
-    readonly fields: infer Fields extends TableFieldMap;
-} ? InsertRow<Name, Fields> : never;
-/** Extracts the payload type produced by `updateSchema(table)`. */
-export type UpdateOf<Table extends AnyTable> = Table[typeof TypeId] extends {
-    readonly name: infer Name extends string;
-    readonly fields: infer Fields extends TableFieldMap;
-    readonly primaryKey: readonly (infer PrimaryKeyColumns)[];
-} ? UpdateRow<Name, Fields, Extract<PrimaryKeyColumns, keyof Fields & string>> : never;

package/src/postgres/cast.ts

@@ -1,45 +0,0 @@
-import type * as Expression from "../internal/scalar.js"
-import type * as ExpressionAst from "../internal/expression-ast.js"
-import type { ExpressionInput } from "../internal/query.js"
-import { cast as postgresCast } from "./internal/dsl.js"
-
-type CastInput = ExpressionInput
-type CastTarget = Expression.DbType.Any
-type CastNullability<Value extends CastInput> = Value extends Expression.Any
-  ? Expression.NullabilityOf<Value>
-  : Value extends null ? "always" : "never"
-type CastKind<Value extends CastInput> = Value extends Expression.Any
-  ? Expression.KindOf<Value>
-  : "scalar"
-type CastDependencies<Value extends CastInput> = Value extends Expression.Any
-  ? Expression.DependenciesOf<Value>
-  : never
-type CastExpression<
-  Value extends CastInput,
-  Target extends CastTarget
-> = Expression.Scalar<
-  Expression.RuntimeOfDbType<Target>,
-  Target,
-  CastNullability<Value>,
-  Target["dialect"],
-  CastKind<Value>,
-  CastDependencies<Value>
-> & {
-  readonly [ExpressionAst.TypeId]: ExpressionAst.CastNode<Value extends Expression.Any ? Value : Expression.Any, Target>
-}
-
-const to: {
-  <Value extends CastInput, Target extends CastTarget>(
-    value: Value,
-    target: Target
-  ): CastExpression<Value, Target>
-  <Target extends CastTarget>(
-    target: Target
-  ): <Value extends CastInput>(value: Value) => CastExpression<Value, Target>
-} = ((...args: [CastInput, CastTarget] | [CastTarget]) =>
-  args.length === 1
-    ? ((value: CastInput) => postgresCast(value as never, args[0] as never))
-    : postgresCast(args[0] as never, args[1] as never)) as unknown as typeof to
-
-/** Postgres cast helpers. */
-export const cast = { to }