durcno 1.0.0-alpha.0

package/dist/src/constraints/unique.mjs

@@ -0,0 +1,36 @@
+//#region src/constraints/unique.ts
+var UniqueConstraint = class {
+	#name;
+	#columns;
+	constructor(name, columns) {
+		if (columns.length < 2) throw new Error("UNIQUE constraint requires at least two columns. For single-column unique, use the column-level 'unique' modifier instead.");
+		this.#name = name;
+		this.#columns = columns;
+	}
+	getName(table) {
+		return this.#name.startsWith(`${table._.name}_`) ? this.#name : `${table._.name}_${this.#name}`;
+	}
+	getColumns() {
+		return this.#columns.map((col) => col.nameSnake);
+	}
+};
+/**
+* Creates a named table-level UNIQUE constraint on two or more columns.
+* For single-column unique, use the column-level `unique` modifier instead.
+*
+* This function is passed as the second parameter to the `uniqueConstraints` callback.
+*
+* @example
+* ```ts
+* table("public", "user_roles", { userId: bigint({}), roleId: bigint({}) }, {
+*   uniqueConstraints: (t, unique) => [
+*     unique("unique_user_role", [t.userId, t.roleId]),
+*   ],
+* });
+* ```
+*/
+function uniqueConstraint(name, columns) {
+	return new UniqueConstraint(name, columns);
+}
+//#endregion
+export { UniqueConstraint, uniqueConstraint };

package/dist/src/db.d.mts

@@ -0,0 +1,180 @@
+import { SelectBuilder } from "./query-builders/select.mjs";
+import { BuildFilterExpression } from "./filters/index.mjs";
+import { AggregateQuery } from "./query-builders/aggregates.mjs";
+import { CountQuery } from "./query-builders/count.mjs";
+import { DeleteQuery } from "./query-builders/delete.mjs";
+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";
+import { AnyColumn, AnyRelations, IsTableWC, Relations, TColsToLeftRight, TableWCorNever, TableWithColumns } from "./table.mjs";
+import { Config, DurcnoSetup } from "./index.mjs";
+import { $Pool, Connector, QueryExecutor } from "./connectors/common.mjs";
+
+//#region src/db.d.ts
+type AnyDBorTX = Base<any, any, any, false>;
+type StdTableFullName = `"${string}"."${string}"`;
+declare class Base<TTName extends string, TTables extends Record<TTName, TableWithColumns<string, string, Record<string, AnyColumn>>>, TAllRelations extends Record<StdTableFullName, AnyRelations>, TPrepare extends boolean> {
+  #private;
+  _: {
+    getConnector: () => Connector;
+    getExecutor: () => QueryExecutor;
+  };
+  $: {
+    tables: TTables;
+    allRelations: TAllRelations;
+    config: Config;
+    dbUrl: string;
+    pre: TPrepare;
+  };
+  constructor(tables: TTables, allRelations: TAllRelations, executor: QueryExecutor | null, connector: Connector, prepare: TPrepare);
+  /**
+   * Start building an INSERT query for the specified table.
+   * @param table The table to insert into
+   * @returns An InsertBuilder instance to chain `.values()` and execute the insert
+   */
+  insert<TTable extends TTables[keyof TTables]>(table: TTable): InsertBuilder<TTable>;
+  /**
+   * Start building a SELECT query from the specified table.
+   * @param table The table to select from
+   * @returns A FromBuilder instance to chain `.select()`, `.where()`, `.orderBy()`, etc.
+   */
+  from<UTSchema extends string, UTName extends string, UTColumns extends Record<string, AnyColumn>>(table: TableWithColumns<UTSchema, UTName, UTColumns>): SelectBuilder<UTSchema, UTName, UTColumns, TPrepare, null>;
+  /**
+   * Start building an UPDATE query for the specified table.
+   * @param table The table to update
+   * @returns An UpdateBuilder instance to chain `.set()` and `.where()` clauses
+   */
+  update<TTable extends TTables[keyof TTables]>(table: TTable): UpdateBuilder<TTable, TPrepare>;
+  /**
+   * Start building a DELETE query for the specified table.
+   * @param table The table to delete from
+   * @returns A DeleteQuery instance to chain `.where()` and execute the deletion
+   */
+  delete<TTable extends TTables[keyof TTables]>(table: TTable): DeleteQuery<TTable, TPrepare, undefined, null>;
+  /**
+   * Count the number of rows in a table, optionally filtered by a where clause.
+   * @param table The table to count rows from
+   * @param where Optional where clause to filter rows
+   * @returns Promise<number> - the count of matching rows
+   */
+  $count<TTable extends TTables[keyof TTables]>(table: TTable): CountQuery<TTable>;
+  $count<TTable extends TTables[keyof TTables], TWhere extends BuildFilterExpression<TColsToLeftRight<TTable["_"]["columns"]>>>(table: TTable, where: TWhere): CountQuery<TTable>;
+  /**
+   * Check if any rows exist in a table, optionally filtered by a where clause.
+   * @param table The table to check
+   * @param where Optional where clause to filter rows
+   * @returns Promise<boolean> - true if at least one row exists
+   */
+  $exists<TTable extends TTables[keyof TTables]>(table: TTable): ExistsQuery<TTable>;
+  $exists<TTable extends TTables[keyof TTables], TWhere extends BuildFilterExpression<TColsToLeftRight<TTable["_"]["columns"]>>>(table: TTable, where: TWhere): ExistsQuery<TTable>;
+  /**
+   * Get the first row from a table, optionally filtered by a where clause.
+   * @param table The table to query
+   * @param where Optional where clause to filter rows
+   * @returns Promise<T | null> - the first row or null if no rows match
+   */
+  $first<TTable extends TTables[keyof TTables]>(table: TTable): FirstQuery<TTable>;
+  $first<TTable extends TTables[keyof TTables], TWhere extends BuildFilterExpression<TColsToLeftRight<TTable["_"]["columns"]>>>(table: TTable, where: TWhere): FirstQuery<TTable>;
+  /**
+   * Calculate the sum of a numeric column.
+   * @param table The table to query
+   * @param column The numeric column to sum
+   * @param where Optional where clause to filter rows
+   * @returns Promise<number | null> - the sum or null if no rows match
+   */
+  $sum<TTable extends TTables[keyof TTables], TColumn extends TTable["_"]["columns"][keyof TTable["_"]["columns"]]>(table: TTable, column: TColumn): AggregateQuery<TTable, TColumn, number | null>;
+  $sum<TTable extends TTables[keyof TTables], TColumn extends TTable["_"]["columns"][keyof TTable["_"]["columns"]], TWhere extends BuildFilterExpression<TColsToLeftRight<TTable["_"]["columns"]>>>(table: TTable, column: TColumn, where: TWhere): AggregateQuery<TTable, TColumn, number | null>;
+  /**
+   * Calculate the average of a numeric column.
+   * @param table The table to query
+   * @param column The numeric column to average
+   * @param where Optional where clause to filter rows
+   * @returns Promise<number | null> - the average or null if no rows match
+   */
+  $avg<TTable extends TTables[keyof TTables], TColumn extends TTable["_"]["columns"][keyof TTable["_"]["columns"]]>(table: TTable, column: TColumn): AggregateQuery<TTable, TColumn, number | null>;
+  $avg<TTable extends TTables[keyof TTables], TColumn extends TTable["_"]["columns"][keyof TTable["_"]["columns"]], TWhere extends BuildFilterExpression<TColsToLeftRight<TTable["_"]["columns"]>>>(table: TTable, column: TColumn, where: TWhere): AggregateQuery<TTable, TColumn, number | null>;
+  /**
+   * Find the minimum value of a column.
+   * @param table The table to query
+   * @param column The column to find the minimum of
+   * @param where Optional where clause to filter rows
+   * @returns Promise<number | null> - the minimum value or null if no rows match
+   */
+  $min<TTable extends TTables[keyof TTables], TColumn extends TTable["_"]["columns"][keyof TTable["_"]["columns"]]>(table: TTable, column: TColumn): AggregateQuery<TTable, TColumn, number | null>;
+  $min<TTable extends TTables[keyof TTables], TColumn extends TTable["_"]["columns"][keyof TTable["_"]["columns"]], TWhere extends BuildFilterExpression<TColsToLeftRight<TTable["_"]["columns"]>>>(table: TTable, column: TColumn, where: TWhere): AggregateQuery<TTable, TColumn, number | null>;
+  /**
+   * Find the maximum value of a column.
+   * @param table The table to query
+   * @param column The column to find the maximum of
+   * @param where Optional where clause to filter rows
+   * @returns Promise<number | null> - the maximum value or null if no rows match
+   */
+  $max<TTable extends TTables[keyof TTables], TColumn extends TTable["_"]["columns"][keyof TTable["_"]["columns"]]>(table: TTable, column: TColumn): AggregateQuery<TTable, TColumn, number | null>;
+  $max<TTable extends TTables[keyof TTables], TColumn extends TTable["_"]["columns"][keyof TTable["_"]["columns"]], TWhere extends BuildFilterExpression<TColsToLeftRight<TTable["_"]["columns"]>>>(table: TTable, column: TColumn, where: TWhere): AggregateQuery<TTable, TColumn, number | null>;
+  /**
+   * Get distinct values of a column.
+   * @param table The table to query
+   * @param column The column to get distinct values from
+   * @param where Optional where clause to filter rows
+   * @returns Promise<T[]> - array of distinct values
+   */
+  $distinct<TTable extends TTables[keyof TTables], TColumn extends TTable["_"]["columns"][keyof TTable["_"]["columns"]]>(table: TTable, column: TColumn): DistinctQuery<TTable, TColumn, TColumn["ValTypeSelect"][]>;
+  $distinct<TTable extends TTables[keyof TTables], TColumn extends TTable["_"]["columns"][keyof TTable["_"]["columns"]], TWhere extends BuildFilterExpression<TColsToLeftRight<TTable["_"]["columns"]>>>(table: TTable, column: TColumn, where: TWhere): DistinctQuery<TTable, TColumn, TColumn["ValTypeSelect"][]>;
+  /**
+   * 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.
+   *
+   * Returns a builder with two methods:
+   * - `.findMany(options)` — fetch all matching rows
+   * - `.findFirst(options)` — fetch the first matching row (or `null`)
+   *
+   * Column selection works in two exclusive modes:
+   * - **Include mode** — `columns: { id: true, name: true }` returns only these columns.
+   * - **Exclude mode** — `columns: { password: false }` returns all columns except these.
+   *
+   * Use the `with` option to include related rows from other tables.
+   * You can nest `with` to load deeply related data.
+   *
+   * @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[`"${UTSchema}"."${UTName}"`], TAllRelations>;
+  /**
+   * 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
+   * @param args Array of parameter values to bind to the query placeholders
+   * @param rowsHandler Optional function to transform the raw result rows
+   * @returns A RawQuery instance that resolves to the query result (or transformed result if handler provided)
+   */
+  raw<TReturn = unknown>(query: string, args: (string | number | null)[] | undefined, rowsHandler: ((rows: any[]) => TReturn) | undefined): RawQuery<TReturn>;
+}
+declare class DB<TTName extends string, TTables extends Record<TTName, TableWithColumns<string, string, Record<string, AnyColumn>>>, TAllRelations extends Record<StdTableFullName, AnyRelations>> extends Base<TTName, TTables, TAllRelations, false> {
+  #private;
+  constructor(tables: TTables, allRelations: TAllRelations, pool: $Pool, connector: Connector);
+  prepare(): Preparer<string, TTables, TAllRelations>;
+  /**
+   * Execute multiple queries within a single database transaction in a new connection.
+   * @param callback Function that receives a transaction context and to be used instead of db.
+   * @returns Promise that resolves to the callback's return value
+   */
+  transaction<T>(callback: (...args: [Transaction<TTName, TTables, TAllRelations>]) => Promise<T>): Promise<T>;
+  close(): Promise<true>;
+}
+declare class Transaction<TTNames extends string, TTables extends Record<TTNames, TableWithColumns<string, string, Record<string, AnyColumn>>>, TAllRelations extends Record<StdTableFullName, AnyRelations>> extends Base<TTNames, TTables, TAllRelations, false> {}
+declare class Preparer<TTNames extends string, TTables extends Record<TTNames, TableWithColumns<string, string, Record<string, AnyColumn>>>, TAllRelations extends Record<StdTableFullName, AnyRelations>> extends Base<TTNames, TTables, TAllRelations, true> {
+  constructor(tables: TTables, allRelations: TAllRelations, connector: Connector);
+}
+declare function database<TEntities extends Record<string, unknown>>(entities: TEntities, setup: DurcnoSetup): DB<string, { [Export in keyof TEntities as IsTableWC<TEntities[Export]> extends true ? Export : never]: TableWCorNever<TEntities[Export]> }, { [Export in keyof TEntities as TEntities[Export] extends ((...args: unknown[]) => infer TRelations) ? TRelations extends Relations<infer TSchema, infer TName, infer _x, infer _y> ? `\"${TSchema}\".\"${TName}\"` : never : never]: TEntities[Export] extends ((...args: unknown[]) => infer TRelations) ? TRelations extends Relations<infer TTSchema, infer TTName, infer TTColumns, infer TTRelations> ? Relations<TTSchema, TTName, TTColumns, TTRelations> : never : never }>;
+//#endregion
+export { AnyDBorTX, database };

package/dist/src/db.mjs

@@ -0,0 +1,191 @@
+import { is } from "./entity.mjs";
+import { getUrlFromDbCredentials } from "./cli/helpers.mjs";
+import { AggregateQuery } from "./query-builders/aggregates.mjs";
+import { CountQuery } from "./query-builders/count.mjs";
+import { DeleteQuery } from "./query-builders/delete.mjs";
+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";
+import { UpdateBuilder } from "./query-builders/update.mjs";
+import { Relations, Table } from "./table.mjs";
+//#region src/db.ts
+var Base = class {
+	#allRelations;
+	#config;
+	#connector;
+	#executor;
+	_ = {
+		getConnector: () => this.#connector,
+		getExecutor: this.#getExecutor.bind(this)
+	};
+	$;
+	constructor(tables, allRelations, executor, connector, prepare) {
+		this.#allRelations = allRelations;
+		this.#config = connector.config;
+		this.#executor = executor;
+		this.#connector = connector;
+		this.$ = {
+			tables,
+			allRelations,
+			config: connector.config,
+			dbUrl: getUrlFromDbCredentials(connector.config.dbCredentials),
+			pre: prepare
+		};
+	}
+	#getExecutor() {
+		if (this.$.pre === true) return null;
+		else if (this.#executor === null) throw new Error("Cannot execute query: no database connection available");
+		return this.#executor;
+	}
+	/**
+	* Start building an INSERT query for the specified table.
+	* @param table The table to insert into
+	* @returns An InsertBuilder instance to chain `.values()` and execute the insert
+	*/
+	insert(table) {
+		return new InsertBuilder(table, this.#config, this.#getExecutor());
+	}
+	/**
+	* Start building a SELECT query from the specified table.
+	* @param table The table to select from
+	* @returns A FromBuilder instance to chain `.select()`, `.where()`, `.orderBy()`, etc.
+	*/
+	from(table) {
+		return new SelectBuilder(table, null, void 0, this.#config, this.#getExecutor(), this.$.pre);
+	}
+	/**
+	* Start building an UPDATE query for the specified table.
+	* @param table The table to update
+	* @returns An UpdateBuilder instance to chain `.set()` and `.where()` clauses
+	*/
+	update(table) {
+		return new UpdateBuilder(table, this.#config, this.#getExecutor(), this.$.pre);
+	}
+	/**
+	* Start building a DELETE query for the specified table.
+	* @param table The table to delete from
+	* @returns A DeleteQuery instance to chain `.where()` and execute the deletion
+	*/
+	delete(table) {
+		return new DeleteQuery(table, void 0, void 0, this.#config, this.#getExecutor(), this.$.pre);
+	}
+	$count(table, where) {
+		return new CountQuery(table, where, this.#config, this.#getExecutor());
+	}
+	$exists(table, where) {
+		return new ExistsQuery(table, where, this.#config, this.#getExecutor());
+	}
+	$first(table, where) {
+		return new FirstQuery(table, where, this.#config, this.#getExecutor());
+	}
+	$sum(table, column, where) {
+		return new AggregateQuery(table, column, "SUM", where, this.#config, this.#getExecutor());
+	}
+	$avg(table, column, where) {
+		return new AggregateQuery(table, column, "AVG", where, this.#config, this.#getExecutor());
+	}
+	$min(table, column, where) {
+		return new AggregateQuery(table, column, "MIN", where, this.#config, this.#getExecutor());
+	}
+	$max(table, column, where) {
+		return new AggregateQuery(table, column, "MAX", where, this.#config, this.#getExecutor());
+	}
+	$distinct(table, column, where) {
+		return new DistinctQuery(table, column, where, this.#config, this.#getExecutor());
+	}
+	/**
+	* 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.#config, this.#getExecutor());
+	}
+	/**
+	* Start building a relational query for the specified table.
+	*
+	* Returns a builder with two methods:
+	* - `.findMany(options)` — fetch all matching rows
+	* - `.findFirst(options)` — fetch the first matching row (or `null`)
+	*
+	* Column selection works in two exclusive modes:
+	* - **Include mode** — `columns: { id: true, name: true }` returns only these columns.
+	* - **Exclude mode** — `columns: { password: false }` returns all columns except these.
+	*
+	* Use the `with` option to include related rows from other tables.
+	* You can nest `with` to load deeply related data.
+	*
+	* @param table The table to query — must have relations registered via `relations()`.
+	* @returns A `RelationQueryBuilder` with `.findMany()` and `.findFirst()` methods.
+	*/
+	query(table) {
+		return new RelationQueryBuilder(table, this.#allRelations[table._.fullName], this.#allRelations, this.#config, this.#getExecutor());
+	}
+	/**
+	* 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
+	* @param args Array of parameter values to bind to the query placeholders
+	* @param rowsHandler Optional function to transform the raw result rows
+	* @returns A RawQuery instance that resolves to the query result (or transformed result if handler provided)
+	*/
+	raw(query, args = [], rowsHandler) {
+		return new RawQuery(query, args, rowsHandler, this.#getExecutor());
+	}
+};
+var DB = class extends Base {
+	#pool;
+	constructor(tables, allRelations, pool, connector) {
+		super(tables, allRelations, pool, connector, false);
+		this.#pool = pool;
+	}
+	prepare() {
+		return new Preparer(this.$.tables, this.$.allRelations, this._.getConnector());
+	}
+	/**
+	* Execute multiple queries within a single database transaction in a new connection.
+	* @param callback Function that receives a transaction context and to be used instead of db.
+	* @returns Promise that resolves to the callback's return value
+	*/
+	async transaction(callback) {
+		const client = await this.#pool.acquireClient();
+		try {
+			await client.query("BEGIN;");
+			const result = await callback(new Transaction(this.$.tables, this.$.allRelations, client, this._.getConnector(), false));
+			await client.query("COMMIT;");
+			await client.close();
+			return result;
+		} catch (error) {
+			await client.query("ROLLBACK;");
+			await client.close();
+			throw error;
+		}
+	}
+	async close() {
+		await this._.getExecutor()?.close();
+		return true;
+	}
+};
+var Transaction = class extends Base {};
+var Preparer = class extends Base {
+	constructor(tables, allRelations, connector) {
+		super(tables, allRelations, null, connector, true);
+	}
+};
+function database(entities, setup) {
+	return new DB(Object.fromEntries(Object.entries(entities).map(([name, entity]) => {
+		if (is(entity, Table)) {
+			entity._.config = setup.config;
+			return [name, entity];
+		}
+	}).filter((entry) => entry !== void 0)), Object.fromEntries(Object.entries(entities).map(([_, entity]) => {
+		if (typeof entity === "function" && is(entity(), Relations)) return [entity().table._.fullName, entity()];
+	}).filter((entry) => entry !== void 0)), setup.connector.getPool(), setup.connector);
+}
+//#endregion
+export { database };

package/dist/src/entity.mjs

@@ -0,0 +1,23 @@
+import { entityType } from "./symbols.mjs";
+import { Column } from "./columns/common.mjs";
+//#region src/entity.ts
+/** biome-ignore-all lint/suspicious/noExplicitAny: <> */
+function is(value, type) {
+	if (value === null || value === void 0) return false;
+	if (value instanceof type) return true;
+	let cls = Object.getPrototypeOf(value).constructor;
+	if (cls) while (cls) {
+		if (entityType in cls && cls[entityType] === type[entityType]) return true;
+		cls = Object.getPrototypeOf(cls);
+	}
+	return false;
+}
+function isCol(value) {
+	return is(value, Column);
+}
+function isTableCol(value) {
+	return isCol(value) && value.table !== void 0;
+}
+const isTCol = isTableCol;
+//#endregion
+export { is, isCol, isTCol, isTableCol };

package/dist/src/enumtype.d.mts

@@ -0,0 +1,27 @@
+import { entityType } from "./symbols.mjs";
+import { EnumedColumn, EnumedConfig } from "./columns/enum.mjs";
+
+//#region src/enumtype.d.ts
+declare class Enum<U extends string = string, TValues extends Readonly<[U, ...U[]]> = Readonly<[U, ...U[]]>> {
+  #private;
+  static readonly [entityType] = "Enum";
+  readonly TValue: TValues[number];
+  constructor(schema: string, name: string, values: TValues);
+  get schema(): string;
+  get name(): string;
+  get values(): TValues;
+  enumed<TConfig extends EnumedConfig>(config: TConfig): EnumedColumn<TValues[number], TConfig>;
+}
+/**
+ * Creates a typed enum definition.
+ *
+ * @example
+ * ```ts
+ * import { enumtype } from "durcno";
+ *
+ * export const UserTypeEnm = enumtype("public", "user_type", ["admin", "user"]);
+ * ```
+ */
+declare function enumtype<U extends string, TValues extends Readonly<[U, ...U[]]>>(schema: string, name: string, values: TValues): Enum<string, TValues>;
+//#endregion
+export { Enum, enumtype };

package/dist/src/enumtype.mjs

@@ -0,0 +1,42 @@
+import { entityType } from "./symbols.mjs";
+import { enumed } from "./columns/enum.mjs";
+//#region src/enumtype.ts
+var Enum = class {
+	static [entityType] = "Enum";
+	TValue;
+	#schema;
+	#name;
+	#values;
+	constructor(schema, name, values) {
+		this.#schema = schema;
+		this.#name = name;
+		this.#values = values;
+	}
+	get schema() {
+		return this.#schema;
+	}
+	get name() {
+		return this.#name;
+	}
+	get values() {
+		return this.#values;
+	}
+	enumed(config) {
+		return enumed(this, config);
+	}
+};
+/**
+* Creates a typed enum definition.
+*
+* @example
+* ```ts
+* import { enumtype } from "durcno";
+*
+* export const UserTypeEnm = enumtype("public", "user_type", ["admin", "user"]);
+* ```
+*/
+function enumtype(schema, name, values) {
+	return new Enum(schema, name, values);
+}
+//#endregion
+export { Enum, enumtype };

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

@@ -0,0 +1,97 @@
+import { Query } from "../query-builders/query.mjs";
+import { Filter } from "./custom.mjs";
+import { AnyColumn, TableColumn } from "../table.mjs";
+
+//#region src/filters/array.d.ts
+/** Shorthand for the Filter's TableColumn constraint. */
+type AnyTC = TableColumn<any, any, any, AnyColumn>;
+/**
+ * Helper type to extract the element type from an array type.
+ * Works with regular arrays, tuples, and nested arrays.
+ */
+type ArrayElement<T> = T extends readonly (infer E)[] ? E extends readonly unknown[] ? ArrayElement<E> : E : T;
+/**
+ * ArrayContains filter: col @> ARRAY[values]
+ * Returns true if the array column contains all the specified values.
+ */
+declare class ArrayContainsFilter<TCol extends AnyTC, TVal extends ArrayElement<TCol["ValType"]>> extends Filter<TCol> {
+  readonly left: TCol;
+  readonly right: TVal[];
+  constructor(column: TCol, values: TVal[]);
+  toSQL(): string;
+  toQuery(query: Query): void;
+}
+/**
+ * Creates a condition that checks if an array column contains all specified values.
+ * SQL: column @> ARRAY[values]
+ *
+ * @example
+ * db.from(Posts).select().where(arrayContains(Posts.tags, ['typescript', 'postgres']))
+ */
+declare function arrayContains<TCol extends AnyTC, TVal extends ArrayElement<TCol["ValType"]>>(column: TCol, values: TVal[]): ArrayContainsFilter<TCol, TVal>;
+/**
+ * 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 AnyTC, TVal extends ArrayElement<TCol["ValType"]>> extends Filter<TCol> {
+  readonly left: TCol;
+  readonly right: TVal[];
+  constructor(column: TCol, values: TVal[]);
+  toSQL(): string;
+  toQuery(query: Query): void;
+}
+/**
+ * Creates a condition that checks if an array column is contained by the specified values.
+ * SQL: column <@ ARRAY[values]
+ */
+declare function arrayContainedBy<TCol extends AnyTC, TVal extends ArrayElement<TCol["ValType"]>>(column: TCol, values: TVal[]): ArrayContainedByFilter<TCol, TVal>;
+/**
+ * ArrayOverlaps filter: col && ARRAY[values]
+ * Returns true if the arrays have any elements in common.
+ */
+declare class ArrayOverlapsFilter<TCol extends AnyTC, TVal extends ArrayElement<TCol["ValType"]>> extends Filter<TCol> {
+  readonly left: TCol;
+  readonly right: TVal[];
+  constructor(column: TCol, values: TVal[]);
+  toSQL(): string;
+  toQuery(query: Query): void;
+}
+/**
+ * Creates a condition that checks if an array column overlaps with the specified values.
+ * SQL: column && ARRAY[values]
+ */
+declare function arrayOverlaps<TCol extends AnyTC, TVal extends ArrayElement<TCol["ValType"]>>(column: TCol, values: TVal[]): ArrayOverlapsFilter<TCol, TVal>;
+/**
+ * ArrayHas filter: value = ANY(col)
+ * Returns true if the value exists in the array column.
+ */
+declare class ArrayHasFilter<TCol extends AnyTC, TVal extends ArrayElement<TCol["ValType"]>> extends Filter<TCol> {
+  readonly left: TCol;
+  readonly right: TVal;
+  constructor(column: TCol, value: TVal);
+  toSQL(): string;
+  toQuery(query: Query): void;
+}
+/**
+ * Creates a condition that checks if a value exists in an array column.
+ * SQL: value = ANY(column)
+ */
+declare function arrayHas<TCol extends AnyTC, TVal extends ArrayElement<TCol["ValType"]>>(column: TCol, value: TVal): ArrayHasFilter<TCol, TVal>;
+/**
+ * ArrayAll filter: value = ALL(col)
+ * Returns true if all elements in the array column equal the value.
+ */
+declare class ArrayAllFilter<TCol extends AnyTC, TVal extends ArrayElement<TCol["ValType"]>> extends Filter<TCol> {
+  readonly left: TCol;
+  readonly right: TVal;
+  constructor(column: TCol, value: TVal);
+  toSQL(): string;
+  toQuery(query: Query): void;
+}
+/**
+ * Creates a condition that checks if all elements in an array column equal a value.
+ * SQL: value = ALL(column)
+ */
+declare function arrayAll<TCol extends AnyTC, TVal extends ArrayElement<TCol["ValType"]>>(column: TCol, value: TVal): ArrayAllFilter<TCol, TVal>;
+//#endregion
+export { arrayAll, arrayContainedBy, arrayContains, arrayHas, arrayOverlaps };