durcno 1.0.0-alpha.0

package/dist/src/columns/common.mjs

@@ -0,0 +1,276 @@
+import { entityType } from "../symbols.mjs";
+import { Arg } from "../query-builders/pre.mjs";
+import { camelToSnake } from "../utils.mjs";
+import { Sql } from "../sql.mjs";
+import * as z from "zod";
+//#region src/columns/common.ts
+const notNull = true;
+const unique = true;
+const primaryKey = true;
+var Column = class {
+	static [entityType] = "Column";
+	config;
+	$;
+	ValType;
+	ValTypeInsert;
+	ValTypeUpdate;
+	ValTypeSelect;
+	#default;
+	#insertFn;
+	#updateFn;
+	#primaryKey;
+	#unique;
+	#notNull;
+	#generated;
+	#as;
+	#references;
+	#name;
+	#nameSnake;
+	#table;
+	constructor(config) {
+		this.config = config;
+		this.#primaryKey = "primaryKey" in config ? !!config.primaryKey : false;
+		this.#unique = "unique" in config ? !!config.unique : false;
+		this.#notNull = "notNull" in config ? !!config.notNull : false;
+		this.#generated = "generated" in config ? config.generated : void 0;
+		this.#as = "as" in config ? config.as : void 0;
+		this.#references = void 0;
+	}
+	_ = {
+		setName: (name) => {
+			this.#name = name;
+			this.#nameSnake = camelToSnake(name);
+		},
+		setTable: (table) => {
+			this.#table = table;
+		}
+	};
+	get name() {
+		return this.#name;
+	}
+	get nameSnake() {
+		return this.#nameSnake;
+	}
+	get table() {
+		return this.#table;
+	}
+	get generated() {
+		return this.#generated;
+	}
+	get as() {
+		return this.#as;
+	}
+	get isPrimaryKey() {
+		return this.#primaryKey;
+	}
+	get isGenerated() {
+		return typeof this.#generated === "string";
+	}
+	get isUnique() {
+		return this.#unique;
+	}
+	get isNotNull() {
+		return this.#notNull;
+	}
+	get sqlType() {
+		const base = this.sqlTypeScalar;
+		if (!this.config.dimension) return base;
+		return `${base}${this.config.dimension.map((d) => d === null ? "[]" : `[${d}]`).join("")}`;
+	}
+	get zodType() {
+		let schema = this.zodTypeScaler;
+		if (!this.config.dimension) return schema;
+		for (const dim of this.config.dimension) if (typeof dim === "number") schema = z.tuple(Array(dim).map(() => schema));
+		else schema = z.array(schema);
+		return schema;
+	}
+	/**
+	* Returns the fully-qualified, double-quoted column identifier separated by a dot.
+	* @returns string `"table"."column"`
+	*/
+	get fullName() {
+		return `"${this.table?._.name}"."${this.nameSnake}"`;
+	}
+	/**
+	* Converts a JavaScript value to the PostgreSQL driver format.
+	* Handles array dimensions if configured, otherwise delegates to scalar implementation.
+	*/
+	toDriver(value) {
+		if (value === null) return null;
+		if (value instanceof Sql) return value.string;
+		if (!this.config.dimension) return this.toDriverScalar(value);
+		return value.map((item) => this.#toDriverArrayElement(item, 0));
+	}
+	/**
+	* Helper to recursively process multi-dimensional arrays for toDriver.
+	*/
+	#toDriverArrayElement(value, dimIndex) {
+		if (dimIndex >= this.config.dimension.length - 1) return this.toDriverScalar(value);
+		return value.map((item) => this.#toDriverArrayElement(item, dimIndex + 1));
+	}
+	/**
+	* Converts a JavaScript value to SQL string literal.
+	* Handles array dimensions with ARRAY[...] syntax if configured.
+	*/
+	toSQL(value) {
+		if (value instanceof Sql) return value.string;
+		if (!this.config.dimension) return this.toSQLScalar(value);
+		return this.#toSQLArray(value, 0);
+	}
+	/**
+	* Helper to recursively process multi-dimensional arrays for toSQL.
+	*/
+	#toSQLArray(arr, dimIndex) {
+		const dimensions = this.config.dimension;
+		if (arr.length === 0) return "'{}'";
+		if (dimIndex >= dimensions.length - 1) return `ARRAY[${arr.map((item) => this.toSQLScalar(item)).join(", ")}]`;
+		return `ARRAY[${arr.map((item) => this.#toSQLArray(item, dimIndex + 1)).join(", ")}]`;
+	}
+	/**
+	* Converts a PostgreSQL result back to JavaScript value.
+	* Handles array dimensions if configured, otherwise delegates to scalar implementation.
+	*/
+	fromDriver(value) {
+		if (value === null) return null;
+		if (!this.config.dimension) return this.fromDriverScalar(value);
+		let arr;
+		if (typeof value === "string") arr = this.#parsePostgresArrayString(value);
+		else arr = value;
+		return this.#fromDriverArray(arr, 0);
+	}
+	/**
+	* Parses a PostgreSQL array string format like {val1,val2,val3} into a JavaScript array.
+	* Handles nested arrays and quoted strings.
+	*/
+	#parsePostgresArrayString(str) {
+		if (str === "{}") return [];
+		const inner = str.slice(1, -1);
+		const result = [];
+		let depth = 0;
+		let current = "";
+		let inQuotes = false;
+		for (let i = 0; i < inner.length; i++) {
+			const char = inner[i];
+			if (char === "\"" && (i === 0 || inner[i - 1] !== "\\")) {
+				inQuotes = !inQuotes;
+				current += char;
+			} else if (!inQuotes && char === "{") {
+				depth++;
+				current += char;
+			} else if (!inQuotes && char === "}") {
+				depth--;
+				current += char;
+			} else if (!inQuotes && char === "," && depth === 0) {
+				result.push(this.#parsePostgresArrayElement(current));
+				current = "";
+			} else current += char;
+		}
+		if (current) result.push(this.#parsePostgresArrayElement(current));
+		return result;
+	}
+	/**
+	* Parses a single element from a PostgreSQL array string.
+	*/
+	#parsePostgresArrayElement(element) {
+		if (element.startsWith("{") && element.endsWith("}")) return this.#parsePostgresArrayString(element);
+		if (element.startsWith("\"") && element.endsWith("\"")) return element.slice(1, -1).replace(/\\"/g, "\"").replace(/\\\\/g, "\\");
+		if (element === "NULL") return null;
+		return element;
+	}
+	/**
+	* Helper to recursively process multi-dimensional arrays for fromDriver.
+	*/
+	#fromDriverArray(arr, dimIndex) {
+		if (dimIndex >= this.config.dimension.length - 1) return arr.map((item) => this.fromDriverScalar(item));
+		return arr.map((item) => this.#fromDriverArray(item, dimIndex + 1));
+	}
+	/**
+	* Sets a default value for this column.
+	* SQL equivalent: `DEFAULT <value>`
+	* @param value - The default value or SQL expression
+	* @returns this column instance
+	*/
+	default(value) {
+		this.#default = value;
+		return this;
+	}
+	get hasDefault() {
+		return this.#default !== void 0;
+	}
+	defaultToSQL() {
+		if (this.#default === void 0) return void 0;
+		return this.toSQL(this.#default);
+	}
+	/**
+	* Sets a foreign key reference for this column.
+	* SQL equivalent: `REFERENCES <table>(<column>) [ON DELETE <action>]`
+	* @param ref - A function returning the referenced column, or an object with column and onDelete
+	* @returns this column instance
+	*/
+	references(ref) {
+		if (typeof ref === "function") this.#references = {
+			column: ref,
+			onDelete: "CASCADE"
+		};
+		else this.#references = {
+			column: ref.column,
+			onDelete: ref.onDelete ?? "CASCADE"
+		};
+		return this;
+	}
+	get hasReferences() {
+		return this.#references !== void 0;
+	}
+	get referencesCol() {
+		return this.#references ? this.#references.column() : null;
+	}
+	get referencesOnDelete() {
+		return this.#references ? this.#references.onDelete : null;
+	}
+	/**
+	* 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>
+	*/
+	$insertFn(fn) {
+		this.#insertFn = fn;
+		return this;
+	}
+	get hasInsertFn() {
+		return this.#insertFn !== void 0;
+	}
+	getInsertFnVal() {
+		return this.#insertFn ? this.#insertFn() : null;
+	}
+	/**
+	* Sets a function to be called during UPDATE queries to generate a value.
+	* @param fn - A function that returns the value to use in updates
+	* @returns HasUpdateFn<this>
+	*/
+	$updateFn(fn) {
+		this.#updateFn = fn;
+		return this;
+	}
+	get hasUpdateFn() {
+		return this.#updateFn !== void 0;
+	}
+	getUpdateFnVal() {
+		return this.#updateFn ? this.#updateFn() : null;
+	}
+	/**
+	* Specifies the TypeScript type for this column's value.
+	* This is a compile-time only operation and does not affect runtime behavior.
+	* @returns this column with the specified value type
+	*/
+	$type() {
+		return this;
+	}
+	/** Creates an `Arg` instance for this column, to be used in prepared queries.
+	* @returns an `Arg` instance with the type of this column
+	*/
+	arg() {
+		return new Arg(this.toDriver.bind(this));
+	}
+};
+//#endregion
+export { Column, notNull, primaryKey, unique };

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

@@ -0,0 +1,19 @@
+import { Sql } from "../sql.mjs";
+import { Column, ColumnConfig } from "./common.mjs";
+import * as z from "zod";
+
+//#region src/columns/date.d.ts
+type DateValType = Date;
+type DateConfig = ColumnConfig;
+declare class DateColumn<TConfig extends DateConfig> extends Column<TConfig, DateValType> {
+  static readonly id = "Column.Date";
+  get sqlTypeScalar(): string;
+  get zodTypeScaler(): z.ZodDate;
+  toDriverScalar(value: DateValType | Sql | null): string | null;
+  toSQLScalar(value: Date | Sql | null): string;
+  fromDriverScalar(value: Date | string | null): DateValType | null;
+}
+/** Creates a `date` column. PostgreSQL calendar date (no time), maps to `Date`. */
+declare function date<TConfig extends DateConfig>(config: TConfig): DateColumn<TConfig>;
+//#endregion
+export { date };

package/dist/src/columns/date.mjs

@@ -0,0 +1,32 @@
+import { Column } from "./common.mjs";
+import { Sql } from "../sql.mjs";
+import * as z from "zod";
+//#region src/columns/date.ts
+var DateColumn = class extends Column {
+	static id = "Column.Date";
+	get sqlTypeScalar() {
+		return "date";
+	}
+	get zodTypeScaler() {
+		return z.date();
+	}
+	toDriverScalar(value) {
+		if (value === null) return null;
+		return value instanceof Sql ? value.string : value.toISOString().slice(0, 10);
+	}
+	toSQLScalar(value) {
+		if (value === null) return "NULL";
+		return value instanceof Sql ? value.string : `'${value.toISOString().slice(0, 10)}'`;
+	}
+	fromDriverScalar(value) {
+		if (value === null) return null;
+		if (value instanceof Date) return new Date(Date.UTC(value.getFullYear(), value.getMonth(), value.getDate()));
+		return /* @__PURE__ */ new Date(`${value}T00:00:00Z`);
+	}
+};
+/** Creates a `date` column. PostgreSQL calendar date (no time), maps to `Date`. */
+function date(config) {
+	return new DateColumn(config);
+}
+//#endregion
+export { date };

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

@@ -0,0 +1,21 @@
+import { Sql } from "../sql.mjs";
+import { Column, ColumnConfig } from "./common.mjs";
+import { Enum } from "../enumtype.mjs";
+import * as z from "zod";
+
+//#region src/columns/enum.d.ts
+type EnumedConfig = ColumnConfig;
+declare class EnumedColumn<TValue extends string, TConfig extends EnumedConfig> extends Column<TConfig, TValue> {
+  #private;
+  static readonly id = "Column.Enumed";
+  constructor(enm: Enum<TValue>, config: TConfig);
+  get sqlTypeScalar(): string;
+  get zodTypeScaler(): z.ZodEnum<{ [k_1 in TValue]: k_1 } extends infer T ? { [k in keyof T]: T[k] } : never>;
+  toDriverScalar(value: TValue | Sql | null): string | null;
+  toSQLScalar(value: TValue | Sql | null): string;
+  fromDriverScalar(value: TValue | null): TValue | null;
+}
+/** Creates an `enum` column bound to a user-defined PostgreSQL enum type. Maps to a union of string literals. */
+declare function enumed<TValue extends string, TConfig extends EnumedConfig>(enm: Enum<TValue>, config: TConfig): EnumedColumn<TValue, TConfig>;
+//#endregion
+export { EnumedColumn, EnumedConfig, enumed };

package/dist/src/columns/enum.mjs

@@ -0,0 +1,35 @@
+import { Column } from "./common.mjs";
+import { Sql } from "../sql.mjs";
+import * as z from "zod";
+//#region src/columns/enum.ts
+var EnumedColumn = class extends Column {
+	static id = "Column.Enumed";
+	#enum;
+	constructor(enm, config) {
+		super(config);
+		this.#enum = enm;
+	}
+	get sqlTypeScalar() {
+		return `"${this.#enum.schema}"."${this.#enum.name}"`;
+	}
+	get zodTypeScaler() {
+		return z.enum(this.#enum.values);
+	}
+	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 an `enum` column bound to a user-defined PostgreSQL enum type. Maps to a union of string literals. */
+function enumed(enm, config) {
+	return new EnumedColumn(enm, config);
+}
+//#endregion
+export { enumed };

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

@@ -0,0 +1,19 @@
+import { Sql } from "../sql.mjs";
+import { Column, ColumnConfig } from "./common.mjs";
+import * as z from "zod";
+
+//#region src/columns/inet.d.ts
+type InetValType = string;
+type InetConfig = ColumnConfig;
+declare class InetColumn<TConfig extends InetConfig> extends Column<TConfig, InetValType> {
+  static readonly id = "Column.Inet";
+  get sqlTypeScalar(): string;
+  get zodTypeScaler(): z.ZodUnion<readonly [z.ZodIPv4, z.ZodIPv6, z.ZodCIDRv4, z.ZodCIDRv6]>;
+  toDriverScalar(value: InetValType | Sql | null): string | null;
+  toSQLScalar(value: InetValType | Sql | null): string;
+  fromDriverScalar(value: string | null): InetValType | null;
+}
+/** Creates an `inet` column. PostgreSQL IPv4/IPv6 host address type, maps to `string`. */
+declare function inet<TConfig extends InetConfig>(config: TConfig): InetColumn<TConfig>;
+//#endregion
+export { inet };

package/dist/src/columns/inet.mjs

@@ -0,0 +1,36 @@
+import { Column } from "./common.mjs";
+import { Sql } from "../sql.mjs";
+import * as z from "zod";
+//#region src/columns/inet.ts
+var InetColumn = class extends Column {
+	static id = "Column.Inet";
+	get sqlTypeScalar() {
+		return "inet";
+	}
+	get zodTypeScaler() {
+		return z.union([
+			z.ipv4(),
+			z.ipv6(),
+			z.cidrv4(),
+			z.cidrv6()
+		]);
+	}
+	toDriverScalar(value) {
+		if (value === null) return null;
+		return value instanceof Sql ? value.string : value;
+	}
+	toSQLScalar(value) {
+		if (value === null) return "NULL";
+		if (value instanceof Sql) return value.string;
+		return `'${value.replace(/'/g, "''")}'`;
+	}
+	fromDriverScalar(value) {
+		return value;
+	}
+};
+/** Creates an `inet` column. PostgreSQL IPv4/IPv6 host address type, maps to `string`. */
+function inet(config) {
+	return new InetColumn(config);
+}
+//#endregion
+export { inet };

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

@@ -0,0 +1,19 @@
+import { Sql } from "../sql.mjs";
+import { Column, ColumnConfig } from "./common.mjs";
+import * as z from "zod";
+
+//#region src/columns/integer.d.ts
+type IntegerValType = number;
+type IntegerConfig = ColumnConfig;
+declare class IntegerColumn<TConfig extends IntegerConfig> extends Column<TConfig, IntegerValType> {
+  static readonly id = "Column.Integer";
+  get sqlTypeScalar(): string;
+  get zodTypeScaler(): z.ZodCoercedNumber<unknown>;
+  toDriverScalar(value: IntegerValType | Sql | null): string | number | null;
+  toSQLScalar(value: number | Sql | null): string;
+  fromDriverScalar(value: number | string | null): IntegerValType | null;
+}
+/** Creates an `integer` column. PostgreSQL 32-bit signed integer, maps to `number`. */
+declare function integer<TConfig extends IntegerConfig>(config: TConfig): IntegerColumn<TConfig>;
+//#endregion
+export { integer };

package/dist/src/columns/integer.mjs

@@ -0,0 +1,32 @@
+import { Column } from "./common.mjs";
+import { Sql } from "../sql.mjs";
+import * as z from "zod";
+//#region src/columns/integer.ts
+var IntegerColumn = class extends Column {
+	static id = "Column.Integer";
+	get sqlTypeScalar() {
+		return "integer";
+	}
+	get zodTypeScaler() {
+		return z.coerce.number();
+	}
+	toDriverScalar(value) {
+		if (value === null) return null;
+		return value instanceof Sql ? value.string : value;
+	}
+	toSQLScalar(value) {
+		if (value === null) return "NULL";
+		if (value instanceof Sql) return value.string;
+		return value.toString();
+	}
+	fromDriverScalar(value) {
+		if (value === null) return null;
+		return typeof value === "string" ? parseInt(value, 10) : value;
+	}
+};
+/** Creates an `integer` column. PostgreSQL 32-bit signed integer, maps to `number`. */
+function integer(config) {
+	return new IntegerColumn(config);
+}
+//#endregion
+export { integer };

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

@@ -0,0 +1,52 @@
+import { Sql } from "../sql.mjs";
+import { Column, ColumnConfig } from "./common.mjs";
+import * as z from "zod";
+
+//#region src/columns/json.d.ts
+/**
+ * The base value type for JSON columns.
+ * JSON can store any valid JSON value: objects, arrays, strings, numbers, booleans, or null.
+ */
+type JsonValType = unknown;
+type JsonConfig = ColumnConfig;
+/**
+ * PostgreSQL JSON column type.
+ * Stores JSON data in text format, preserving exact input formatting.
+ *
+ * Key differences from JSONB:
+ * - Preserves whitespace and key ordering
+ * - No indexing support for JSON path queries
+ * - Slightly faster to insert (no parsing overhead)
+ * - Slower to query (must be reparsed on each access)
+ *
+ * Use $type<T>() to specify a TypeScript type for the column value.
+ *
+ * @example
+ * ```ts
+ * // Basic JSON column
+ * const table = table('users', {
+ *   metadata: json({}),
+ * });
+ *
+ * // Typed JSON column
+ * interface UserSettings {
+ *   theme: 'light' | 'dark';
+ *   notifications: boolean;
+ * }
+ * const table = table('users', {
+ *   settings: json({}).$type<UserSettings>(),
+ * });
+ * ```
+ */
+declare class JsonColumn<TConfig extends JsonConfig> extends Column<TConfig, JsonValType> {
+  static readonly id = "Column.Json";
+  get sqlTypeScalar(): string;
+  get zodTypeScaler(): z.ZodUnknown;
+  toDriverScalar(value: JsonValType | Sql | null): string | null;
+  toSQLScalar(value: JsonValType | Sql | null): string;
+  fromDriverScalar(value: unknown): JsonValType | null;
+}
+/** Creates a `json` column. Stores JSON as text, preserving formatting. Maps to `unknown` (use `$type<T>()` to narrow). */
+declare function json<TConfig extends JsonConfig>(config: TConfig): JsonColumn<TConfig>;
+//#endregion
+export { json };

package/dist/src/columns/json.mjs

@@ -0,0 +1,67 @@
+import { Column } from "./common.mjs";
+import { Sql } from "../sql.mjs";
+import * as z from "zod";
+//#region src/columns/json.ts
+/**
+* PostgreSQL JSON column type.
+* Stores JSON data in text format, preserving exact input formatting.
+*
+* Key differences from JSONB:
+* - Preserves whitespace and key ordering
+* - No indexing support for JSON path queries
+* - Slightly faster to insert (no parsing overhead)
+* - Slower to query (must be reparsed on each access)
+*
+* Use $type<T>() to specify a TypeScript type for the column value.
+*
+* @example
+* ```ts
+* // Basic JSON column
+* const table = table('users', {
+*   metadata: json({}),
+* });
+*
+* // Typed JSON column
+* interface UserSettings {
+*   theme: 'light' | 'dark';
+*   notifications: boolean;
+* }
+* const table = table('users', {
+*   settings: json({}).$type<UserSettings>(),
+* });
+* ```
+*/
+var JsonColumn = class extends Column {
+	static id = "Column.Json";
+	get sqlTypeScalar() {
+		return "json";
+	}
+	get zodTypeScaler() {
+		return z.unknown();
+	}
+	toDriverScalar(value) {
+		if (value === null) return null;
+		if (value instanceof Sql) return value.string;
+		return JSON.stringify(value);
+	}
+	toSQLScalar(value) {
+		if (value === null) return "NULL";
+		if (value instanceof Sql) return value.string;
+		return `'${JSON.stringify(value).replace(/'/g, "''")}'::json`;
+	}
+	fromDriverScalar(value) {
+		if (value === null) return null;
+		if (typeof value === "string") try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+		return value;
+	}
+};
+/** Creates a `json` column. Stores JSON as text, preserving formatting. Maps to `unknown` (use `$type<T>()` to narrow). */
+function json(config) {
+	return new JsonColumn(config);
+}
+//#endregion
+export { json };

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

@@ -0,0 +1,53 @@
+import { Sql } from "../sql.mjs";
+import { Column, ColumnConfig } from "./common.mjs";
+import * as z from "zod";
+
+//#region src/columns/jsonb.d.ts
+/**
+ * The base value type for JSONB columns.
+ * JSONB can store any valid JSON value: objects, arrays, strings, numbers, booleans, or null.
+ */
+type JsonbValType = unknown;
+type JsonbConfig = ColumnConfig;
+/**
+ * PostgreSQL JSONB column type.
+ * Stores JSON data in a decomposed binary format for efficient processing.
+ *
+ * Key differences from JSON:
+ * - Does not preserve whitespace or key ordering
+ * - Supports GIN indexing for fast path queries
+ * - Slightly slower to insert (parsing overhead)
+ * - Faster to query (no reparsing needed)
+ * - Supports containment and existence operators (@>, ?, ?|, ?&)
+ *
+ * Use $type<T>() to specify a TypeScript type for the column value.
+ *
+ * @example
+ * ```ts
+ * // Basic JSONB column
+ * const table = table('users', {
+ *   metadata: jsonb({}),
+ * });
+ *
+ * // Typed JSONB column
+ * interface UserSettings {
+ *   theme: 'light' | 'dark';
+ *   notifications: boolean;
+ * }
+ * const table = table('users', {
+ *   settings: jsonb({}).$type<UserSettings>(),
+ * });
+ * ```
+ */
+declare class JsonbColumn<TConfig extends JsonbConfig> extends Column<TConfig, JsonbValType> {
+  static readonly id = "Column.Jsonb";
+  get sqlTypeScalar(): string;
+  get zodTypeScaler(): z.ZodUnknown;
+  toDriverScalar(value: JsonbValType | Sql | null): string | null;
+  toSQLScalar(value: JsonbValType | Sql | null): string;
+  fromDriverScalar(value: unknown): JsonbValType | null;
+}
+/** Creates a `jsonb` column. Stores JSON in decomposed binary format for efficient querying. Maps to `unknown` (use `$type<T>()` to narrow). */
+declare function jsonb<TConfig extends JsonbConfig>(config: TConfig): JsonbColumn<TConfig>;
+//#endregion
+export { jsonb };