durcno 1.0.0-alpha.0

package/dist/src/connectors/pglite.mjs

@@ -0,0 +1,94 @@
+import { $Client, $Pool, Connector } from "./common.mjs";
+import { PGlite } from "@electric-sql/pglite";
+//#region src/connectors/pglite.ts
+/**
+* Connector implementation for the `@electric-sql/pglite` library.
+*
+* PGlite is a lightweight, embeddable PostgreSQL implementation that runs
+* entirely in-process using WASM. Perfect for local development, testing,
+* and edge computing scenarios.
+*
+* @see https://pglite.dev/
+* @see https://www.npmjs.com/package/@electric-sql/pglite
+*/
+var PgLiteConnector = class extends Connector {
+	getClient() {
+		return new PgLiteClient(this.url);
+	}
+	getPool() {
+		return new PgLitePool(this.url, this.config.pool);
+	}
+};
+/**
+* Single-instance client wrapper for PGlite.
+*
+* Since PGlite runs in-process, this creates a single PGlite instance.
+* Connection is established automatically during initialization.
+*
+* @internal
+*/
+var PgLiteClient = class extends $Client {
+	#client;
+	constructor(connectionString) {
+		super();
+		this.#client = new PGlite(connectionString);
+		this.query = this.#client.query.bind(this.#client);
+	}
+	async connect() {}
+	getRows(response) {
+		return response.rows;
+	}
+	async close() {
+		await this.#client.close();
+	}
+};
+/**
+* Pool-like wrapper for PGlite.
+*
+* Since PGlite runs in-process, pooling is not applicable in the traditional
+* sense. This class provides API compatibility with other connectors while
+* using a single PGlite instance internally.
+*
+* @internal
+*/
+var PgLitePool = class extends $Pool {
+	#pool;
+	constructor(connectionString, pool) {
+		super();
+		this.#pool = new PGlite(connectionString);
+		this.query = this.#pool.query.bind(this.#pool);
+	}
+	async connect() {}
+	getRows(response) {
+		return response.rows;
+	}
+	async close() {
+		await this.#pool.close();
+	}
+	async acquireClient() {
+		return new PgLitePoolClient(this.#pool);
+	}
+};
+/**
+* Client wrapper for a connection acquired from a PGlite Pool.
+*
+* Since PGlite runs in-process, this wraps the shared PGlite instance.
+* The close() method is a no-op to avoid closing the shared instance.
+*
+* @internal
+*/
+var PgLitePoolClient = class extends $Client {
+	#client;
+	constructor(client) {
+		super();
+		this.#client = client;
+		this.query = this.#client.query.bind(this.#client);
+	}
+	async connect() {}
+	getRows(response) {
+		return response.rows;
+	}
+	async close() {}
+};
+//#endregion
+export { PgLiteConnector };

package/dist/src/connectors/postgres.d.mts

@@ -0,0 +1,18 @@
+import { Connector } from "./common.mjs";
+
+//#region src/connectors/postgres.d.ts
+/**
+ * Connector implementation for the `postgres` (postgres.js) library.
+ *
+ * Postgres.js - The Fastest full featured PostgreSQL client for Node.js,
+ * Deno, Bun and CloudFlare.
+ *
+ * @see https://github.com/porsager/postgres
+ * @see https://www.npmjs.com/package/postgres
+ */
+declare class PostgresConnector extends Connector {
+  getClient(): PostgresClient;
+  getPool(): PostgresPool;
+}
+//#endregion
+export { PostgresConnector };

package/dist/src/connectors/postgres.mjs

@@ -0,0 +1,93 @@
+import { $Client, $Pool, Connector } from "./common.mjs";
+import postgres from "postgres";
+//#region src/connectors/postgres.ts
+/**
+* Connector implementation for the `postgres` (postgres.js) library.
+*
+* Postgres.js - The Fastest full featured PostgreSQL client for Node.js,
+* Deno, Bun and CloudFlare.
+*
+* @see https://github.com/porsager/postgres
+* @see https://www.npmjs.com/package/postgres
+*/
+var PostgresConnector = class extends Connector {
+	getClient() {
+		return new PostgresClient(this.url);
+	}
+	getPool() {
+		return new PostgresPool(this.url, this.config.pool);
+	}
+};
+/**
+* Single-connection client wrapper for postgres.js.
+*
+* Configures postgres.js with `max: 1` to simulate single-connection behavior.
+* Connection is established lazily on first query.
+*
+* @internal
+*/
+var PostgresClient = class extends $Client {
+	#sql;
+	constructor(connectionString) {
+		super();
+		this.#sql = postgres(connectionString, { max: 1 });
+		this.query = this.#sql.unsafe.bind(this.#sql);
+	}
+	async connect() {}
+	getRows(response) {
+		return response;
+	}
+	async close() {
+		await this.#sql.end();
+	}
+};
+/**
+* Connection pool wrapper for postgres.js.
+*
+* postgres.js has built-in connection pooling, so this wrapper configures
+* the pool size via the `max` option. Connections are managed automatically.
+*
+* @internal
+*/
+var PostgresPool = class extends $Pool {
+	#sql;
+	constructor(connectionString, pool) {
+		super();
+		this.#sql = postgres(connectionString, { max: pool?.max ?? 10 });
+		this.query = this.#sql.unsafe.bind(this.#sql);
+	}
+	async connect() {}
+	getRows(response) {
+		return response;
+	}
+	async close() {
+		await this.#sql.end();
+	}
+	async acquireClient() {
+		return new PostgresPoolClient(await this.#sql.reserve());
+	}
+};
+/**
+* Client wrapper for a reserved connection from a postgres.js pool.
+*
+* This client uses a reserved connection that's exclusive until released.
+*
+* @internal
+*/
+var PostgresPoolClient = class extends $Client {
+	#sql;
+	constructor(sql) {
+		super();
+		this.#sql = sql;
+		this.query = this.#sql.unsafe.bind(this.#sql);
+	}
+	async connect() {}
+	getRows(response) {
+		return response;
+	}
+	async close() {
+		this.#sql.release();
+	}
+};
+//#endregion
+export { PostgresConnector };

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

@@ -0,0 +1,88 @@
+import { AnyColumn, TableColumn } from "../table.mjs";
+
+//#region src/constraints/check.d.ts
+type ComparisonOp = "=" | "<>" | "<" | ">" | "<=" | ">=" | "IN" | "NOT IN";
+type PatternOp = "LIKE" | "SIMILAR TO" | "~";
+type LogicalOp = "AND" | "OR";
+interface ComparisonExpr {
+  type: "comparison";
+  left: TableColumn<string, string, Key, AnyColumn> | FunctionExpr;
+  op: ComparisonOp | PatternOp;
+  right: unknown;
+}
+interface LogicalExpr {
+  type: "logical";
+  op: LogicalOp;
+  expressions: CheckExpr[];
+}
+interface FunctionExpr {
+  type: "function";
+  name: string;
+  args: (TableColumn<string, string, Key, AnyColumn> | unknown)[];
+}
+interface RawExpr {
+  type: "raw";
+  sql: string;
+}
+type CheckExpr = ComparisonExpr | LogicalExpr | FunctionExpr | RawExpr;
+type SnapshotComparisonOp = "=" | "<>" | "<" | ">" | "<=" | ">=" | "IN" | "NOT IN";
+type SnapshotPatternOp = "LIKE" | "SIMILAR TO" | "~";
+type SnapshotLogicalOp = "AND" | "OR";
+interface SnapshotComparisonExpr {
+  type: "comparison";
+  left: string | SnapshotFunctionExpr;
+  op: SnapshotComparisonOp | SnapshotPatternOp;
+  right: unknown;
+}
+interface SnapshotLogicalExpr {
+  type: "logical";
+  op: SnapshotLogicalOp;
+  expressions: SnapshotCheckExpr[];
+}
+interface SnapshotFunctionExpr {
+  type: "function";
+  name: string;
+  args: (string | unknown)[];
+}
+interface SnapshotRawExpr {
+  type: "raw";
+  sql: string;
+}
+type SnapshotCheckExpr = SnapshotComparisonExpr | SnapshotLogicalExpr | SnapshotFunctionExpr | SnapshotRawExpr;
+declare class CheckBuilder {
+  eq<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, value: TCol["ValType"]): ComparisonExpr;
+  neq<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, value: TCol["ValType"]): ComparisonExpr;
+  gt<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, value: TCol["ValType"]): ComparisonExpr;
+  gte<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, value: TCol["ValType"]): ComparisonExpr;
+  lt<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, value: TCol["ValType"]): ComparisonExpr;
+  lte<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, value: TCol["ValType"]): ComparisonExpr;
+  like<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, pattern: string): ComparisonExpr;
+  similarTo<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, pattern: string): ComparisonExpr;
+  regex<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, pattern: string): ComparisonExpr;
+  in<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, values: (TCol["ValType"] & (string | number))[]): ComparisonExpr;
+  notIn<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, values: (TCol["ValType"] & (string | number))[]): ComparisonExpr;
+  and(...expressions: CheckExpr[]): LogicalExpr;
+  or(...expressions: CheckExpr[]): LogicalExpr;
+  length<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol): FunctionExpr;
+  lower<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol): FunctionExpr;
+  upper<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol): FunctionExpr;
+  trim<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol): FunctionExpr;
+  coalesce<TCol extends TableColumn<string, string, Key, AnyColumn>>(col: TCol, defaultValue: TCol["ValType"]): FunctionExpr;
+  fnEq(fn: FunctionExpr, value: unknown): ComparisonExpr;
+  fnNeq(fn: FunctionExpr, value: unknown): ComparisonExpr;
+  fnGt(fn: FunctionExpr, value: number): ComparisonExpr;
+  fnGte(fn: FunctionExpr, value: number): ComparisonExpr;
+  fnLt(fn: FunctionExpr, value: number): ComparisonExpr;
+  fnLte(fn: FunctionExpr, value: number): ComparisonExpr;
+  raw(sql: string): RawExpr;
+  toSQL(expr: CheckExpr): string;
+}
+declare class Check {
+  #private;
+  constructor(name: string, expr: CheckExpr);
+  getName(): string;
+  getExpression(): string;
+  toSnapshotExpr(): SnapshotCheckExpr;
+}
+//#endregion
+export { Check, CheckBuilder, CheckExpr, SnapshotCheckExpr };

package/dist/src/constraints/check.mjs

@@ -0,0 +1,307 @@
+import { isTableCol } from "../entity.mjs";
+//#region src/constraints/check.ts
+var CheckBuilder = class {
+	eq(col, value) {
+		return {
+			type: "comparison",
+			left: col,
+			op: "=",
+			right: value
+		};
+	}
+	neq(col, value) {
+		return {
+			type: "comparison",
+			left: col,
+			op: "<>",
+			right: value
+		};
+	}
+	gt(col, value) {
+		return {
+			type: "comparison",
+			left: col,
+			op: ">",
+			right: value
+		};
+	}
+	gte(col, value) {
+		return {
+			type: "comparison",
+			left: col,
+			op: ">=",
+			right: value
+		};
+	}
+	lt(col, value) {
+		return {
+			type: "comparison",
+			left: col,
+			op: "<",
+			right: value
+		};
+	}
+	lte(col, value) {
+		return {
+			type: "comparison",
+			left: col,
+			op: "<=",
+			right: value
+		};
+	}
+	like(col, pattern) {
+		return {
+			type: "comparison",
+			left: col,
+			op: "LIKE",
+			right: pattern
+		};
+	}
+	similarTo(col, pattern) {
+		return {
+			type: "comparison",
+			left: col,
+			op: "SIMILAR TO",
+			right: pattern
+		};
+	}
+	regex(col, pattern) {
+		return {
+			type: "comparison",
+			left: col,
+			op: "~",
+			right: pattern
+		};
+	}
+	in(col, values) {
+		if (!Array.isArray(values) || values.length === 0) throw new Error("IN expression requires a non-empty array of values");
+		return {
+			type: "comparison",
+			left: col,
+			op: "IN",
+			right: values
+		};
+	}
+	notIn(col, values) {
+		if (!Array.isArray(values) || values.length === 0) throw new Error("NOT IN expression requires a non-empty array of values");
+		return {
+			type: "comparison",
+			left: col,
+			op: "NOT IN",
+			right: values
+		};
+	}
+	and(...expressions) {
+		return {
+			type: "logical",
+			op: "AND",
+			expressions
+		};
+	}
+	or(...expressions) {
+		return {
+			type: "logical",
+			op: "OR",
+			expressions
+		};
+	}
+	length(col) {
+		return {
+			type: "function",
+			name: "length",
+			args: [col]
+		};
+	}
+	lower(col) {
+		return {
+			type: "function",
+			name: "lower",
+			args: [col]
+		};
+	}
+	upper(col) {
+		return {
+			type: "function",
+			name: "upper",
+			args: [col]
+		};
+	}
+	trim(col) {
+		return {
+			type: "function",
+			name: "trim",
+			args: [col]
+		};
+	}
+	coalesce(col, defaultValue) {
+		return {
+			type: "function",
+			name: "coalesce",
+			args: [col, defaultValue]
+		};
+	}
+	fnEq(fn, value) {
+		return {
+			type: "comparison",
+			left: fn,
+			op: "=",
+			right: value
+		};
+	}
+	fnNeq(fn, value) {
+		return {
+			type: "comparison",
+			left: fn,
+			op: "<>",
+			right: value
+		};
+	}
+	fnGt(fn, value) {
+		return {
+			type: "comparison",
+			left: fn,
+			op: ">",
+			right: value
+		};
+	}
+	fnGte(fn, value) {
+		return {
+			type: "comparison",
+			left: fn,
+			op: ">=",
+			right: value
+		};
+	}
+	fnLt(fn, value) {
+		return {
+			type: "comparison",
+			left: fn,
+			op: "<",
+			right: value
+		};
+	}
+	fnLte(fn, value) {
+		return {
+			type: "comparison",
+			left: fn,
+			op: "<=",
+			right: value
+		};
+	}
+	raw(sql) {
+		return {
+			type: "raw",
+			sql
+		};
+	}
+	toSQL(expr) {
+		return exprToSQL(expr);
+	}
+};
+var Check = class {
+	#name;
+	#expr;
+	constructor(name, expr) {
+		this.#name = name;
+		this.#expr = expr;
+	}
+	getName() {
+		return this.#name.includes("check") ? this.#name : `${this.#name}_check`;
+	}
+	getExpression() {
+		return exprToSQL(this.#expr);
+	}
+	toSnapshotExpr() {
+		return exprToSnapshot(this.#expr);
+	}
+};
+function check(name, expr) {
+	return new Check(name, expr);
+}
+function formatValue(value) {
+	if (value === null) return "NULL";
+	if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+	if (typeof value === "number") return String(value);
+	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+	if (value instanceof Date) return `'${value.toISOString()}'`;
+	return String(value);
+}
+function exprToSQL(expr) {
+	if (expr.type === "raw") return expr.sql;
+	if (expr.type === "comparison") {
+		let left;
+		if (isTableCol(expr.left)) left = `"${expr.left.name}"`;
+		else if (expr.left.type === "function") left = exprToSQL(expr.left);
+		else left = String(expr.left);
+		if (expr.op === "IN" || expr.op === "NOT IN") {
+			if (Array.isArray(expr.right)) {
+				const list = expr.right.map((v) => isTableCol(v) ? `"${v.name}"` : formatValue(v)).join(", ");
+				return `${left} ${expr.op} (${list})`;
+			}
+			const singleRight = isTableCol(expr.right) ? `"${expr.right.name}"` : formatValue(expr.right);
+			return `${left} ${expr.op} (${singleRight})`;
+		}
+		const right = isTableCol(expr.right) ? `"${expr.right.name}"` : formatValue(expr.right);
+		return `${left} ${expr.op} ${right}`;
+	}
+	if (expr.type === "logical") return `(${expr.expressions.map((e) => exprToSQL(e)).join(` ${expr.op} `)})`;
+	if (expr.type === "function") {
+		const args = expr.args.map((arg) => isTableCol(arg) ? `"${arg.name}"` : formatValue(arg));
+		return `${expr.name}(${args.join(", ")})`;
+	}
+	throw new Error("Unknown expression type");
+}
+function exprToSnapshot(expr) {
+	if (expr.type === "raw") return {
+		type: "raw",
+		sql: expr.sql
+	};
+	if (expr.type === "comparison") {
+		let left;
+		if (isTableCol(expr.left)) left = expr.left.name;
+		else if (expr.left.type === "function") left = exprToSnapshot(expr.left);
+		else left = String(expr.left);
+		const right = isTableCol(expr.right) ? expr.right.name : expr.right;
+		return {
+			type: "comparison",
+			left,
+			op: expr.op,
+			right
+		};
+	}
+	if (expr.type === "logical") return {
+		type: "logical",
+		op: expr.op,
+		expressions: expr.expressions.map((e) => exprToSnapshot(e))
+	};
+	if (expr.type === "function") return {
+		type: "function",
+		name: expr.name,
+		args: expr.args.map((arg) => isTableCol(arg) ? arg.name : arg)
+	};
+	throw new Error("Unknown expression type");
+}
+function snapshotExprToSQL(expr) {
+	if (expr.type === "raw") return expr.sql;
+	if (expr.type === "comparison") {
+		const left = typeof expr.left === "string" ? `"${expr.left}"` : snapshotExprToSQL(expr.left);
+		const right = formatSnapshotValue(expr.right);
+		return `${left} ${expr.op} ${right}`;
+	}
+	if (expr.type === "logical") return expr.expressions.map((e) => snapshotExprToSQL(e)).map((p) => `(${p})`).join(` ${expr.op} `);
+	if (expr.type === "function") {
+		const args = expr.args.map((a) => typeof a === "string" ? `"${a}"` : formatSnapshotValue(a));
+		return `${expr.name}(${args.join(", ")})`;
+	}
+	throw new Error("Unknown expression type");
+}
+function formatSnapshotValue(value) {
+	if (value === null) return "NULL";
+	if (Array.isArray(value)) return `(${value.map((v) => formatSnapshotValue(v)).join(", ")})`;
+	if (typeof value === "string") return `'${value.replace(/'/g, "''")}'`;
+	if (typeof value === "number") return String(value);
+	if (typeof value === "boolean") return value ? "TRUE" : "FALSE";
+	return String(value);
+}
+//#endregion
+export { CheckBuilder, check, snapshotExprToSQL };

package/dist/src/constraints/primary-key.d.mts

@@ -0,0 +1,28 @@
+import { AnyColumn, AnyTableWithColumns, TableColumn } from "../table.mjs";
+
+//#region src/constraints/primary-key.d.ts
+declare class PrimaryKeyConstraint {
+  #private;
+  constructor(name: string, columns: TableColumn<string, string, Key, AnyColumn>[]);
+  getName<TTable extends AnyTableWithColumns>(table: TTable): string;
+  getColumns(): string[];
+}
+/**
+ * Creates a named table-level PRIMARY KEY constraint on two or more columns.
+ * A table can have at most one primary key constraint.
+ * For single-column primary key, use the column-level `pk()` function instead.
+ *
+ * This function is passed as the second parameter to the `primaryKeyConstraint` callback.
+ *
+ * @example
+ * ```ts
+ * table("public", "user_roles", { userId: bigint({}), roleId: bigint({}) }, {
+ *   primaryKeyConstraint: (t, primaryKey) =>
+ *     primaryKey("pk", [t.userId, t.roleId]),
+ * });
+ * ```
+ */
+declare function primaryKeyConstraint(name: string, columns: [TableColumn<string, string, Key, AnyColumn>, TableColumn<string, string, Key, AnyColumn>, ...TableColumn<string, string, Key, AnyColumn>[]]): PrimaryKeyConstraint;
+type PrimaryKeyConstraintFn = typeof primaryKeyConstraint;
+//#endregion
+export { PrimaryKeyConstraint, PrimaryKeyConstraintFn, primaryKeyConstraint };

package/dist/src/constraints/primary-key.mjs

@@ -0,0 +1,36 @@
+//#region src/constraints/primary-key.ts
+var PrimaryKeyConstraint = class {
+	#name;
+	#columns;
+	constructor(name, columns) {
+		if (columns.length < 2) throw new Error("PRIMARY KEY constraint requires at least two columns. For single-column primary key, use the column-level 'pk()' function 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 PRIMARY KEY constraint on two or more columns.
+* A table can have at most one primary key constraint.
+* For single-column primary key, use the column-level `pk()` function instead.
+*
+* This function is passed as the second parameter to the `primaryKeyConstraint` callback.
+*
+* @example
+* ```ts
+* table("public", "user_roles", { userId: bigint({}), roleId: bigint({}) }, {
+*   primaryKeyConstraint: (t, primaryKey) =>
+*     primaryKey("pk", [t.userId, t.roleId]),
+* });
+* ```
+*/
+function primaryKeyConstraint(name, columns) {
+	return new PrimaryKeyConstraint(name, columns);
+}
+//#endregion
+export { PrimaryKeyConstraint, primaryKeyConstraint };

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

@@ -0,0 +1,28 @@
+import { AnyColumn, AnyTableWithColumns, TableColumn } from "../table.mjs";
+
+//#region src/constraints/unique.d.ts
+declare class UniqueConstraint {
+  #private;
+  constructor(name: string, columns: TableColumn<string, string, Key, AnyColumn>[]);
+  getName<TTable extends AnyTableWithColumns>(table: TTable): string;
+  getColumns(): string[];
+}
+/**
+ * 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]),
+ *   ],
+ * });
+ * ```
+ */
+declare function uniqueConstraint(name: string, columns: [TableColumn<string, string, Key, AnyColumn>, TableColumn<string, string, Key, AnyColumn>, ...TableColumn<string, string, Key, AnyColumn>[]]): UniqueConstraint;
+type UniqueConstraintFn = typeof uniqueConstraint;
+//#endregion
+export { UniqueConstraint, UniqueConstraintFn, uniqueConstraint };