durcno 1.0.0-alpha.12 → 1.0.0-alpha.14

package/README.md

@@ -26,6 +26,7 @@
 - **🔌 Multiple Drivers** — Support for `pg`, `postgres`, `bun`, and `pglite` drivers.
 - **🛡️ Zod Integration** — Built-in Zod validators for schema validation and type inference.
 - **🌍 PostGIS Support** — First-class geographic column types for spatial queries.
+- **🔍 pgvector Support** — Vector similarity search with type-safe distance functions and indexes.
 
 ## Setup
 

package/dist/bin.cjs

@@ -9411,7 +9411,9 @@ function generateMigration(prev, curr, direction, renamedTables = {}, renamedCol
       }
       statements.push(tableBuilder.join("\n"));
       for (const idx of Object.values(currTable.indexes)) {
-        const cols = idx.columns.map((c) => `"${c}"`).join(", ");
+        const cols = idx.columns.map(
+          (c) => c.opclass ? `["${c.name}", "${c.opclass}"]` : `"${c.name}"`
+        ).join(", ");
         let indexStmt = `ddl.createIndex("${idx.name}").on("${currTable.schema}", "${currTable.name}", [${cols}]).using("${idx.type}")`;
         if (idx.unique) indexStmt += ".unique()";
         statements.push(indexStmt);
@@ -9531,7 +9533,9 @@ function generateAlterTableStmts(prevTable, currTable, tableName, curr, statemen
   for (const idxName in currTable.indexes) {
     if (!prevTable.indexes[idxName]) {
       const idx = currTable.indexes[idxName];
-      const cols = idx.columns.map((c) => `"${c}"`).join(", ");
+      const cols = idx.columns.map(
+        (c) => c.opclass ? `["${c.name}", "${c.opclass}"]` : `"${c.name}"`
+      ).join(", ");
       let indexStmt = `ddl.createIndex("${idx.name}").on("${currTable.schema}", "${currTable.name}", [${cols}]).using("${idx.type}")`;
       if (idx.unique) indexStmt += ".unique()";
       statements.push(indexStmt);
@@ -10451,7 +10455,7 @@ async function status(options) {
 }
 
 // src/cli/index.ts
-program.version("1.0.0-alpha.11");
+program.version("1.0.0-alpha.13");
 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 { AnyColumn, 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
@@ -299,6 +308,19 @@ declare abstract class Column<TConfig extends ColumnConfig, TColVal, TPgType ext
    * @returns an `Arg` instance with the type of this column
    */
   arg(): Arg<this["ValType"]>;
+  /**
+   * Applies an operator class to this column for index creation.
+   *
+   * @param opclass - The operator class to use (e.g., 'vector_l2_ops').
+   * @returns an IndexOn instance wrapping this column and its opclass.
+   */
+  opclass(opclass: string): IndexOn<this>;
+}
+declare class IndexOn<TCol extends AnyColumn = AnyColumn> {
+  readonly column: StdTableColumn<TCol>;
+  readonly opclassStr: string;
+  static readonly [entityType] = "IndexOn";
+  constructor(column: StdTableColumn<TCol>, opclassStr: string);
 }
 //#endregion
-export { Column, ColumnConfig, Dimension, GeneratedAlways, GeneratedByDefault, OnDeleteAction, array, notNull, primaryKey, tuple, unique };
+export { Column, ColumnConfig, Dimension, GeneratedAlways, GeneratedByDefault, IndexOn, OnDeleteAction, Tuple, array, notNull, primaryKey, tuple, unique };

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>
@@ -377,6 +390,22 @@ var Column = class {
 	arg() {
 		return new Arg(this.toDriver.bind(this), this.sqlCast);
 	}
+	/**
+	* Applies an operator class to this column for index creation.
+	*
+	* @param opclass - The operator class to use (e.g., 'vector_l2_ops').
+	* @returns an IndexOn instance wrapping this column and its opclass.
+	*/
+	opclass(opclass) {
+		return new IndexOn(this, opclass);
+	}
+};
+var IndexOn = class {
+	static [entityType] = "IndexOn";
+	constructor(column, opclassStr) {
+		this.column = column;
+		this.opclassStr = opclassStr;
+	}
 };
 //#endregion
-export { Column, Dimension, array, identity, notNull, primaryKey, tuple, unique };
+export { Column, Dimension, IndexOn, array, identity, notNull, primaryKey, tuple, unique };

package/dist/src/columns/pgvector/index.d.mts

@@ -0,0 +1,122 @@
+import { Column, ColumnConfig, Tuple } from "../common.mjs";
+import { Sql } from "../../sql.mjs";
+import * as z from "zod";
+
+//#region src/columns/pgvector/index.d.ts
+type VectorConfig = ColumnConfig & {
+  dimensions?: number;
+};
+/** Derives a fixed-length numeric tuple when `dimensions` is a number literal, otherwise `number[]`. */
+type VectorValue<TConfig extends VectorConfig> = TConfig extends {
+  dimensions: infer D extends number;
+} ? number extends D ? number[] : Tuple<number, D> : number[];
+declare class VectorColumn<TConfig extends VectorConfig> extends Column<TConfig, VectorValue<TConfig>, "numeric"> {
+  #private;
+  static readonly id = "Column.Vector";
+  constructor(config: TConfig);
+  get sqlTypeScalar(): string;
+  get sqlCastScalar(): string;
+  get zodTypeScaler(): TConfig["dimensions"] extends number ? z.ZodTuple<Tuple<z.ZodNumber, TConfig["dimensions"]>, null> : z.ZodArray<z.ZodNumber>;
+  toDriverScalar(value: VectorValue<TConfig> | Sql | null): string | null;
+  toSQLScalar(value: VectorValue<TConfig> | Sql | null): string;
+  fromDriverScalar(value: unknown): VectorValue<TConfig> | null;
+}
+/**
+ * Creates a `vector` column. PostgreSQL pgvector dense vector type, maps to `number[]`.
+ *
+ * @example
+ * ```ts
+ * vector({ dimensions: 1536, notNull }) // vector(1536) NOT NULL
+ * ```
+ *
+ * @param config.dimensions - Fixed vector dimension length
+ */
+declare function vector<const TConfig extends VectorConfig>(config?: TConfig): VectorColumn<TConfig>;
+type HalfvecConfig = ColumnConfig & {
+  dimensions?: number;
+};
+/** Derives a fixed-length numeric tuple when `dimensions` is a number literal, otherwise `number[]`. */
+type HalfvecValue<TConfig extends HalfvecConfig> = TConfig extends {
+  dimensions: infer D extends number;
+} ? number extends D ? number[] : Tuple<number, D> : number[];
+declare class HalfvecColumn<TConfig extends HalfvecConfig> extends Column<TConfig, HalfvecValue<TConfig>, "numeric"> {
+  #private;
+  static readonly id = "Column.Halfvec";
+  constructor(config: TConfig);
+  get sqlTypeScalar(): string;
+  get sqlCastScalar(): string;
+  get zodTypeScaler(): TConfig["dimensions"] extends number ? z.ZodTuple<Tuple<z.ZodNumber, TConfig["dimensions"]>, null> : z.ZodArray<z.ZodNumber>;
+  toDriverScalar(value: HalfvecValue<TConfig> | Sql | null): string | null;
+  toSQLScalar(value: HalfvecValue<TConfig> | Sql | null): string;
+  fromDriverScalar(value: unknown): HalfvecValue<TConfig> | null;
+}
+/**
+ * Creates a `halfvec` column. PostgreSQL pgvector half precision vector type, maps to `number[]`.
+ *
+ * @example
+ * ```ts
+ * halfvec({ dimensions: 1536, notNull }) // halfvec(1536) NOT NULL
+ * ```
+ *
+ * @param config.dimensions - Fixed vector dimension length
+ */
+declare function halfvec<const TConfig extends HalfvecConfig>(config?: TConfig): HalfvecColumn<TConfig>;
+type SparsevecConfig = ColumnConfig & {
+  dimensions?: number;
+};
+declare class SparsevecColumn<TConfig extends SparsevecConfig> extends Column<TConfig, string, "string"> {
+  #private;
+  static readonly id = "Column.Sparsevec";
+  constructor(config: TConfig);
+  get sqlTypeScalar(): string;
+  get sqlCastScalar(): string;
+  get zodTypeScaler(): z.ZodString;
+  toDriverScalar(value: string | Sql | null): string | null;
+  toSQLScalar(value: string | Sql | null): string;
+  fromDriverScalar(value: string | null): string | null;
+}
+/**
+ * Creates a `sparsevec` column. PostgreSQL pgvector sparse vector type, maps to `string`.
+ *
+ * @example
+ * ```ts
+ * sparsevec({ dimensions: 1000, notNull }) // sparsevec(1000) NOT NULL
+ * ```
+ *
+ * @param config.dimensions - Fixed vector dimension length
+ */
+declare function sparsevec<const TConfig extends SparsevecConfig>(config?: TConfig): SparsevecColumn<TConfig>;
+type BitConfig = ColumnConfig & {
+  length?: number;
+};
+declare class BitColumn<TConfig extends BitConfig> extends Column<TConfig, string, "string"> {
+  #private;
+  static readonly id = "Column.Bit";
+  constructor(config: TConfig);
+  get sqlTypeScalar(): string;
+  get sqlCastScalar(): string;
+  get zodTypeScaler(): z.ZodString;
+  toDriverScalar(value: string | Sql | null): string | null;
+  toSQLScalar(value: string | Sql | null): string;
+  fromDriverScalar(value: string | null): string | null;
+}
+/**
+ * Creates a `bit` column. PostgreSQL bit string type, maps to `string`.
+ *
+ * @example
+ * ```ts
+ * bit({ length: 16, notNull }) // bit(16) NOT NULL
+ * ```
+ *
+ * @param config.length - Fixed bit string length
+ */
+declare function bit<const TConfig extends BitConfig>(config?: TConfig): BitColumn<TConfig>;
+/** All pgvector column constructors grouped as a single object. */
+declare const pgvector: {
+  vector: typeof vector;
+  halfvec: typeof halfvec;
+  sparsevec: typeof sparsevec;
+  bit: typeof bit;
+};
+//#endregion
+export { pgvector };

package/dist/src/columns/pgvector/index.mjs

@@ -0,0 +1,195 @@
+import { Column } from "../common.mjs";
+import { Sql } from "../../sql.mjs";
+import * as z from "zod";
+//#region src/columns/pgvector/index.ts
+var VectorColumn = class extends Column {
+	static id = "Column.Vector";
+	#dimensions;
+	constructor(config) {
+		super(config);
+		this.#dimensions = config.dimensions;
+	}
+	get sqlTypeScalar() {
+		return this.#dimensions ? `vector(${this.#dimensions})` : "vector";
+	}
+	get sqlCastScalar() {
+		return this.sqlTypeScalar;
+	}
+	get zodTypeScaler() {
+		if (this.#dimensions === void 0) return z.array(z.number());
+		return z.tuple(Array.from({ length: this.#dimensions }, () => z.number()));
+	}
+	toDriverScalar(value) {
+		if (value === null) return null;
+		return value instanceof Sql ? value.string : `[${value.join(",")}]`;
+	}
+	toSQLScalar(value) {
+		if (value === null) return "NULL";
+		return value instanceof Sql ? value.string : `'[${value.join(",")}]'`;
+	}
+	fromDriverScalar(value) {
+		if (value === null) return null;
+		if (Array.isArray(value)) return value;
+		if (typeof value === "string") try {
+			return JSON.parse(value);
+		} catch {
+			return null;
+		}
+		return null;
+	}
+};
+/**
+* Creates a `vector` column. PostgreSQL pgvector dense vector type, maps to `number[]`.
+*
+* @example
+* ```ts
+* vector({ dimensions: 1536, notNull }) // vector(1536) NOT NULL
+* ```
+*
+* @param config.dimensions - Fixed vector dimension length
+*/
+function vector(config = {}) {
+	return new VectorColumn(config);
+}
+var HalfvecColumn = class extends Column {
+	static id = "Column.Halfvec";
+	#dimensions;
+	constructor(config) {
+		super(config);
+		this.#dimensions = config.dimensions;
+	}
+	get sqlTypeScalar() {
+		return this.#dimensions ? `halfvec(${this.#dimensions})` : "halfvec";
+	}
+	get sqlCastScalar() {
+		return this.sqlTypeScalar;
+	}
+	get zodTypeScaler() {
+		if (this.#dimensions === void 0) return z.array(z.number());
+		return z.tuple(Array.from({ length: this.#dimensions }, () => z.number()));
+	}
+	toDriverScalar(value) {
+		if (value === null) return null;
+		return value instanceof Sql ? value.string : `[${value.join(",")}]`;
+	}
+	toSQLScalar(value) {
+		if (value === null) return "NULL";
+		return value instanceof Sql ? value.string : `'[${value.join(",")}]'`;
+	}
+	fromDriverScalar(value) {
+		if (value === null) return null;
+		if (Array.isArray(value)) return value;
+		if (typeof value === "string") try {
+			return JSON.parse(value);
+		} catch {
+			return null;
+		}
+		return null;
+	}
+};
+/**
+* Creates a `halfvec` column. PostgreSQL pgvector half precision vector type, maps to `number[]`.
+*
+* @example
+* ```ts
+* halfvec({ dimensions: 1536, notNull }) // halfvec(1536) NOT NULL
+* ```
+*
+* @param config.dimensions - Fixed vector dimension length
+*/
+function halfvec(config = {}) {
+	return new HalfvecColumn(config);
+}
+var SparsevecColumn = class extends Column {
+	static id = "Column.Sparsevec";
+	#dimensions;
+	constructor(config) {
+		super(config);
+		this.#dimensions = config.dimensions;
+	}
+	get sqlTypeScalar() {
+		return this.#dimensions ? `sparsevec(${this.#dimensions})` : "sparsevec";
+	}
+	get sqlCastScalar() {
+		return this.sqlTypeScalar;
+	}
+	get zodTypeScaler() {
+		return z.string();
+	}
+	toDriverScalar(value) {
+		if (value === null) return null;
+		return value instanceof Sql ? value.string : value;
+	}
+	toSQLScalar(value) {
+		if (value === null) return "NULL";
+		return value instanceof Sql ? value.string : `'${value.replace(/'/g, "''")}'`;
+	}
+	fromDriverScalar(value) {
+		return value;
+	}
+};
+/**
+* Creates a `sparsevec` column. PostgreSQL pgvector sparse vector type, maps to `string`.
+*
+* @example
+* ```ts
+* sparsevec({ dimensions: 1000, notNull }) // sparsevec(1000) NOT NULL
+* ```
+*
+* @param config.dimensions - Fixed vector dimension length
+*/
+function sparsevec(config = {}) {
+	return new SparsevecColumn(config);
+}
+var BitColumn = class extends Column {
+	static id = "Column.Bit";
+	#length;
+	constructor(config) {
+		super(config);
+		this.#length = config.length;
+	}
+	get sqlTypeScalar() {
+		return this.#length ? `bit(${this.#length})` : "bit";
+	}
+	get sqlCastScalar() {
+		return this.sqlTypeScalar;
+	}
+	get zodTypeScaler() {
+		let base = z.string().regex(/^[01]+$/);
+		if (this.#length !== void 0) base = base.length(this.#length);
+		return base;
+	}
+	toDriverScalar(value) {
+		if (value === null) return null;
+		return value instanceof Sql ? value.string : value;
+	}
+	toSQLScalar(value) {
+		if (value === null) return "NULL";
+		return value instanceof Sql ? value.string : `B'${value}'`;
+	}
+	fromDriverScalar(value) {
+		return value;
+	}
+};
+/**
+* Creates a `bit` column. PostgreSQL bit string type, maps to `string`.
+*
+* @example
+* ```ts
+* bit({ length: 16, notNull }) // bit(16) NOT NULL
+* ```
+*
+* @param config.length - Fixed bit string length
+*/
+function bit(config = {}) {
+	return new BitColumn(config);
+}
+/** All pgvector column constructors grouped as a single object. */
+const pgvector = {
+	vector,
+	halfvec,
+	sparsevec,
+	bit
+};
+//#endregion
+export { pgvector };

package/dist/src/connectors/bun.mjs

@@ -59,7 +59,7 @@ var BunPool = class extends $Pool {
 	#pool;
 	constructor(options) {
 		super(options);
-		this.#pool = new Bun.SQL(getUrlFromDbCredentials(options.dbCredentials), { max: options.pool?.max ?? 10 });
+		this.#pool = new Bun.SQL(getUrlFromDbCredentials(options.dbCredentials), { max: options.pool?.max ?? 5 });
 		this.query = this.#pool.unsafe.bind(this.#pool);
 	}
 	async connect() {

package/dist/src/connectors/pg.mjs

@@ -66,7 +66,7 @@ var PgPool = class extends $Pool {
 		super(options);
 		this.#pool = new Pool({
 			connectionString: getUrlFromDbCredentials(options.dbCredentials),
-			max: options.pool?.max ?? 10
+			max: options.pool?.max ?? 5
 		});
 		this.query = this.#pool.query.bind(this.#pool);
 	}

package/dist/src/connectors/postgres.mjs

@@ -60,7 +60,7 @@ var PostgresPool = class extends $Pool {
 	#sql;
 	constructor(options) {
 		super(options);
-		this.#sql = postgresLib(getUrlFromDbCredentials(options.dbCredentials), { max: options.pool?.max ?? 10 });
+		this.#sql = postgresLib(getUrlFromDbCredentials(options.dbCredentials), { max: options.pool?.max ?? 5 });
 		this.query = this.#sql.unsafe.bind(this.#sql);
 	}
 	async connect() {}

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 };