effect-qb 0.14.0 → 0.15.0

package/package.json

@@ -1,7 +1,20 @@
 {
   "name": "effect-qb",
-  "version": "0.14.0",
+  "version": "0.15.0",
   "type": "module",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/relsunkaev/effect-qb.git"
+  },
+  "bugs": {
+    "url": "https://github.com/relsunkaev/effect-qb/issues"
+  },
+  "homepage": "https://github.com/relsunkaev/effect-qb#readme",
+  "engines": {
+    "node": ">=22",
+    "bun": ">=1.3.5"
+  },
   "files": [
     "dist",
     "src",

package/src/internal/aggregation-validation.ts

@@ -1,4 +1,4 @@
-import * as Expression from "./expression.js"
+import * as Expression from "./scalar.js"
 import { groupingKeyOfExpression } from "./grouping-key.js"
 
 /** Recursive selection value accepted by aggregate-shape validation. */
@@ -13,7 +13,7 @@ const isExpression = (value: unknown): value is Expression.Any =>
 
 const selectionHasAggregate = (selection: SelectionValue): boolean => {
   if (isExpression(selection)) {
-    return selection[Expression.TypeId].aggregation === "aggregate"
+    return selection[Expression.TypeId].kind === "aggregate"
   }
   return Object.values(selection).some((value) => selectionHasAggregate(value))
 }
@@ -23,7 +23,7 @@ const isGroupedSelectionValid = (
   groupedExpressions: ReadonlySet<string>
 ): boolean => {
   if (isExpression(selection)) {
-    const aggregation = selection[Expression.TypeId].aggregation
+    const aggregation = selection[Expression.TypeId].kind
     if (aggregation === "aggregate") {
       return true
     }

package/src/internal/case-analysis.d.ts

@@ -0,0 +1,18 @@
+import type * as Expression from "./scalar.js";
+import type * as ExpressionAst from "./expression-ast.js";
+import type { PredicateFormula } from "./predicate/formula.js";
+import type { AssumeFormulaFalse, AssumeFormulaTrue, Contradicts, Implies } from "./predicate/analysis.js";
+import type { FormulaOfExpression } from "./predicate/normalize.js";
+export interface CasePath<Assumptions extends PredicateFormula, Value extends Expression.Any> {
+    readonly assumptions: Assumptions;
+    readonly value: Value;
+}
+type PredicateFormulaOf<Predicate extends Expression.Any> = FormulaOfExpression<Predicate>;
+export type CaseBranchAssumeTrue<Assumptions extends PredicateFormula, Predicate extends Expression.Any> = AssumeFormulaTrue<Assumptions, PredicateFormulaOf<Predicate>>;
+export type CaseBranchAssumeFalse<Assumptions extends PredicateFormula, Predicate extends Expression.Any> = AssumeFormulaFalse<Assumptions, PredicateFormulaOf<Predicate>>;
+export type CaseBranchDecision<Assumptions extends PredicateFormula, Predicate extends Expression.Any> = Contradicts<Assumptions, Predicate> extends true ? "skip" : Implies<Assumptions, Predicate> extends true ? "take" : "branch";
+export type ReachableCasePaths<Assumptions extends PredicateFormula, Branches extends readonly ExpressionAst.CaseBranchNode[], Else extends Expression.Any> = Branches extends readonly [
+    infer Head extends ExpressionAst.CaseBranchNode,
+    ...infer Tail extends readonly ExpressionAst.CaseBranchNode[]
+] ? CaseBranchDecision<Assumptions, Head["when"]> extends "skip" ? ReachableCasePaths<Assumptions, Tail, Else> : CaseBranchDecision<Assumptions, Head["when"]> extends "take" ? CasePath<CaseBranchAssumeTrue<Assumptions, Head["when"]>, Head["then"]> : CasePath<CaseBranchAssumeTrue<Assumptions, Head["when"]>, Head["then"]> | ReachableCasePaths<CaseBranchAssumeFalse<Assumptions, Head["when"]>, Tail, Else> : CasePath<Assumptions, Else>;
+export {};

package/src/internal/case-analysis.ts

@@ -1,8 +1,8 @@
-import type * as Expression from "./expression.js"
+import type * as Expression from "./scalar.js"
 import type * as ExpressionAst from "./expression-ast.js"
-import type { PredicateFormula } from "./predicate-formula.js"
-import type { AssumeFormulaFalse, AssumeFormulaTrue, Contradicts, Implies } from "./predicate-analysis.js"
-import type { FormulaOfExpression } from "./predicate-normalize.js"
+import type { PredicateFormula } from "./predicate/formula.js"
+import type { AssumeFormulaFalse, AssumeFormulaTrue, Contradicts, Implies } from "./predicate/analysis.js"
+import type { FormulaOfExpression } from "./predicate/normalize.js"
 
 export interface CasePath<
   Assumptions extends PredicateFormula,

package/src/internal/coercion/analysis.d.ts

@@ -0,0 +1,7 @@
+import type * as Expression from "../scalar.js";
+import type { CastTargetError, OperandCompatibilityError } from "./errors.js";
+import type { CanCastDbType, CanCompareDbTypes, CanTextuallyCoerceDbType } from "./rules.js";
+export type ComparableDbType<Left extends Expression.DbType.Any, Right extends Expression.DbType.Any, Dialect extends string, Operator extends string = "comparison"> = CanCompareDbTypes<Left, Right, Dialect> extends true ? Right : OperandCompatibilityError<Operator, Left, Right, Dialect, "the same db type family">;
+export type TextCompatibleDbType<Db extends Expression.DbType.Any, Dialect extends string, Operator extends string = "text operator"> = CanTextuallyCoerceDbType<Db, Dialect> extends true ? Db : OperandCompatibilityError<Operator, Db, Db, Dialect, "a text-compatible db type">;
+export type CastableDbType<Source extends Expression.DbType.Any, Target extends Expression.DbType.Any, Dialect extends string> = CanCastDbType<Source, Target, Dialect> extends true ? Target : CastTargetError<Source, Target, Dialect>;
+export type RuntimeOfDbType<Db extends Expression.DbType.Any> = Expression.RuntimeOfDbType<Db>;

package/src/internal/{coercion-analysis.ts → coercion/analysis.ts}

@@ -1,6 +1,6 @@
-import type * as Expression from "./expression.js"
-import type { CastTargetError, OperandCompatibilityError } from "./coercion-errors.js"
-import type { CanCastDbType, CanCompareDbTypes, CanTextuallyCoerceDbType } from "./coercion-rules.js"
+import type * as Expression from "../scalar.js"
+import type { CastTargetError, OperandCompatibilityError } from "./errors.js"
+import type { CanCastDbType, CanCompareDbTypes, CanTextuallyCoerceDbType } from "./rules.js"
 
 export type ComparableDbType<
   Left extends Expression.DbType.Any,

package/src/internal/coercion/errors.d.ts

@@ -0,0 +1,17 @@
+import type * as Expression from "../scalar.js";
+export type OperandCompatibilityError<Operator extends string, Left extends Expression.DbType.Any, Right extends Expression.DbType.Any, Dialect extends string, Expected extends string> = {
+    readonly __effect_qb_error__: "effect-qb: incompatible operand types";
+    readonly __effect_qb_operator__: Operator;
+    readonly __effect_qb_left_db_type__: Left;
+    readonly __effect_qb_right_db_type__: Right;
+    readonly __effect_qb_dialect__: Dialect;
+    readonly __effect_qb_expected__: Expected;
+    readonly __effect_qb_hint__: "Use cast(...) or pick values from the same db type family";
+};
+export type CastTargetError<Source extends Expression.DbType.Any, Target extends Expression.DbType.Any, Dialect extends string> = {
+    readonly __effect_qb_error__: "effect-qb: unsupported cast target";
+    readonly __effect_qb_source_db_type__: Source;
+    readonly __effect_qb_target_db_type__: Target;
+    readonly __effect_qb_dialect__: Dialect;
+    readonly __effect_qb_hint__: "Use one of the supported Q.type.<kind>() witnesses";
+};

package/src/internal/{coercion-errors.ts → coercion/errors.ts}

@@ -1,4 +1,4 @@
-import type * as Expression from "./expression.js"
+import type * as Expression from "../scalar.js"
 
 export type OperandCompatibilityError<
   Operator extends string,

package/src/internal/coercion/kind.d.ts

@@ -0,0 +1,4 @@
+import type * as Expression from "../scalar.js";
+import type { FamilyOfDbType } from "../datatypes/lookup.js";
+export type CoercionKind = "text" | "numeric" | "boolean" | "date" | "time" | "timestamp" | "binary" | "interval" | "uuid" | "json" | "xml" | "bit" | "identifier" | "network" | "spatial" | "textsearch" | "range" | "multirange" | "array" | "record" | "domain" | "enum" | "set" | "money" | "null" | `other:${string}`;
+export type CoercionKindOf<Db extends Expression.DbType.Any> = FamilyOfDbType<Db>;

package/src/internal/{coercion-kind.ts → coercion/kind.ts}

@@ -1,5 +1,5 @@
-import type * as Expression from "./expression.js"
-import type { FamilyOfDbType } from "./datatypes/lookup.js"
+import type * as Expression from "../scalar.js"
+import type { FamilyOfDbType } from "../datatypes/lookup.js"
 
 export type CoercionKind =
   | "text"

package/src/internal/{coercion-normalize.ts → coercion/normalize.ts}

@@ -1,4 +1,4 @@
-import type * as Expression from "./expression.js"
+import type * as Expression from "../scalar.js"
 
 /** Extracts the database type carried by an expression. */
 export type DbTypeOfExpression<Value extends Expression.Any> = Expression.DbTypeOf<Value>

package/src/internal/coercion/rules.d.ts

@@ -0,0 +1,6 @@
+import type * as Expression from "../scalar.js";
+import type { CanCastDbType as LookupCanCastDbType, CanCompareDbTypes as LookupCanCompareDbTypes, CanContainDbTypes as LookupCanContainDbTypes, CanTextuallyCoerceDbType as LookupCanTextuallyCoerceDbType } from "../datatypes/lookup.js";
+export type CanCompareDbTypes<Left extends Expression.DbType.Any, Right extends Expression.DbType.Any, Dialect extends string> = LookupCanCompareDbTypes<Left, Right, Dialect>;
+export type CanContainDbTypes<Left extends Expression.DbType.Any, Right extends Expression.DbType.Any, Dialect extends string> = LookupCanContainDbTypes<Left, Right, Dialect>;
+export type CanTextuallyCoerceDbType<Db extends Expression.DbType.Any, Dialect extends string> = LookupCanTextuallyCoerceDbType<Db, Dialect>;
+export type CanCastDbType<Source extends Expression.DbType.Any, Target extends Expression.DbType.Any, Dialect extends string> = LookupCanCastDbType<Source, Target, Dialect>;

package/src/internal/{coercion-rules.ts → coercion/rules.ts}

@@ -1,5 +1,5 @@
-import type * as Expression from "./expression.js"
-import type { CanCastDbType as LookupCanCastDbType, CanCompareDbTypes as LookupCanCompareDbTypes, CanContainDbTypes as LookupCanContainDbTypes, CanTextuallyCoerceDbType as LookupCanTextuallyCoerceDbType } from "./datatypes/lookup.js"
+import type * as Expression from "../scalar.js"
+import type { CanCastDbType as LookupCanCastDbType, CanCompareDbTypes as LookupCanCompareDbTypes, CanContainDbTypes as LookupCanContainDbTypes, CanTextuallyCoerceDbType as LookupCanTextuallyCoerceDbType } from "../datatypes/lookup.js"
 
 export type CanCompareDbTypes<
   Left extends Expression.DbType.Any,

package/src/internal/column-state.d.ts

@@ -0,0 +1,190 @@
+import type * as Brand from "effect/Brand";
+import { type Pipeable } from "effect/Pipeable";
+import * as Schema from "effect/Schema";
+import * as Expression from "./scalar.js";
+import * as ExpressionAst from "./expression-ast.js";
+import type * as SchemaExpression from "./schema-expression.js";
+/** Symbol used to attach column-definition metadata. */
+export declare const ColumnTypeId: unique symbol;
+/** Symbol used to attach bound-column provenance. */
+export declare const BoundColumnTypeId: unique symbol;
+export type ColumnTypeId = typeof ColumnTypeId;
+export type BoundColumnTypeId = typeof BoundColumnTypeId;
+export type DdlExpression = Expression.Any | SchemaExpression.Any;
+/** Lazy reference to another bound column. */
+export interface ColumnReference<Target = unknown> {
+    readonly target: () => Target;
+    readonly name?: string;
+    readonly onUpdate?: "noAction" | "restrict" | "cascade" | "setNull" | "setDefault";
+    readonly onDelete?: "noAction" | "restrict" | "cascade" | "setNull" | "setDefault";
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
+}
+/** Inline single-column index metadata. */
+export interface ColumnIndexOptions {
+    readonly name?: string;
+    readonly method?: string;
+    readonly include?: readonly string[];
+    readonly predicate?: DdlExpression;
+    readonly order?: "asc" | "desc";
+    readonly nulls?: "first" | "last";
+    readonly operatorClass?: string;
+    readonly collation?: string;
+}
+/** Inline single-column unique-constraint metadata. */
+export interface ColumnUniqueOptions {
+    readonly name?: string;
+    readonly nullsNotDistinct?: boolean;
+    readonly deferrable?: boolean;
+    readonly initiallyDeferred?: boolean;
+}
+/** Complete static state tracked for a column definition. */
+export interface ColumnState<Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends Expression.BindingId = never> {
+    readonly select: Select;
+    readonly insert: Insert;
+    readonly update: Update;
+    readonly dbType: Db;
+    readonly nullable: Nullable;
+    readonly hasDefault: HasDefault;
+    readonly generated: Generated;
+    readonly primaryKey: PrimaryKey;
+    readonly unique: Unique;
+    readonly references: Ref;
+    readonly brand?: true;
+    readonly index?: ColumnIndexOptions;
+    readonly uniqueConstraint?: ColumnUniqueOptions;
+    readonly defaultValue?: DdlExpression;
+    readonly generatedValue?: DdlExpression;
+    readonly ddlType?: string;
+    readonly identity?: {
+        readonly generation: "always" | "byDefault";
+    };
+    readonly enum?: {
+        readonly name: string;
+        readonly schemaName?: string;
+        readonly values: readonly [string, ...string[]];
+    };
+    readonly dependencies?: Dependencies;
+}
+/** Unbound column definition produced by the `Column` DSL. */
+export interface ColumnDefinition<Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends Expression.BindingId = never> extends Pipeable, Expression.Scalar<Select, Db, Nullable extends true ? "maybe" : "never", Db["dialect"], "scalar", Dependencies> {
+    readonly pipe: Pipeable["pipe"];
+    readonly [ColumnTypeId]: ColumnState<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
+    readonly schema: Schema.Schema<NonNullable<Select>, any, any>;
+    readonly metadata: {
+        readonly dbType: Db;
+        readonly nullable: Nullable;
+        readonly hasDefault: HasDefault;
+        readonly generated: Generated;
+        readonly primaryKey: PrimaryKey;
+        readonly unique: Unique;
+        readonly references: Ref;
+        readonly brand?: true;
+        readonly index?: ColumnIndexOptions;
+        readonly uniqueConstraint?: ColumnUniqueOptions;
+        readonly defaultValue?: DdlExpression;
+        readonly generatedValue?: DdlExpression;
+        readonly ddlType?: string;
+        readonly identity?: {
+            readonly generation: "always" | "byDefault";
+        };
+        readonly enum?: {
+            readonly name: string;
+            readonly schemaName?: string;
+            readonly values: readonly [string, ...string[]];
+        };
+    };
+}
+/** Column definition bound to a concrete table and column name. */
+export interface BoundColumn<Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, TableName extends string, ColumnName extends string, BaseTableName extends string = TableName> extends ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, TableName> {
+    readonly [BoundColumnTypeId]: {
+        readonly tableName: TableName;
+        readonly columnName: ColumnName;
+        readonly baseTableName: BaseTableName;
+        readonly schemaName?: string;
+    };
+    readonly [Expression.TypeId]: Expression.State<Select, Db, Nullable extends true ? "maybe" : "never", Db["dialect"], "scalar", TableName>;
+    readonly [ExpressionAst.TypeId]: ExpressionAst.ColumnNode<TableName, ColumnName>;
+}
+/** Convenience alias for any column definition. */
+export type AnyColumnDefinition = ColumnDefinition<any, any, any, Expression.DbType.Any, boolean, boolean, boolean, boolean, boolean, any, any>;
+/** Convenience alias for any bound column. */
+export type AnyBoundColumn = BoundColumn<any, any, any, Expression.DbType.Any, boolean, boolean, boolean, boolean, boolean, any, string, string, string>;
+/** Constructs a runtime column-definition object from schema and metadata. */
+export declare const makeColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(schema: Schema.Schema<NonNullable<Select>, any, any>, metadata: {
+    readonly dbType: Db;
+    readonly nullable: Nullable;
+    readonly hasDefault: HasDefault;
+    readonly generated: Generated;
+    readonly primaryKey: PrimaryKey;
+    readonly unique: Unique;
+    readonly references: Ref;
+    readonly brand?: true | undefined;
+    readonly index?: ColumnIndexOptions | undefined;
+    readonly uniqueConstraint?: ColumnUniqueOptions | undefined;
+    readonly defaultValue?: DdlExpression | undefined;
+    readonly generatedValue?: DdlExpression | undefined;
+    readonly ddlType?: string | undefined;
+    readonly identity?: {
+        readonly generation: "always" | "byDefault";
+    } | undefined;
+    readonly enum?: {
+        readonly name: string;
+        readonly schemaName?: string | undefined;
+        readonly values: readonly [string, ...string[]];
+    } | undefined;
+}) => ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
+export declare const remapColumnDefinition: <Select, Insert, Update, Db extends Expression.DbType.Any, Nullable extends boolean, HasDefault extends boolean, Generated extends boolean, PrimaryKey extends boolean, Unique extends boolean, Ref, Dependencies extends string = never>(column: ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>, options?: {
+    readonly schema?: Schema.Schema.Any | undefined;
+    readonly metadata?: {
+        readonly dbType: Db;
+        readonly nullable: Nullable;
+        readonly hasDefault: HasDefault;
+        readonly generated: Generated;
+        readonly primaryKey: PrimaryKey;
+        readonly unique: Unique;
+        readonly references: Ref;
+        readonly brand?: true | undefined;
+        readonly index?: ColumnIndexOptions | undefined;
+        readonly uniqueConstraint?: ColumnUniqueOptions | undefined;
+        readonly defaultValue?: DdlExpression | undefined;
+        readonly generatedValue?: DdlExpression | undefined;
+        readonly ddlType?: string | undefined;
+        readonly identity?: {
+            readonly generation: "always" | "byDefault";
+        } | undefined;
+        readonly enum?: {
+            readonly name: string;
+            readonly schemaName?: string | undefined;
+            readonly values: readonly [string, ...string[]];
+        } | undefined;
+    } | undefined;
+}) => ColumnDefinition<Select, Insert, Update, Db, Nullable, HasDefault, Generated, PrimaryKey, Unique, Ref, Dependencies>;
+/** Attaches table/column provenance to an existing column definition. */
+export declare const bindColumn: <TableName extends string, ColumnName extends string, BaseTableName extends string, SchemaName extends string | undefined, Column extends AnyColumnDefinition>(tableName: TableName, columnName: ColumnName, column: Column, baseTableName: BaseTableName, schemaName?: SchemaName | undefined) => BoundColumnFrom<Column, TableName, ColumnName, BaseTableName>;
+/** Extracts the internal state record for a column. */
+export type ColumnStateOf<Column extends AnyColumnDefinition> = Column[typeof ColumnTypeId];
+/** Extracts the read/select type of a column. */
+export type SelectType<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["select"];
+/** Extracts the insert type of a column. */
+export type InsertType<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["insert"];
+/** Extracts the update type of a column. */
+export type UpdateType<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["update"];
+/** Extracts whether a column is nullable. */
+export type IsNullable<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["nullable"];
+/** Extracts whether a column has a server-side default. */
+export type HasDefault<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["hasDefault"];
+/** Extracts whether a column is generated by the database. */
+export type IsGenerated<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["generated"];
+/** Extracts whether a column is part of a primary key. */
+export type IsPrimaryKey<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["primaryKey"];
+/** Extracts whether a column is unique. */
+export type IsUnique<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["unique"];
+/** Extracts a column's foreign-key reference metadata. */
+export type ReferencesOf<Column extends AnyColumnDefinition> = ColumnStateOf<Column>["references"];
+/** Extracts the non-null select type of a column. */
+export type BaseSelectType<Column extends AnyColumnDefinition> = NonNullable<SelectType<Column>>;
+type BrandedValue<Value, BrandName extends string> = [Extract<Value, null | undefined>] extends [never] ? Value & Brand.Brand<BrandName> : (Exclude<Value, null | undefined> & Brand.Brand<BrandName>) | Extract<Value, null | undefined>;
+/** Rebinds a generic column definition to a specific table and key. */
+export type BoundColumnFrom<Column extends AnyColumnDefinition, TableName extends string, ColumnName extends string, BaseTableName extends string = TableName> = BoundColumn<Column["metadata"]["brand"] extends true ? BrandedValue<SelectType<Column>, `${TableName}.${ColumnName}`> : SelectType<Column>, Column["metadata"]["brand"] extends true ? BrandedValue<InsertType<Column>, `${TableName}.${ColumnName}`> : InsertType<Column>, Column["metadata"]["brand"] extends true ? BrandedValue<UpdateType<Column>, `${TableName}.${ColumnName}`> : UpdateType<Column>, ColumnStateOf<Column>["dbType"], IsNullable<Column>, HasDefault<Column>, IsGenerated<Column>, IsPrimaryKey<Column>, IsUnique<Column>, ReferencesOf<Column>, TableName, ColumnName, BaseTableName>;
+export {};

package/src/internal/column-state.ts

@@ -2,7 +2,7 @@ import type * as Brand from "effect/Brand"
 import { pipeArguments, type Pipeable } from "effect/Pipeable"
 import * as Schema from "effect/Schema"
 
-import * as Expression from "./expression.js"
+import * as Expression from "./scalar.js"
 import * as ExpressionAst from "./expression-ast.js"
 import type * as SchemaExpression from "./schema-expression.js"
 
@@ -34,6 +34,8 @@ export interface ColumnIndexOptions {
   readonly predicate?: DdlExpression
   readonly order?: "asc" | "desc"
   readonly nulls?: "first" | "last"
+  readonly operatorClass?: string
+  readonly collation?: string
 }
 
 /** Inline single-column unique-constraint metadata. */
@@ -56,8 +58,7 @@ export interface ColumnState<
   PrimaryKey extends boolean,
   Unique extends boolean,
   Ref,
-  Source = never,
-  Dependencies extends Expression.SourceDependencies = {}
+  Dependencies extends Expression.BindingId = never
 > {
   readonly select: Select
   readonly insert: Insert
@@ -83,8 +84,7 @@ export interface ColumnState<
     readonly schemaName?: string
     readonly values: readonly [string, ...string[]]
   }
-  readonly source: Source
-  readonly dependencies: Dependencies
+  readonly dependencies?: Dependencies
 }
 
 /** Unbound column definition produced by the `Column` DSL. */
@@ -99,15 +99,13 @@ export interface ColumnDefinition<
   PrimaryKey extends boolean,
   Unique extends boolean,
   Ref,
-  Source = never,
-  Dependencies extends Expression.SourceDependencies = {}
-> extends Pipeable, Expression.Expression<
+  Dependencies extends Expression.BindingId = never
+> extends Pipeable, Expression.Scalar<
     Select,
     Db,
     Nullable extends true ? "maybe" : "never",
     Db["dialect"],
     "scalar",
-    Source,
     Dependencies
   > {
   readonly pipe: Pipeable["pipe"]
@@ -122,7 +120,6 @@ export interface ColumnDefinition<
     PrimaryKey,
     Unique,
     Ref,
-    Source,
     Dependencies
   >
   readonly schema: Schema.Schema<NonNullable<Select>, any, any>
@@ -161,11 +158,11 @@ export interface BoundColumn<
   HasDefault extends boolean,
   Generated extends boolean,
   PrimaryKey extends boolean,
-    Unique extends boolean,
-    Ref,
-    TableName extends string,
-    ColumnName extends string,
-    BaseTableName extends string = TableName
+  Unique extends boolean,
+  Ref,
+  TableName extends string,
+  ColumnName extends string,
+  BaseTableName extends string = TableName
 > extends ColumnDefinition<
     Select,
     Insert,
@@ -177,8 +174,7 @@ export interface BoundColumn<
     PrimaryKey,
     Unique,
     Ref,
-    Expression.ColumnSource<TableName, ColumnName, BaseTableName>,
-    Record<TableName, true>
+    TableName
   > {
   readonly [BoundColumnTypeId]: {
     readonly tableName: TableName
@@ -192,9 +188,7 @@ export interface BoundColumn<
     Nullable extends true ? "maybe" : "never",
     Db["dialect"],
     "scalar",
-    Expression.ColumnSource<TableName, ColumnName, BaseTableName>,
-    Record<TableName, true>,
-    "propagate"
+    TableName
   >
   readonly [ExpressionAst.TypeId]: ExpressionAst.ColumnNode<TableName, ColumnName>
 }
@@ -226,6 +220,7 @@ export type AnyBoundColumn = BoundColumn<
   boolean,
   any,
   string,
+  string,
   string
 >
 
@@ -235,6 +230,17 @@ const ColumnProto = {
   }
 }
 
+const attachPipe = <Value extends object>(value: Value): Value => {
+  Object.defineProperty(value, "pipe", {
+    configurable: true,
+    writable: true,
+    value: function(this: unknown) {
+      return pipeArguments(value, arguments)
+    }
+  })
+  return value
+}
+
 /** Constructs a runtime column-definition object from schema and metadata. */
 export const makeColumnDefinition = <
   Select,
@@ -247,8 +253,7 @@ export const makeColumnDefinition = <
   PrimaryKey extends boolean,
   Unique extends boolean,
   Ref,
-  Source = never,
-  Dependencies extends Expression.SourceDependencies = {}
+  Dependencies extends Expression.BindingId = never
 >(
   schema: Schema.Schema<NonNullable<Select>, any, any>,
   metadata: ColumnDefinition<
@@ -262,7 +267,6 @@ export const makeColumnDefinition = <
     PrimaryKey,
     Unique,
     Ref,
-    Source,
     Dependencies
   >["metadata"]
 ): ColumnDefinition<
@@ -276,10 +280,9 @@ export const makeColumnDefinition = <
   PrimaryKey,
   Unique,
   Ref,
-  Source,
   Dependencies
 > => {
-  const column = Object.create(ColumnProto)
+  const column = attachPipe(Object.create(ColumnProto))
   column.schema = schema
   column.metadata = metadata
   column[Expression.TypeId] = {
@@ -288,10 +291,8 @@ export const makeColumnDefinition = <
     runtimeSchema: schema,
     nullability: (metadata.nullable ? "maybe" : "never") as Nullable extends true ? "maybe" : "never",
     dialect: metadata.dbType.dialect,
-    aggregation: "scalar",
-    source: undefined as Source,
-    sourceNullability: "propagate" as const,
-    dependencies: {} as Dependencies
+    kind: "scalar",
+    dependencies: {}
   }
   column[ColumnTypeId] = {
     select: undefined as Select,
@@ -308,9 +309,7 @@ export const makeColumnDefinition = <
     generatedValue: metadata.generatedValue,
     ddlType: metadata.ddlType,
     identity: metadata.identity,
-    enum: metadata.enum,
-    source: undefined as Source,
-    dependencies: {} as Dependencies
+    enum: metadata.enum
   }
   return column
 }
@@ -326,8 +325,7 @@ export const remapColumnDefinition = <
   PrimaryKey extends boolean,
   Unique extends boolean,
   Ref,
-  Source = never,
-  Dependencies extends Expression.SourceDependencies = {}
+  Dependencies extends Expression.BindingId = never
 >(
   column: ColumnDefinition<
     Select,
@@ -340,7 +338,6 @@ export const remapColumnDefinition = <
     PrimaryKey,
     Unique,
     Ref,
-    Source,
     Dependencies
   >,
   options: {
@@ -356,7 +353,6 @@ export const remapColumnDefinition = <
       PrimaryKey,
       Unique,
       Ref,
-      Source,
       Dependencies
     >["metadata"]
   } = {}
@@ -371,12 +367,11 @@ export const remapColumnDefinition = <
   PrimaryKey,
   Unique,
   Ref,
-  Source,
   Dependencies
 > => {
   const schema = options.schema ?? column.schema
   const metadata = options.metadata ?? column.metadata
-  const next = Object.create(ColumnProto)
+  const next = attachPipe(Object.create(ColumnProto))
   next.schema = schema
   next.metadata = metadata
   next[Expression.TypeId] = {
@@ -441,7 +436,7 @@ export const bindColumn = <
   const schema = column.metadata.brand === true
     ? Schema.brand(brandName)(column.schema)
     : column.schema
-  const bound = Object.create(ColumnProto)
+  const bound = attachPipe(Object.create(ColumnProto))
   bound.schema = schema
   bound.metadata = column.metadata
   bound[Expression.TypeId] = {
@@ -450,16 +445,10 @@ export const bindColumn = <
     runtimeSchema: schema,
     nullability: (column.metadata.nullable ? "maybe" : "never") as IsNullable<Column> extends true ? "maybe" : "never",
     dialect: column.metadata.dbType.dialect,
-    aggregation: "scalar",
-    source: {
-      tableName,
-      columnName,
-      baseTableName
-    },
-    sourceNullability: "propagate" as const,
+    kind: "scalar",
     dependencies: {
       [tableName]: true
-    } as Record<TableName, true>
+    }
   }
   bound[ExpressionAst.TypeId] = {
     kind: "column",