durcno 1.0.0-alpha.13 → 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.12");
+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,6 +1,6 @@
 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";
@@ -308,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

@@ -390,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/functions/pgvector.d.mts

@@ -0,0 +1,33 @@
+import { AnyColumn } from "../table.mjs";
+import { SqlFn } from "./index.mjs";
+import { Arg, IsArg } from "../query-builders/pre.mjs";
+import { Query, QueryContext } from "../query-builders/query.mjs";
+
+//#region src/functions/pgvector.d.ts
+declare class DistanceFn<TCol extends AnyColumn, TOp extends string = string, TVal extends TCol["ValType"] | Arg<TCol["ValType"]> = TCol["ValType"] | Arg<TCol["ValType"]>> extends SqlFn<TCol, IsArg<TVal>, "scalar", "numeric", number> {
+  private readonly col;
+  private readonly val;
+  private readonly op;
+  constructor(col: TCol, val: TVal, op: TOp);
+  toQuery(query: Query, ctx?: QueryContext): void;
+}
+/** Computes the L2 distance using the `<->` operator. */
+declare function l2Distance<TCol extends AnyColumn>(col: TCol, val: TCol["ValType"]): DistanceFn<TCol, "<->", TCol["ValType"]>;
+declare function l2Distance<TCol extends AnyColumn>(col: TCol, val: Arg<TCol["ValType"]>): DistanceFn<TCol, "<->", Arg<TCol["ValType"]>>;
+/** Computes the inner product using the `<#>` operator. */
+declare function innerProduct<TCol extends AnyColumn>(col: TCol, val: TCol["ValType"]): DistanceFn<TCol, "<#>", TCol["ValType"]>;
+declare function innerProduct<TCol extends AnyColumn>(col: TCol, val: Arg<TCol["ValType"]>): DistanceFn<TCol, "<#>", Arg<TCol["ValType"]>>;
+/** Computes the cosine distance using the `<=>` operator. */
+declare function cosineDistance<TCol extends AnyColumn>(col: TCol, val: TCol["ValType"]): DistanceFn<TCol, "<=>", TCol["ValType"]>;
+declare function cosineDistance<TCol extends AnyColumn>(col: TCol, val: Arg<TCol["ValType"]>): DistanceFn<TCol, "<=>", Arg<TCol["ValType"]>>;
+/** Computes the L1 distance using the `<+>` operator. */
+declare function l1Distance<TCol extends AnyColumn>(col: TCol, val: TCol["ValType"]): DistanceFn<TCol, "<+>", TCol["ValType"]>;
+declare function l1Distance<TCol extends AnyColumn>(col: TCol, val: Arg<TCol["ValType"]>): DistanceFn<TCol, "<+>", Arg<TCol["ValType"]>>;
+/** Computes the Hamming distance using the `<~>` operator. */
+declare function hammingDistance<TCol extends AnyColumn>(col: TCol, val: TCol["ValType"]): DistanceFn<TCol, "<~>", TCol["ValType"]>;
+declare function hammingDistance<TCol extends AnyColumn>(col: TCol, val: Arg<TCol["ValType"]>): DistanceFn<TCol, "<~>", Arg<TCol["ValType"]>>;
+/** Computes the Jaccard distance using the `<%>` operator. */
+declare function jaccardDistance<TCol extends AnyColumn>(col: TCol, val: TCol["ValType"]): DistanceFn<TCol, "<%>", TCol["ValType"]>;
+declare function jaccardDistance<TCol extends AnyColumn>(col: TCol, val: Arg<TCol["ValType"]>): DistanceFn<TCol, "<%>", Arg<TCol["ValType"]>>;
+//#endregion
+export { cosineDistance, hammingDistance, innerProduct, jaccardDistance, l1Distance, l2Distance };

package/dist/src/functions/pgvector.mjs

@@ -0,0 +1,38 @@
+import { SqlFn } from "./index.mjs";
+import { Arg } from "../query-builders/pre.mjs";
+import { is } from "../entity.mjs";
+//#region src/functions/pgvector.ts
+var DistanceFn = class extends SqlFn {
+	constructor(col, val, op) {
+		super();
+		this.col = col;
+		this.val = val;
+		this.op = op;
+	}
+	toQuery(query, ctx) {
+		this.col.toQuery(query, ctx);
+		query.sql += ` ${this.op} `;
+		if (is(this.val, Arg)) query.addArg(this.val);
+		else query.sql += this.col.toSQL(this.val, { cast: true });
+	}
+};
+function l2Distance(col, val) {
+	return new DistanceFn(col, val, "<->");
+}
+function innerProduct(col, val) {
+	return new DistanceFn(col, val, "<#>");
+}
+function cosineDistance(col, val) {
+	return new DistanceFn(col, val, "<=>");
+}
+function l1Distance(col, val) {
+	return new DistanceFn(col, val, "<+>");
+}
+function hammingDistance(col, val) {
+	return new DistanceFn(col, val, "<~>");
+}
+function jaccardDistance(col, val) {
+	return new DistanceFn(col, val, "<%>");
+}
+//#endregion
+export { cosineDistance, hammingDistance, innerProduct, jaccardDistance, l1Distance, l2Distance };

package/dist/src/index.d.mts

@@ -24,6 +24,7 @@ import { json } from "./columns/json.mjs";
 import { jsonb } from "./columns/jsonb.mjs";
 import { macaddr } from "./columns/macaddr.mjs";
 import { numeric } from "./columns/numeric.mjs";
+import { pgvector } from "./columns/pgvector/index.mjs";
 import { geography } from "./columns/postgis/geography/index.mjs";
 import { serial } from "./columns/serial.mjs";
 import { smallint } from "./columns/smallint.mjs";
@@ -38,6 +39,7 @@ import { stContains, stDWithin, stIntersects, stWithin } from "./filters/postgis
 import { contains, endsWith, like, startsWith } from "./filters/string.mjs";
 import { avg, count, countDistinct, max, min, sum } from "./functions/aggregate.mjs";
 import { abs, ceil, floor, mod, round } from "./functions/numeric.mjs";
+import { cosineDistance, hammingDistance, innerProduct, jaccardDistance, l1Distance, l2Distance } from "./functions/pgvector.mjs";
 import { stDistance } from "./functions/postgis.mjs";
 import { left, length, lower, position, right, trim, upper } from "./functions/string.mjs";
 import { Migrations, pk } from "./models.mjs";
@@ -98,4 +100,4 @@ type Config<T extends Connector = Connector> = {
   connector: T;
 };
 //#endregion
-export { $, type $Client, type AnyColumn, Arg, Column, type ColumnConfig, Config, type ConnectorOptions, Dimension, Filter, type Key, Migrations, type Prettify, PrimaryKeyConstraint, Query, type QueryContext, type QueryLogger, Sql, SqlFn, type TableColumn, UniqueConstraint, type UuidVersion, abs, and, array, arrayAll, arrayContainedBy, arrayContains, arrayHas, arrayOverlaps, asc, avg, bigint, bigserial, boolean, bytea, ceil, char, cidr, contains, count, countDistinct, database, date, defineConfig, desc, endsWith, enumed, enumtype, eq, fk, floor, geography, gt, gte, index, inet, integer, isIn, isNotNull, isNull, json, jsonb, left, length, like, lower, lt, lte, macaddr, many, max, min, mod, ne, notIn, notNull, now, numeric, one, or, pk, position, prequery, primaryKey, primaryKeyConstraint, relations, right, round, sequence, serial, smallint, smallserial, sql, stContains, stDWithin, stDistance, stIntersects, stWithin, startsWith, sum, table, text, time, timestamp, trim, tuple, unique, uniqueConstraint, uniqueIndex, upper, uuid, uuidv4, uuidv7, varchar };
+export { $, type $Client, type AnyColumn, Arg, Column, type ColumnConfig, Config, type ConnectorOptions, Dimension, Filter, type Key, Migrations, type Prettify, PrimaryKeyConstraint, Query, type QueryContext, type QueryLogger, Sql, SqlFn, type TableColumn, UniqueConstraint, type UuidVersion, abs, and, array, arrayAll, arrayContainedBy, arrayContains, arrayHas, arrayOverlaps, asc, avg, bigint, bigserial, boolean, bytea, ceil, char, cidr, contains, cosineDistance, count, countDistinct, database, date, defineConfig, desc, endsWith, enumed, enumtype, eq, fk, floor, geography, gt, gte, hammingDistance, index, inet, innerProduct, integer, isIn, isNotNull, isNull, jaccardDistance, json, jsonb, l1Distance, l2Distance, left, length, like, lower, lt, lte, macaddr, many, max, min, mod, ne, notIn, notNull, now, numeric, one, or, pgvector, pk, position, prequery, primaryKey, primaryKeyConstraint, relations, right, round, sequence, serial, smallint, smallserial, sql, stContains, stDWithin, stDistance, stIntersects, stWithin, startsWith, sum, table, text, time, timestamp, trim, tuple, unique, uniqueConstraint, uniqueIndex, upper, uuid, uuidv4, uuidv7, varchar };

package/dist/src/index.mjs

@@ -18,6 +18,7 @@ import { json } from "./columns/json.mjs";
 import { jsonb } from "./columns/jsonb.mjs";
 import { macaddr } from "./columns/macaddr.mjs";
 import { numeric } from "./columns/numeric.mjs";
+import { pgvector } from "./columns/pgvector/index.mjs";
 import { geography } from "./columns/postgis/geography/index.mjs";
 import { serial } from "./columns/serial.mjs";
 import { smallint } from "./columns/smallint.mjs";
@@ -38,6 +39,7 @@ import { stContains, stDWithin, stIntersects, stWithin } from "./filters/postgis
 import { contains, endsWith, like, startsWith } from "./filters/string.mjs";
 import { avg, count, countDistinct, max, min, sum } from "./functions/aggregate.mjs";
 import { abs, ceil, floor, mod, round } from "./functions/numeric.mjs";
+import { cosineDistance, hammingDistance, innerProduct, jaccardDistance, l1Distance, l2Distance } from "./functions/pgvector.mjs";
 import { stDistance } from "./functions/postgis.mjs";
 import { left, length, lower, position, right, trim, upper } from "./functions/string.mjs";
 import { index, uniqueIndex } from "./indexes.mjs";
@@ -80,4 +82,4 @@ function defineConfig(config) {
 	return config;
 }
 //#endregion
-export { $, Arg, Column, Dimension, Filter, Migrations, PrimaryKeyConstraint, Query, Sql, SqlFn, UniqueConstraint, abs, and, array, arrayAll, arrayContainedBy, arrayContains, arrayHas, arrayOverlaps, asc, avg, bigint, bigserial, boolean, bytea, ceil, char, cidr, contains, count, countDistinct, database, date, defineConfig, desc, endsWith, enumed, enumtype, eq, fk, floor, geography, gt, gte, index, inet, integer, isIn, isNotNull, isNull, json, jsonb, left, length, like, lower, lt, lte, macaddr, many, max, min, mod, ne, notIn, notNull, now, numeric, one, or, pk, position, prequery, primaryKey, primaryKeyConstraint, relations, right, round, sequence, serial, smallint, smallserial, sql, stContains, stDWithin, stDistance, stIntersects, stWithin, startsWith, sum, table, text, time, timestamp, trim, tuple, unique, uniqueConstraint, uniqueIndex, upper, uuid, uuidv4, uuidv7, varchar };
+export { $, Arg, Column, Dimension, Filter, Migrations, PrimaryKeyConstraint, Query, Sql, SqlFn, UniqueConstraint, abs, and, array, arrayAll, arrayContainedBy, arrayContains, arrayHas, arrayOverlaps, asc, avg, bigint, bigserial, boolean, bytea, ceil, char, cidr, contains, cosineDistance, count, countDistinct, database, date, defineConfig, desc, endsWith, enumed, enumtype, eq, fk, floor, geography, gt, gte, hammingDistance, index, inet, innerProduct, integer, isIn, isNotNull, isNull, jaccardDistance, json, jsonb, l1Distance, l2Distance, left, length, like, lower, lt, lte, macaddr, many, max, min, mod, ne, notIn, notNull, now, numeric, one, or, pgvector, pk, position, prequery, primaryKey, primaryKeyConstraint, relations, right, round, sequence, serial, smallint, smallserial, sql, stContains, stDWithin, stDistance, stIntersects, stWithin, startsWith, sum, table, text, time, timestamp, trim, tuple, unique, uniqueConstraint, uniqueIndex, upper, uuid, uuidv4, uuidv7, varchar };

package/dist/src/indexes.d.mts

@@ -1,12 +1,13 @@
+import { IndexOn } from "./columns/common.mjs";
 import { AnyColumn, StdTable, StdTableColumn } from "./table.mjs";
 
 //#region src/indexes.d.ts
 type IndexType = "btree" | "hash" | "gist" | "spgist" | "gin" | "brin" | "hnsw" | "ivfflat" | (string & {});
 declare class Index<Col extends AnyColumn> {
   #private;
-  constructor(columns: StdTableColumn<Col>[], using: IndexType, unique: boolean);
+  constructor(columns: (StdTableColumn<Col> | IndexOn<Col>)[], using: IndexType, unique: boolean);
   _: {
-    getColumns: () => StdTableColumn<Col>[];
+    getColumns: () => (StdTableColumn<Col> | IndexOn<Col>)[];
     getUsing: () => IndexType;
     getUnique: () => boolean;
     getName: (table: StdTable) => string;
@@ -25,7 +26,7 @@ declare class Index<Col extends AnyColumn> {
    */
   using(using: IndexType): this;
 }
-declare function index<Col extends AnyColumn>(columns: StdTableColumn<Col>[], using?: IndexType): Index<Col>;
-declare function uniqueIndex<Col extends AnyColumn>(columns: StdTableColumn<Col>[], using?: IndexType): Index<Col>;
+declare function index<Col extends AnyColumn>(columns: (StdTableColumn<Col> | IndexOn<Col>)[], using?: IndexType): Index<Col>;
+declare function uniqueIndex<Col extends AnyColumn>(columns: (StdTableColumn<Col> | IndexOn<Col>)[], using?: IndexType): Index<Col>;
 //#endregion
 export { Index, IndexType, index, uniqueIndex };

package/dist/src/indexes.mjs

@@ -1,3 +1,4 @@
+import { IndexOn } from "./columns/common.mjs";
 //#region src/indexes.ts
 var Index = class {
 	#columns;
@@ -13,7 +14,7 @@ var Index = class {
 		getUsing: () => this.#using,
 		getUnique: () => this.#unique,
 		getName: (table) => {
-			return `${table._.nameSql}_${this.#columns.map((col) => col.nameSql).join("_")}_index`;
+			return `${table._.nameSql}_${this.#columns.map((col) => col instanceof IndexOn ? col.column.nameSql : col.nameSql).join("_")}_index`;
 		}
 	};
 	/**

package/dist/src/migration/ddl/indexes.d.mts

@@ -51,7 +51,7 @@ declare class CreateIndexBuilder extends DDLStatement {
    * @param columns - Optional array of column names to index.
    * @returns `this` for chaining.
    */
-  on(schema: string, table: string, columns?: string[]): this;
+  on(schema: string, table: string, columns?: (string | [string, string])[]): this;
   /**
    * Specify the index method.
    *
@@ -59,7 +59,7 @@ declare class CreateIndexBuilder extends DDLStatement {
    * @param columns - Optional array of column names to index.
    * @returns `this` for chaining.
    */
-  using(type: IndexType, columns?: string[]): this;
+  using(type: IndexType, columns?: (string | [string, string])[]): this;
   /**
    * Make this a unique index.
    *

package/dist/src/migration/ddl/indexes.mjs

@@ -82,7 +82,11 @@ var CreateIndexBuilder = class extends DDLStatement {
 	}
 	toSQL() {
 		const tableRelation = `"${this.tableSchema}"."${this.tableName}"`;
-		const columns = this.indexColumns.map((c) => `"${c}"`).join(", ");
+		const columns = this.indexColumns.map((c) => {
+			const colName = typeof c === "string" ? c : c[0];
+			const colOpclass = typeof c === "string" ? void 0 : c[1];
+			return colOpclass ? `"${colName}" ${colOpclass}` : `"${colName}"`;
+		}).join(", ");
 		return `CREATE${this.isUnique ? " UNIQUE" : ""} INDEX${this.isConcurrent ? " CONCURRENTLY" : ""} ${this.indexName} ON ${tableRelation} USING ${this.indexType} (${columns});`;
 	}
 	applyToSnapshot(snapshot) {
@@ -91,7 +95,12 @@ var CreateIndexBuilder = class extends DDLStatement {
 		if (!table) return;
 		table.indexes[this.indexName] = {
 			name: this.indexName,
-			columns: [...this.indexColumns],
+			columns: this.indexColumns.map((c) => {
+				return {
+					name: typeof c === "string" ? c : c[0],
+					opclass: typeof c === "string" ? void 0 : c[1]
+				};
+			}),
 			type: this.indexType,
 			unique: this.isUnique
 		};

package/dist/src/migration/snapshot.d.mts

@@ -102,14 +102,23 @@ interface SnapshotSequence {
   /** Number of sequence values to pre-allocate (`CACHE`). */
   cache?: number;
 }
+/**
+ * Snapshot of a table index column.
+ */
+interface SnapshotTableIndexColumn {
+  /** The column name. */
+  name: string;
+  /** Optional operator class for this specific column. */
+  opclass?: string;
+}
 /**
  * Snapshot of a table index.
  */
 interface SnapshotTableIndex {
   /** The index name. */
   name: string;
-  /** Column names included in the index. */
-  columns: string[];
+  /** Columns included in the index. */
+  columns: SnapshotTableIndexColumn[];
   /** The index method (e.g. `"btree"`, `"hash"`, `"gin"`, `"gist"`). */
   type: IndexType;
   /** Whether this is a unique index. */

package/dist/src/migration/snapshot.mjs

@@ -1,4 +1,5 @@
 import { Query } from "../query-builders/query.mjs";
+import { IndexOn } from "../columns/common.mjs";
 import { is } from "../entity.mjs";
 import { Sql } from "../sql.mjs";
 import { primaryKeyConstraint } from "../constraints/primary-key.mjs";
@@ -74,7 +75,13 @@ function snapshot(entities) {
 		(table._.extra.indexes?.(table) ?? []).forEach((index) => {
 			ss.tables[`${table._.schemaSql}.${table._.nameSql}`].indexes[index._.getName(table)] = {
 				name: index._.getName(table),
-				columns: index._.getColumns().map((col) => col.nameSql),
+				columns: index._.getColumns().map((col) => {
+					if (col instanceof IndexOn) return {
+						name: col.column.nameSql,
+						opclass: col.opclassStr
+					};
+					return { name: col.nameSql };
+				}),
 				type: index._.getUsing(),
 				unique: index._.getUnique()
 			};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "durcno",
-  "version": "1.0.0-alpha.13",
+  "version": "1.0.0-alpha.14",
   "description": "A PostgreSQL Query Builder and Migration Manager for TypeScript, from the future.",
   "license": "Apache-2.0",
   "homepage": "https://durcno.dev",