durcno 1.0.0-alpha.12 → 1.0.0-alpha.13

package/dist/bin.cjs

@@ -10451,7 +10451,7 @@ async function status(options) {
 }
 
 // src/cli/index.ts
-program.version("1.0.0-alpha.11");
+program.version("1.0.0-alpha.12");
 var Options = {
   config: ["--config <path>", "Path to the config file"]
 };

package/dist/src/columns/common.d.mts

@@ -1,5 +1,7 @@
+import { CheckExpression } from "../constraints/check.mjs";
 import { entityType } from "../symbols.mjs";
 import { StdTable, StdTableColumn } from "../table.mjs";
+import { AnyFilter } from "../filters/index.mjs";
 import { Arg } from "../query-builders/pre.mjs";
 import { Query, QueryContext } from "../query-builders/query.mjs";
 import { Sql } from "../sql.mjs";
@@ -273,6 +275,13 @@ declare abstract class Column<TConfig extends ColumnConfig, TColVal, TPgType ext
   get hasReferences(): boolean;
   get getReferencesCol(): StdTableColumn | null;
   get getReferencesOnDelete(): OnDeleteAction | null;
+  /**
+   * Attaches a column-level CHECK constraint.
+   * SQL equivalent: `CONSTRAINT "{table}_{col}_check" CHECK (<expr>)`
+   * @param fn - Function receiving the column and returning a filter or SQL expression.
+   */
+  check(fn: (c: this) => CheckExpression<this>): this;
+  get getCheckFn(): ((c: StdTableColumn) => AnyFilter | Sql) | undefined;
   /**
    * Sets a function to be called during INSERT queries to generate a value.
    * @param fn - A function that returns the value to insert

package/dist/src/columns/common.mjs

@@ -74,6 +74,7 @@ var Column = class {
 	#generated;
 	#generatedAs;
 	#references;
+	#check;
 	#name;
 	#nameSql;
 	#table;
@@ -334,6 +335,18 @@ var Column = class {
 		return this.#references ? this.#references.onDelete : null;
 	}
 	/**
+	* Attaches a column-level CHECK constraint.
+	* SQL equivalent: `CONSTRAINT "{table}_{col}_check" CHECK (<expr>)`
+	* @param fn - Function receiving the column and returning a filter or SQL expression.
+	*/
+	check(fn) {
+		this.#check = fn;
+		return this;
+	}
+	get getCheckFn() {
+		return this.#check;
+	}
+	/**
 	* Sets a function to be called during INSERT queries to generate a value.
 	* @param fn - A function that returns the value to insert
 	* @returns HasInsertFn<this>

package/dist/src/constraints/check.d.mts

@@ -1,4 +1,4 @@
-import { TableAnyColumn } from "../table.mjs";
+import { AnyColumn, TableAnyColumn } from "../table.mjs";
 import { AnyFilter, Filter } from "../filters/index.mjs";
 import { QueryContext } from "../query-builders/query.mjs";
 import { Sql } from "../sql.mjs";
@@ -8,7 +8,7 @@ import { Sql } from "../sql.mjs";
  * A check constraint expression that can be a filter condition or a raw SQL snippet.
  * Used in `checkConstraints` table extra to define `CHECK` constraints.
  */
-type CheckExpression<TScopeColumns extends TableAnyColumn> = Filter<TScopeColumns, false> | Sql;
+type CheckExpression<TScopeColumns extends TableAnyColumn | AnyColumn> = Filter<TScopeColumns, false> | Sql;
 /** A CHECK constraint for a table, storing its name and filter/SQL expression. */
 declare class Check {
   #private;

package/dist/src/constraints/check.mjs

@@ -34,7 +34,7 @@ var Check = class {
 * ```ts
 * table("public", "projects", { name: varchar({ length: 255 }) }, {
 *   checkConstraints: (t, check) => [
-*     check("check_projects_name_length", gte(sql`char_length(${t.name})`, 1)),
+*     check("check_projects_name_length", gte(length(t.name), 1)),
 *   ],
 * });
 * ```

package/dist/src/db.d.mts

@@ -10,7 +10,6 @@ import { DistinctQuery } from "./query-builders/distinct.mjs";
 import { ExistsQuery } from "./query-builders/exists.mjs";
 import { FirstQuery } from "./query-builders/first.mjs";
 import { InsertBuilder } from "./query-builders/insert.mjs";
-import { InsertReturningQuery } from "./query-builders/insert-returning.mjs";
 import { RawQuery } from "./query-builders/raw.mjs";
 import { RelationQueryBuilder } from "./query-builders/rq.mjs";
 import { UpdateBuilder } from "./query-builders/update.mjs";
@@ -124,13 +123,6 @@ declare class Base<TTName extends string, TTables extends Record<TTName, TableWi
    */
   $distinct<TTable extends TTables[keyof TTables], TColumn extends Valueof<TTable["_"]["columns"]>>(table: TTable, column: TColumn): DistinctQuery<TTable, TColumn, TColumn["ValTypeSelect"][], TPrepare>;
   $distinct<TTable extends TTables[keyof TTables], TColumn extends Valueof<TTable["_"]["columns"]>, TWhere extends FilterExpression<Valueof<TTable["_"]["columns"]>, TPrepare>>(table: TTable, column: TColumn, where: TWhere): DistinctQuery<TTable, TColumn, TColumn["ValTypeSelect"][], TPrepare>;
-  /**
-   * Insert a row and return the inserted row with all columns.
-   * @param table The table to insert into
-   * @param values The values to insert
-   * @returns Promise<T> - the inserted row with all columns including generated values
-   */
-  $insertReturning<TTable extends TTables[keyof TTables]>(table: TTable, values: { [colName in keyof TTable["_"]["columns"] as TTable["_"]["columns"][colName]["ValTypeInsert"] extends never ? never : undefined extends TTable["_"]["columns"][colName]["ValTypeInsert"] ? never : colName]: TTable["_"]["columns"][colName]["ValTypeInsert"] } & { [colName in keyof TTable["_"]["columns"] as TTable["_"]["columns"][colName]["ValTypeInsert"] extends never ? never : undefined extends TTable["_"]["columns"][colName]["ValTypeInsert"] ? colName : never]?: Exclude<TTable["_"]["columns"][colName]["ValTypeInsert"], undefined> }): InsertReturningQuery<TTable, { [ColName in keyof TTable["_"]["columns"]]: TTable["_"]["columns"][ColName]["ValTypeSelect"] }>;
   /**
    * Start building a relational query for the specified table.
    *
@@ -148,7 +140,7 @@ declare class Base<TTName extends string, TTables extends Record<TTName, TableWi
    * @param table The table to query — must have relations registered via `relations()`.
    * @returns A `RelationQueryBuilder` with `.findMany()` and `.findFirst()` methods.
    */
-  query<UTSchema extends string, UTName extends string, TColumns extends Record<string, AnyColumn>>(table: TableWithColumns<UTSchema, UTName, TColumns>): RelationQueryBuilder<UTSchema, UTName, TColumns, TAllRelations[`"${CamelToSnake<UTSchema>}"."${CamelToSnake<UTName>}"`], TAllRelations>;
+  query<UTSchema extends string, UTName extends string, TColumns extends Record<string, AnyColumn>>(table: TableWithColumns<UTSchema, UTName, TColumns>): RelationQueryBuilder<UTSchema, UTName, TColumns, TAllRelations[`"${CamelToSnake<UTSchema>}"."${CamelToSnake<UTName>}"`], TAllRelations, TPrepare>;
   /**
    * Execute a raw SQL query with optional parameter binding and custom result handler.
    * @param query The raw SQL query string with $1, $2, etc. placeholders for parameters

package/dist/src/db.mjs

@@ -7,7 +7,6 @@ import { DistinctQuery } from "./query-builders/distinct.mjs";
 import { ExistsQuery } from "./query-builders/exists.mjs";
 import { FirstQuery } from "./query-builders/first.mjs";
 import { InsertBuilder } from "./query-builders/insert.mjs";
-import { InsertReturningQuery } from "./query-builders/insert-returning.mjs";
 import { RawQuery } from "./query-builders/raw.mjs";
 import { RelationQueryBuilder } from "./query-builders/rq.mjs";
 import { SelectBuilder } from "./query-builders/select.mjs";
@@ -91,15 +90,6 @@ var Base = class {
 		return new DistinctQuery(table, column, where, this.#getExecutor(), this.$.pre);
 	}
 	/**
-	* Insert a row and return the inserted row with all columns.
-	* @param table The table to insert into
-	* @param values The values to insert
-	* @returns Promise<T> - the inserted row with all columns including generated values
-	*/
-	$insertReturning(table, values) {
-		return new InsertReturningQuery(table, values, this.#getExecutor());
-	}
-	/**
 	* Start building a relational query for the specified table.
 	*
 	* Returns a builder with two methods:
@@ -117,7 +107,7 @@ var Base = class {
 	* @returns A `RelationQueryBuilder` with `.findMany()` and `.findFirst()` methods.
 	*/
 	query(table) {
-		return new RelationQueryBuilder(table, this.#allRelations[table._.fullName], this.#allRelations, this.#getExecutor());
+		return new RelationQueryBuilder(table, this.#allRelations[table._.fullName], this.#allRelations, this.#getExecutor(), this.$.pre);
 	}
 	/**
 	* Execute a raw SQL query with optional parameter binding and custom result handler.

package/dist/src/filters/array.d.mts

@@ -1,4 +1,4 @@
-import { TableAnyColumn } from "../table.mjs";
+import { AnyColumn } from "../table.mjs";
 import { Filter } from "./index.mjs";
 import { Arg, IsArg } from "../query-builders/pre.mjs";
 import { Query, QueryContext } from "../query-builders/query.mjs";
@@ -13,7 +13,7 @@ type ArrayElement<T> = T extends readonly (infer E)[] ? E extends readonly unkno
  * ArrayContains filter: col @> ARRAY[values]
  * Returns true if the array column contains all the specified values.
  */
-declare class ArrayContainsFilter<TCol extends TableAnyColumn, TValues extends ArrayElement<TCol["ValType"]>[] | Arg<TCol["ValType"]>> extends Filter<TCol, IsArg<TValues>> {
+declare class ArrayContainsFilter<TCol extends AnyColumn, TValues extends ArrayElement<TCol["ValType"]>[] | Arg<TCol["ValType"]>> extends Filter<TCol, IsArg<TValues>> {
   readonly left: TCol;
   readonly values: TValues;
   constructor(column: TCol, values: TValues);
@@ -26,13 +26,13 @@ declare class ArrayContainsFilter<TCol extends TableAnyColumn, TValues extends A
  * @example
  * db.from(Posts).select().where(arrayContains(Posts.tags, ['typescript', 'postgres']))
  */
-declare function arrayContains<TCol extends TableAnyColumn, TValues extends ArrayElement<TCol["ValType"]>[]>(column: TCol, values: TValues): ArrayContainsFilter<TCol, TValues>;
-declare function arrayContains<TCol extends TableAnyColumn, TValues extends Arg<TCol["ValType"]>>(column: TCol, values: TValues): ArrayContainsFilter<TCol, TValues>;
+declare function arrayContains<TCol extends AnyColumn, TValues extends ArrayElement<TCol["ValType"]>[]>(column: TCol, values: TValues): ArrayContainsFilter<TCol, TValues>;
+declare function arrayContains<TCol extends AnyColumn, TValues extends Arg<TCol["ValType"]>>(column: TCol, values: TValues): ArrayContainsFilter<TCol, TValues>;
 /**
  * ArrayContainedBy filter: col <@ ARRAY[values]
  * Returns true if the array column is contained by (is a subset of) the specified values.
  */
-declare class ArrayContainedByFilter<TCol extends TableAnyColumn, TValues extends ArrayElement<TCol["ValType"]>[] | Arg<TCol["ValType"]>> extends Filter<TCol, IsArg<TValues>> {
+declare class ArrayContainedByFilter<TCol extends AnyColumn, TValues extends ArrayElement<TCol["ValType"]>[] | Arg<TCol["ValType"]>> extends Filter<TCol, IsArg<TValues>> {
   readonly left: TCol;
   readonly values: TValues;
   constructor(column: TCol, values: TValues);
@@ -42,13 +42,13 @@ declare class ArrayContainedByFilter<TCol extends TableAnyColumn, TValues extend
  * Creates a condition that checks if an array column is contained by the specified values.
  * SQL: column <@ ARRAY[values]
  */
-declare function arrayContainedBy<TCol extends TableAnyColumn, TValues extends ArrayElement<TCol["ValType"]>[]>(column: TCol, values: TValues): ArrayContainedByFilter<TCol, TValues>;
-declare function arrayContainedBy<TCol extends TableAnyColumn, TValues extends Arg<TCol["ValType"]>>(column: TCol, values: TValues): ArrayContainedByFilter<TCol, TValues>;
+declare function arrayContainedBy<TCol extends AnyColumn, TValues extends ArrayElement<TCol["ValType"]>[]>(column: TCol, values: TValues): ArrayContainedByFilter<TCol, TValues>;
+declare function arrayContainedBy<TCol extends AnyColumn, TValues extends Arg<TCol["ValType"]>>(column: TCol, values: TValues): ArrayContainedByFilter<TCol, TValues>;
 /**
  * ArrayOverlaps filter: col && ARRAY[values]
  * Returns true if the arrays have any elements in common.
  */
-declare class ArrayOverlapsFilter<TCol extends TableAnyColumn, TValues extends ArrayElement<TCol["ValType"]>[] | Arg<TCol["ValType"]>> extends Filter<TCol, IsArg<TValues>> {
+declare class ArrayOverlapsFilter<TCol extends AnyColumn, TValues extends ArrayElement<TCol["ValType"]>[] | Arg<TCol["ValType"]>> extends Filter<TCol, IsArg<TValues>> {
   readonly left: TCol;
   readonly right: TValues;
   constructor(column: TCol, values: TValues);
@@ -58,13 +58,13 @@ declare class ArrayOverlapsFilter<TCol extends TableAnyColumn, TValues extends A
  * Creates a condition that checks if an array column overlaps with the specified values.
  * SQL: column && ARRAY[values]
  */
-declare function arrayOverlaps<TCol extends TableAnyColumn, TValues extends ArrayElement<TCol["ValType"]>[]>(column: TCol, values: TValues): ArrayOverlapsFilter<TCol, TValues>;
-declare function arrayOverlaps<TCol extends TableAnyColumn, TValues extends Arg<TCol["ValType"]>>(column: TCol, values: TValues): ArrayOverlapsFilter<TCol, TValues>;
+declare function arrayOverlaps<TCol extends AnyColumn, TValues extends ArrayElement<TCol["ValType"]>[]>(column: TCol, values: TValues): ArrayOverlapsFilter<TCol, TValues>;
+declare function arrayOverlaps<TCol extends AnyColumn, TValues extends Arg<TCol["ValType"]>>(column: TCol, values: TValues): ArrayOverlapsFilter<TCol, TValues>;
 /**
  * ArrayHas filter: value = ANY(col)
  * Returns true if the value exists in the array column.
  */
-declare class ArrayHasFilter<TCol extends TableAnyColumn, TRight extends ArrayElement<TCol["ValType"]> | Arg<ArrayElement<TCol["ValType"]>>> extends Filter<TCol, IsArg<TRight>> {
+declare class ArrayHasFilter<TCol extends AnyColumn, TRight extends ArrayElement<TCol["ValType"]> | Arg<ArrayElement<TCol["ValType"]>>> extends Filter<TCol, IsArg<TRight>> {
   readonly left: TCol;
   readonly value: TRight;
   constructor(column: TCol, value: TRight);
@@ -74,13 +74,13 @@ declare class ArrayHasFilter<TCol extends TableAnyColumn, TRight extends ArrayEl
  * Creates a condition that checks if a value exists in an array column.
  * SQL: value = ANY(column)
  */
-declare function arrayHas<TCol extends TableAnyColumn, TRight extends ArrayElement<TCol["ValType"]>>(column: TCol, value: TRight): ArrayHasFilter<TCol, TRight>;
-declare function arrayHas<TCol extends TableAnyColumn, TRight extends Arg<ArrayElement<TCol["ValType"]>>>(column: TCol, value: TRight): ArrayHasFilter<TCol, TRight>;
+declare function arrayHas<TCol extends AnyColumn, TRight extends ArrayElement<TCol["ValType"]>>(column: TCol, value: TRight): ArrayHasFilter<TCol, TRight>;
+declare function arrayHas<TCol extends AnyColumn, TRight extends Arg<ArrayElement<TCol["ValType"]>>>(column: TCol, value: TRight): ArrayHasFilter<TCol, TRight>;
 /**
  * ArrayAll filter: value = ALL(col)
  * Returns true if all elements in the array column equal the value.
  */
-declare class ArrayAllFilter<TCol extends TableAnyColumn, TRight extends ArrayElement<TCol["ValType"]> | Arg<ArrayElement<TCol["ValType"]>>> extends Filter<TCol, IsArg<TRight>> {
+declare class ArrayAllFilter<TCol extends AnyColumn, TRight extends ArrayElement<TCol["ValType"]> | Arg<ArrayElement<TCol["ValType"]>>> extends Filter<TCol, IsArg<TRight>> {
   readonly left: TCol;
   readonly value: TRight;
   constructor(column: TCol, value: TRight);
@@ -90,7 +90,7 @@ declare class ArrayAllFilter<TCol extends TableAnyColumn, TRight extends ArrayEl
  * Creates a condition that checks if all elements in an array column equal a value.
  * SQL: value = ALL(column)
  */
-declare function arrayAll<TCol extends TableAnyColumn, TRight extends ArrayElement<TCol["ValType"]>>(column: TCol, value: TRight): ArrayAllFilter<TCol, TRight>;
-declare function arrayAll<TCol extends TableAnyColumn, TRight extends Arg<ArrayElement<TCol["ValType"]>>>(column: TCol, value: TRight): ArrayAllFilter<TCol, TRight>;
+declare function arrayAll<TCol extends AnyColumn, TRight extends ArrayElement<TCol["ValType"]>>(column: TCol, value: TRight): ArrayAllFilter<TCol, TRight>;
+declare function arrayAll<TCol extends AnyColumn, TRight extends Arg<ArrayElement<TCol["ValType"]>>>(column: TCol, value: TRight): ArrayAllFilter<TCol, TRight>;
 //#endregion
 export { arrayAll, arrayContainedBy, arrayContains, arrayHas, arrayOverlaps };

package/dist/src/filters/index.d.mts

@@ -1,5 +1,5 @@
 import { BasicTypes, Or } from "../types.mjs";
-import { TableAnyColumn } from "../table.mjs";
+import { AnyColumn } from "../table.mjs";
 import { AnyScalarSqlFn } from "../functions/index.mjs";
 import { SelectQuery } from "../query-builders/select.mjs";
 import { Arg, IsArg } from "../query-builders/pre.mjs";
@@ -8,7 +8,7 @@ import { Sql } from "../sql.mjs";
 
 //#region src/filters/index.d.ts
 /** Abstract base class for SQL filter expressions used in `WHERE`/`ON`/`CHECK` clauses. */
-declare abstract class Filter<TColumns extends TableAnyColumn = TableAnyColumn, THasArg extends boolean = false> {
+declare abstract class Filter<TColumns extends AnyColumn = AnyColumn, THasArg extends boolean = false> {
   /** Phantom field: the columns this filter is applied to. */
   readonly $Columns: TColumns;
   /** Phantom field: `true` when this filter embeds at least one `Arg` placeholder. */
@@ -23,12 +23,12 @@ type AnyFilter = Filter<any, any>;
  * or a raw `Sql` snippet. When `TArg` is `true`, filters carrying `Arg`
  * placeholders are also accepted (prepared-query context).
  */
-type FilterExpression<TScopeColumns extends TableAnyColumn, TPrepare extends boolean = false> = Filter<TScopeColumns, TPrepare extends true ? boolean : false> | Sql;
-type StdCondition = FilterExpression<TableAnyColumn>;
+type FilterExpression<TScopeColumns extends AnyColumn, TPrepare extends boolean = false> = Filter<TScopeColumns, TPrepare extends true ? boolean : false> | Sql;
+type StdCondition = FilterExpression<AnyColumn>;
 type HasArg<T> = T extends {
   $HasArg: true;
 } ? true : false;
-declare class ComparisonLeftIsColumn<TLeft extends TableAnyColumn, TOp extends string, TRight extends TLeft["ValType"] | Arg<TLeft["ValType"]> | TableAnyColumn | AnyScalarSqlFn> extends Filter<TLeft, Or<IsArg<TRight>, HasArg<TRight>>> {
+declare class ComparisonLeftIsColumn<TLeft extends AnyColumn, TOp extends string, TRight extends TLeft["ValType"] | Arg<TLeft["ValType"]> | AnyColumn | AnyScalarSqlFn> extends Filter<TLeft, Or<IsArg<TRight>, HasArg<TRight>>> {
   readonly left: TLeft;
   readonly op: TOp;
   readonly right: TRight;
@@ -42,57 +42,57 @@ declare class ComparisonLeftIsSqlFn<TLeft extends AnyScalarSqlFn, TOp extends st
   constructor(field: TLeft, op: TOp, right: TRight);
   toQuery(query: Query, ctx?: QueryContext): void;
 }
-declare function eq<TLeft extends TableAnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "=", TRight>;
-declare function eq<TLeft extends TableAnyColumn, TRight extends Arg<TLeft["ValType"]> | TableAnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "=", TRight>;
+declare function eq<TLeft extends AnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "=", TRight>;
+declare function eq<TLeft extends AnyColumn, TRight extends Arg<TLeft["ValType"]> | AnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "=", TRight>;
 declare function eq<TLeft extends AnyScalarSqlFn, TRight extends BasicTypes>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, "=", TRight>;
 declare function eq<TLeft extends AnyScalarSqlFn, TRight extends AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, "=", TRight>;
-declare function ne<TLeft extends TableAnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "!=", TRight>;
-declare function ne<TLeft extends TableAnyColumn, TRight extends Arg<TLeft["ValType"]> | TableAnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "!=", TRight>;
+declare function ne<TLeft extends AnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "!=", TRight>;
+declare function ne<TLeft extends AnyColumn, TRight extends Arg<TLeft["ValType"]> | AnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "!=", TRight>;
 declare function ne<TLeft extends AnyScalarSqlFn, TRight extends BasicTypes>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, "!=", TRight>;
 declare function ne<TLeft extends AnyScalarSqlFn, TRight extends AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, "!=", TRight>;
-declare function gt<TLeft extends TableAnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, ">", TRight>;
-declare function gt<TLeft extends TableAnyColumn, TRight extends Arg<TLeft["ValType"]> | TableAnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, ">", TRight>;
+declare function gt<TLeft extends AnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, ">", TRight>;
+declare function gt<TLeft extends AnyColumn, TRight extends Arg<TLeft["ValType"]> | AnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, ">", TRight>;
 declare function gt<TLeft extends AnyScalarSqlFn, TRight extends BasicTypes>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, ">", TRight>;
 declare function gt<TLeft extends AnyScalarSqlFn, TRight extends AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, ">", TRight>;
-declare function gte<TLeft extends TableAnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, ">=", TRight>;
-declare function gte<TLeft extends TableAnyColumn, TRight extends Arg<TLeft["ValType"]> | TableAnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, ">=", TRight>;
+declare function gte<TLeft extends AnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, ">=", TRight>;
+declare function gte<TLeft extends AnyColumn, TRight extends Arg<TLeft["ValType"]> | AnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, ">=", TRight>;
 declare function gte<TLeft extends AnyScalarSqlFn, TRight extends BasicTypes>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, ">=", TRight>;
 declare function gte<TLeft extends AnyScalarSqlFn, TRight extends AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, ">=", TRight>;
-declare function lt<TLeft extends TableAnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "<", TRight>;
-declare function lt<TLeft extends TableAnyColumn, TRight extends Arg<TLeft["ValType"]> | TableAnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "<", TRight>;
+declare function lt<TLeft extends AnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "<", TRight>;
+declare function lt<TLeft extends AnyColumn, TRight extends Arg<TLeft["ValType"]> | AnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "<", TRight>;
 declare function lt<TLeft extends AnyScalarSqlFn, TRight extends BasicTypes>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, "<", TRight>;
 declare function lt<TLeft extends AnyScalarSqlFn, TRight extends AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, "<", TRight>;
-declare function lte<TLeft extends TableAnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "<=", TRight>;
-declare function lte<TLeft extends TableAnyColumn, TRight extends Arg<TLeft["ValType"]> | TableAnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "<=", TRight>;
+declare function lte<TLeft extends AnyColumn, TRight extends TLeft["ValType"]>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "<=", TRight>;
+declare function lte<TLeft extends AnyColumn, TRight extends Arg<TLeft["ValType"]> | AnyColumn | AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsColumn<TLeft, "<=", TRight>;
 declare function lte<TLeft extends AnyScalarSqlFn, TRight extends BasicTypes>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, "<=", TRight>;
 declare function lte<TLeft extends AnyScalarSqlFn, TRight extends AnyScalarSqlFn>(left: TLeft, right: TRight): ComparisonLeftIsSqlFn<TLeft, "<=", TRight>;
-declare class IsNullCondition<TCol extends TableAnyColumn> extends Filter<TCol, false> {
+declare class IsNullCondition<TCol extends AnyColumn> extends Filter<TCol, false> {
   readonly field: TCol;
   constructor(field: TCol);
   toQuery(query: Query, ctx?: QueryContext): void;
 }
-declare function isNull<TCol extends TableAnyColumn>(field: TCol): IsNullCondition<TCol>;
-declare class IsNotNullCondition<TCol extends TableAnyColumn> extends Filter<TCol, false> {
+declare function isNull<TCol extends AnyColumn>(field: TCol): IsNullCondition<TCol>;
+declare class IsNotNullCondition<TCol extends AnyColumn> extends Filter<TCol, false> {
   readonly field: TCol;
   constructor(field: TCol);
   toQuery(query: Query, ctx?: QueryContext): void;
 }
-declare function isNotNull<TCol extends TableAnyColumn>(field: TCol): IsNotNullCondition<TCol>;
+declare function isNotNull<TCol extends AnyColumn>(field: TCol): IsNotNullCondition<TCol>;
 type InSelectQuery<TArg extends boolean, TReturn> = SelectQuery<any, any, any, any, any, TArg, any, any, Record<string, TReturn>[]>;
-declare class InCondition<TCol extends TableAnyColumn, TArg extends boolean> extends Filter<TCol, TArg> {
+declare class InCondition<TCol extends AnyColumn, TArg extends boolean> extends Filter<TCol, TArg> {
   readonly field: TCol;
   readonly values: TCol["ValType"][] | InSelectQuery<TArg, TCol["ValType"]>;
   constructor(field: TCol, values: TCol["ValType"][] | InSelectQuery<TArg, TCol["ValType"]>);
   toQuery(query: Query, ctx?: QueryContext): void;
 }
-declare function isIn<TCol extends TableAnyColumn>(field: TCol, values: TCol["ValType"][] | InSelectQuery<boolean, TCol["ValType"]>): InCondition<TCol, false>;
-declare class NotInCondition<TCol extends TableAnyColumn> extends Filter<TCol, false> {
+declare function isIn<TCol extends AnyColumn>(field: TCol, values: TCol["ValType"][] | InSelectQuery<boolean, TCol["ValType"]>): InCondition<TCol, false>;
+declare class NotInCondition<TCol extends AnyColumn> extends Filter<TCol, false> {
   readonly field: TCol;
   readonly values: TCol["ValType"][];
   constructor(field: TCol, values: TCol["ValType"][]);
   toQuery(query: Query, ctx?: QueryContext): void;
 }
-declare function notIn<TCol extends TableAnyColumn>(field: TCol, values: TCol["ValType"][]): NotInCondition<TCol>;
+declare function notIn<TCol extends AnyColumn>(field: TCol, values: TCol["ValType"][]): NotInCondition<TCol>;
 declare class AndCondition<TConditions extends (AnyFilter | Sql)[]> extends Filter<ExtractCols<TConditions[number]>, HasArgOf<TConditions>> {
   readonly conditions: TConditions;
   constructor(...conditions: TConditions);

package/dist/src/filters/postgis.d.mts

@@ -1,5 +1,4 @@
 import { Or } from "../types.mjs";
-import { TableAnyColumn } from "../table.mjs";
 import { Filter } from "./index.mjs";
 import { PointColumn } from "../columns/postgis/geography/point.mjs";
 import { Arg, IsArg } from "../query-builders/pre.mjs";
@@ -7,7 +6,7 @@ import { Query, QueryContext } from "../query-builders/query.mjs";
 
 //#region src/filters/postgis.d.ts
 /** Constrains `TCol` to geography point columns only. */
-type GeographyPointCol = TableAnyColumn<PointColumn<any>>;
+type GeographyPointCol = PointColumn<any>;
 /**
  * Spatial filter: `ST_DWithin(col, ST_SetSRID(ST_MakePoint(lon, lat), srid), radius)`
  * Returns true if the geometry column is within `radius` meters of the given point.

package/dist/src/filters/string.d.mts

@@ -1,11 +1,10 @@
 import { Column } from "../columns/common.mjs";
-import { TableAnyColumn } from "../table.mjs";
 import { Filter } from "./index.mjs";
 import { Arg, IsArg } from "../query-builders/pre.mjs";
 import { Query, QueryContext } from "../query-builders/query.mjs";
 
 //#region src/filters/string.d.ts
-type TextScalarTableColumn = TableAnyColumn<Column<any, any, "text">> & {
+type TextScalarTableColumn = Column<any, any, "text"> & {
   config: {
     dimension?: undefined;
   };

package/dist/src/functions/aggregate.d.mts

@@ -1,4 +1,4 @@
-import { TableAnyColumn } from "../table.mjs";
+import { AnyColumn } from "../table.mjs";
 import { AnyScalarSqlFn, ExprColumns, HasArg, SqlFn } from "./index.mjs";
 import { Query, QueryContext } from "../query-builders/query.mjs";
 
@@ -8,8 +8,8 @@ import { Query, QueryContext } from "../query-builders/query.mjs";
  * Restricts nested expressions to scalars, preventing illegal
  * aggregate-in-aggregate nesting at the type level.
  */
-type AggregateInput = TableAnyColumn | AnyScalarSqlFn;
-type NumericAggregateInput = (TableAnyColumn & {
+type AggregateInput = AnyColumn | AnyScalarSqlFn;
+type NumericAggregateInput = (AnyColumn & {
   $: {
     PgType: "numeric";
   };
@@ -32,7 +32,7 @@ type NumericAggregateInput = (TableAnyColumn & {
  *
  * @template TExpr - The table column to count.
  */
-declare class CountFn<TExpr extends TableAnyColumn> extends SqlFn<TExpr, false, "aggregate", "numeric", number> {
+declare class CountFn<TExpr extends AnyColumn> extends SqlFn<TExpr, false, "aggregate", "numeric", number> {
   private readonly expr;
   readonly isAggregate = true;
   constructor(expr: TExpr);
@@ -62,7 +62,7 @@ declare class CountStarFn extends SqlFn<never, false, "aggregate", "numeric", nu
  *
  * @template TExpr - The table column to count distinct values from.
  */
-declare class CountDistinctFn<TExpr extends TableAnyColumn> extends SqlFn<TExpr, false, "aggregate", "numeric", number> {
+declare class CountDistinctFn<TExpr extends AnyColumn> extends SqlFn<TExpr, false, "aggregate", "numeric", number> {
   private readonly expr;
   readonly isAggregate = true;
   constructor(expr: TExpr);
@@ -84,7 +84,7 @@ declare function count(star: "*"): CountStarFn;
  * @example
  * db.from(Orders).select({ total: count(Orders.id) });
  */
-declare function count<TExpr extends TableAnyColumn>(expr: TExpr): CountFn<TExpr>;
+declare function count<TExpr extends AnyColumn>(expr: TExpr): CountFn<TExpr>;
 /**
  * Creates a SQL aggregate expression `count(DISTINCT col)` that counts distinct non-null values.
  *
@@ -94,7 +94,7 @@ declare function count<TExpr extends TableAnyColumn>(expr: TExpr): CountFn<TExpr
  * @example
  * db.from(Orders).select({ uniqueUsers: countDistinct(Orders.userId) });
  */
-declare function countDistinct<TExpr extends TableAnyColumn>(expr: TExpr): CountDistinctFn<TExpr>;
+declare function countDistinct<TExpr extends AnyColumn>(expr: TExpr): CountDistinctFn<TExpr>;
 /**
  * SQL aggregate expression: `sum(col)`
  * Returns the sum of all non-null values in the column, or `null` if no rows match.

package/dist/src/functions/index.d.mts

@@ -1,4 +1,4 @@
-import { TableAnyColumn } from "../table.mjs";
+import { AnyColumn } from "../table.mjs";
 import { Query, QueryContext } from "../query-builders/query.mjs";
 import { Sql } from "../sql.mjs";
 
@@ -24,7 +24,7 @@ import { Sql } from "../sql.mjs";
  *   enabling type-safe nested function calls (e.g. `lower(trim(col))`).
  * @template TTsType - The TypeScript type this expression evaluates to.
  */
-declare abstract class SqlFn<TColumn extends TableAnyColumn, THasArg extends boolean = false, TFnType extends "aggregate" | "scalar" = "aggregate" | "scalar", TPgType extends string = string, TTsType = any> {
+declare abstract class SqlFn<TColumn extends AnyColumn, THasArg extends boolean = false, TFnType extends "aggregate" | "scalar" = "aggregate" | "scalar", TPgType extends string = string, TTsType = any> {
   readonly $: {
     kind: "sqlFn";
     TsType: TTsType;
@@ -75,7 +75,7 @@ type ExprColumns<TExpr> = TExpr extends {
   $: {
     kind: "sqlFn";
   };
-  $Columns: infer TCol extends TableAnyColumn;
+  $Columns: infer TCol extends AnyColumn;
 } ? TCol : TExpr extends {
   $: {
     kind: "column";

package/dist/src/functions/numeric.d.mts

@@ -1,11 +1,11 @@
 import { Or } from "../types.mjs";
-import { AnyScalarTableColumn } from "../table.mjs";
+import { AnyScalarColumn } from "../table.mjs";
 import { AnySqlFn, ExprColumns, HasArg, SqlFn } from "./index.mjs";
 import { Arg, IsArg } from "../query-builders/pre.mjs";
 import { Query, QueryContext } from "../query-builders/query.mjs";
 
 //#region src/functions/numeric.d.ts
-declare class AbsFn<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
+declare class AbsFn<TExpr extends (AnyScalarColumn | AnySqlFn) & {
   $: {
     PgType: "numeric";
   };
@@ -15,12 +15,12 @@ declare class AbsFn<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
   toQuery(query: Query, ctx?: QueryContext): void;
 }
 /** Returns the absolute value of a numeric expression. */
-declare function abs<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
+declare function abs<TExpr extends (AnyScalarColumn | AnySqlFn) & {
   $: {
     PgType: "numeric";
   };
 }>(expr: TExpr): AbsFn<TExpr>;
-declare class ModFn<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
+declare class ModFn<TExpr extends (AnyScalarColumn | AnySqlFn) & {
   $: {
     PgType: "numeric";
   };
@@ -31,12 +31,12 @@ declare class ModFn<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
   toQuery(query: Query, ctx?: QueryContext): void;
 }
 /** Returns the remainder of `expr` divided by `n`. */
-declare function mod<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
+declare function mod<TExpr extends (AnyScalarColumn | AnySqlFn) & {
   $: {
     PgType: "numeric";
   };
 }, TN extends number | Arg<number>>(expr: TExpr, n: TN): ModFn<TExpr, TN>;
-declare class RoundFn<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
+declare class RoundFn<TExpr extends (AnyScalarColumn | AnySqlFn) & {
   $: {
     PgType: "numeric";
   };
@@ -47,12 +47,12 @@ declare class RoundFn<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
   toQuery(query: Query, ctx?: QueryContext): void;
 }
 /** Rounds a numeric expression to the nearest integer, or to `decimals` decimal places. */
-declare function round<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
+declare function round<TExpr extends (AnyScalarColumn | AnySqlFn) & {
   $: {
     PgType: "numeric";
   };
 }, TDecimals extends number | Arg<number> | undefined = undefined>(expr: TExpr, decimals?: TDecimals): RoundFn<TExpr, TDecimals>;
-declare class CeilFn<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
+declare class CeilFn<TExpr extends (AnyScalarColumn | AnySqlFn) & {
   $: {
     PgType: "numeric";
   };
@@ -62,12 +62,12 @@ declare class CeilFn<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
   toQuery(query: Query, ctx?: QueryContext): void;
 }
 /** Returns the smallest integer greater than or equal to the numeric expression. */
-declare function ceil<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
+declare function ceil<TExpr extends (AnyScalarColumn | AnySqlFn) & {
   $: {
     PgType: "numeric";
   };
 }>(expr: TExpr): CeilFn<TExpr>;
-declare class FloorFn<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
+declare class FloorFn<TExpr extends (AnyScalarColumn | AnySqlFn) & {
   $: {
     PgType: "numeric";
   };
@@ -77,7 +77,7 @@ declare class FloorFn<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
   toQuery(query: Query, ctx?: QueryContext): void;
 }
 /** Returns the largest integer less than or equal to the numeric expression. */
-declare function floor<TExpr extends (AnyScalarTableColumn | AnySqlFn) & {
+declare function floor<TExpr extends (AnyScalarColumn | AnySqlFn) & {
   $: {
     PgType: "numeric";
   };