alepha 0.12.1 → 0.13.1

package/dist/orm/index.cjs

@@ -1,2986 +0,0 @@
-//#region rolldown:runtime
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __copyProps = (to, from, except, desc$1) => {
-	if (from && typeof from === "object" || typeof from === "function") {
-		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
-			key = keys[i];
-			if (!__hasOwnProp.call(to, key) && key !== except) {
-				__defProp(to, key, {
-					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc$1 = __getOwnPropDesc(from, key)) || desc$1.enumerable
-				});
-			}
-		}
-	}
-	return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
-	value: mod,
-	enumerable: true
-}) : target, mod));
-
-//#endregion
-let alepha = require("alepha");
-let alepha_datetime = require("alepha/datetime");
-let drizzle_orm = require("drizzle-orm");
-drizzle_orm = __toESM(drizzle_orm);
-let drizzle_orm_pg_core = require("drizzle-orm/pg-core");
-drizzle_orm_pg_core = __toESM(drizzle_orm_pg_core);
-let node_fs_promises = require("node:fs/promises");
-let alepha_logger = require("alepha/logger");
-let drizzle_orm_sql_sql = require("drizzle-orm/sql/sql");
-let node_module = require("node:module");
-let alepha_lock = require("alepha/lock");
-let drizzle_orm_postgres_js = require("drizzle-orm/postgres-js");
-let drizzle_orm_postgres_js_migrator = require("drizzle-orm/postgres-js/migrator");
-let postgres = require("postgres");
-postgres = __toESM(postgres);
-let drizzle_orm_sqlite_proxy = require("drizzle-orm/sqlite-proxy");
-let drizzle_orm_sqlite_proxy_migrator = require("drizzle-orm/sqlite-proxy/migrator");
-let node_crypto = require("node:crypto");
-let drizzle_orm_sqlite_core = require("drizzle-orm/sqlite-core");
-drizzle_orm_sqlite_core = __toESM(drizzle_orm_sqlite_core);
-let drizzle_orm_pglite_migrator = require("drizzle-orm/pglite/migrator");
-let alepha_retry = require("alepha/retry");
-
-//#region src/orm/constants/PG_SYMBOLS.ts
-const PG_DEFAULT = Symbol.for("Alepha.Postgres.Default");
-const PG_PRIMARY_KEY = Symbol.for("Alepha.Postgres.PrimaryKey");
-const PG_CREATED_AT = Symbol.for("Alepha.Postgres.CreatedAt");
-const PG_UPDATED_AT = Symbol.for("Alepha.Postgres.UpdatedAt");
-const PG_DELETED_AT = Symbol.for("Alepha.Postgres.DeletedAt");
-const PG_VERSION = Symbol.for("Alepha.Postgres.Version");
-const PG_IDENTITY = Symbol.for("Alepha.Postgres.Identity");
-const PG_ENUM = Symbol.for("Alepha.Postgres.Enum");
-const PG_REF = Symbol.for("Alepha.Postgres.Ref");
-/**
-* @deprecated Use `PG_IDENTITY` instead.
-*/
-const PG_SERIAL = Symbol.for("Alepha.Postgres.Serial");
-
-//#endregion
-//#region src/orm/types/schema.ts
-/**
-* Postgres schema type.
-*/
-const schema = (name, document) => (0, drizzle_orm_pg_core.customType)({
-	dataType: () => "jsonb",
-	toDriver: (value) => JSON.stringify(value),
-	fromDriver: (value) => value && typeof value === "string" ? JSON.parse(value) : value
-})(name, { document }).$type();
-
-//#endregion
-//#region src/orm/schemas/insertSchema.ts
-const insertSchema = (obj) => {
-	const newProperties = {};
-	for (const key in obj.properties) {
-		const prop = obj.properties[key];
-		if (PG_DEFAULT in prop) newProperties[key] = alepha.t.optional(prop);
-		else newProperties[key] = prop;
-	}
-	return alepha.t.object(newProperties, "options" in schema && typeof schema.options === "object" ? { ...schema.options } : {});
-};
-
-//#endregion
-//#region src/orm/schemas/updateSchema.ts
-const updateSchema = (schema$1) => {
-	const newProperties = {};
-	for (const key in schema$1.properties) {
-		const prop = schema$1.properties[key];
-		if (alepha.t.schema.isOptional(prop)) newProperties[key] = alepha.t.optional(alepha.t.union([prop, alepha.t.raw.Null()]));
-		else newProperties[key] = prop;
-	}
-	return alepha.t.object(newProperties, "options" in schema$1 && typeof schema$1.options === "object" ? { ...schema$1.options } : {});
-};
-
-//#endregion
-//#region src/orm/descriptors/$entity.ts
-/**
-* Creates a database entity descriptor that defines table structure using TypeBox schemas.
-*
-* @example
-* ```ts
-* import { t } from "alepha";
-* import { $entity } from "alepha/orm";
-*
-* const userEntity = $entity({
-*   name: "users",
-*   schema: t.object({
-*     id: pg.primaryKey(),
-*     name: t.text(),
-*     email: t.email(),
-*   }),
-* });
-* ```
-*/
-const $entity = (options) => {
-	return new EntityDescriptor(options);
-};
-var EntityDescriptor = class EntityDescriptor {
-	options;
-	constructor(options) {
-		this.options = options;
-	}
-	alias(alias$1) {
-		const aliased = new EntityDescriptor(this.options);
-		return new Proxy(aliased, { get(target, prop, receiver) {
-			if (prop === "$alias") return alias$1;
-			return Reflect.get(target, prop, receiver);
-		} });
-	}
-	get cols() {
-		const cols = {};
-		for (const key of Object.keys(this.schema.properties)) cols[key] = {
-			name: key,
-			entity: this
-		};
-		return cols;
-	}
-	get name() {
-		return this.options.name;
-	}
-	get schema() {
-		return this.options.schema;
-	}
-	get insertSchema() {
-		return insertSchema(this.options.schema);
-	}
-	get updateSchema() {
-		return updateSchema(this.options.schema);
-	}
-};
-$entity[alepha.KIND] = EntityDescriptor;
-
-//#endregion
-//#region src/orm/errors/DbError.ts
-var DbError = class extends alepha.AlephaError {
-	name = "DbError";
-	constructor(message, cause) {
-		super(message, { cause });
-	}
-};
-
-//#endregion
-//#region src/orm/errors/DbConflictError.ts
-var DbConflictError = class extends DbError {
-	name = "DbConflictError";
-	status = 409;
-};
-
-//#endregion
-//#region src/orm/errors/DbEntityNotFoundError.ts
-var DbEntityNotFoundError = class extends DbError {
-	name = "DbEntityNotFoundError";
-	status = 404;
-	constructor(entityName) {
-		super(`Entity from '${entityName}' was not found`);
-	}
-};
-
-//#endregion
-//#region src/orm/errors/DbVersionMismatchError.ts
-/**
-* Error thrown when there is a version mismatch.
-* It's thrown by {@link Repository#save} when the updated entity version does not match the one in the database.
-* This is used for optimistic concurrency control.
-*/
-var DbVersionMismatchError = class extends DbError {
-	name = "DbVersionMismatchError";
-	constructor(table, id) {
-		super(`Version mismatch for table '${table}' and id '${id}'`);
-	}
-};
-
-//#endregion
-//#region src/orm/helpers/pgAttr.ts
-/**
-* Decorates a typebox schema with a Postgres attribute.
-*
-* > It's just a fancy way to add Symbols to a field.
-*
-* @example
-* ```ts
-* import { t } from "alepha";
-* import { PG_UPDATED_AT } from "../constants/PG_SYMBOLS";
-*
-* export const updatedAtSchema = pgAttr(
-*   t.datetime(), PG_UPDATED_AT,
-* );
-* ```
-*/
-const pgAttr = (type, attr, value) => {
-	Object.assign(type, { [attr]: value ?? {} });
-	return type;
-};
-/**
-* Retrieves the fields of a schema that have a specific attribute.
-*/
-const getAttrFields = (schema$1, name) => {
-	const fields = [];
-	for (const key of Object.keys(schema$1.properties)) {
-		const value = schema$1.properties[key];
-		if (name in value) fields.push({
-			type: value,
-			key,
-			data: value[name]
-		});
-	}
-	return fields;
-};
-
-//#endregion
-//#region src/orm/providers/drivers/DatabaseProvider.ts
-var DatabaseProvider = class {
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	log = (0, alepha_logger.$logger)();
-	enums = /* @__PURE__ */ new Map();
-	tables = /* @__PURE__ */ new Map();
-	sequences = /* @__PURE__ */ new Map();
-	get name() {
-		return "default";
-	}
-	get schema() {
-		return "public";
-	}
-	table(entity) {
-		const table = this.tables.get(entity.name);
-		if (!table) throw new alepha.AlephaError(`Table '${entity.name}' is not registered`);
-		const hasAlias = entity.$alias;
-		if (hasAlias) return (0, drizzle_orm_pg_core.alias)(table, hasAlias);
-		return table;
-	}
-	registerEntity(entity) {
-		this.builder.buildTable(entity, this);
-	}
-	registerSequence(sequence) {
-		this.builder.buildSequence(sequence, this);
-	}
-	async run(statement, schema$1) {
-		return (await this.execute(statement)).map((row) => this.alepha.codec.decode(schema$1, row));
-	}
-	/**
-	* Get migrations folder path - can be overridden
-	*/
-	getMigrationsFolder() {
-		return `migrations/${this.name}`;
-	}
-	/**
-	* Base migration orchestration - handles environment logic
-	*/
-	async migrateDatabase() {
-		const migrationsFolder = this.getMigrationsFolder();
-		if (this.alepha.isProduction()) await this.runProductionMigration(migrationsFolder);
-		else if (this.alepha.isTest()) await this.runTestMigration();
-		else await this.runDevelopmentMigration(migrationsFolder);
-	}
-	/**
-	* Production: run migrations from folder
-	*/
-	async runProductionMigration(migrationsFolder) {
-		if (!await (0, node_fs_promises.stat)(migrationsFolder).catch(() => false)) {
-			this.log.warn("Migration SKIPPED - no migrations found");
-			return;
-		}
-		this.log.debug(`Migrate from '${migrationsFolder}' directory ...`);
-		await this.executeMigrations(migrationsFolder);
-		this.log.info("Migration OK");
-	}
-	/**
-	* Test: always synchronize
-	*/
-	async runTestMigration() {
-		await this.synchronizeSchema();
-	}
-	/**
-	* Development: default to synchronize (can be overridden)
-	*/
-	async runDevelopmentMigration(migrationsFolder) {
-		try {
-			if (!this.url.includes(":memory:")) await this.executeMigrations(migrationsFolder);
-		} catch {}
-		await this.synchronizeSchema();
-	}
-	/**
-	* Common synchronization with error handling
-	*/
-	async synchronizeSchema() {
-		try {
-			await this.kit.synchronize(this);
-		} catch (error) {
-			throw new DbError(`Failed to synchronize ${this.dialect} database schema`, error);
-		}
-	}
-};
-
-//#endregion
-//#region src/orm/services/PgRelationManager.ts
-var PgRelationManager = class {
-	/**
-	* Recursively build joins for the query builder based on the relations map
-	*/
-	buildJoins(provider, builder, joins, withRelations, table, parentKey) {
-		for (const [key, join] of Object.entries(withRelations)) {
-			const from = provider.table(join.join);
-			const on = (0, drizzle_orm_sql_sql.isSQLWrapper)(join.on) ? join.on : drizzle_orm.sql`${table[join.on[0]]} = ${from[join.on[1].name]}`;
-			if (join.type === "right") builder.rightJoin(from, on);
-			else if (join.type === "inner") builder.innerJoin(from, on);
-			else builder.leftJoin(from, on);
-			joins.push({
-				key,
-				table: (0, drizzle_orm.getTableName)(from),
-				schema: join.join.schema,
-				col: (name) => from[name],
-				parent: parentKey
-			});
-			if (join.with) this.buildJoins(provider, builder, joins, join.with, from, parentKey ? `${parentKey}.${key}` : key);
-		}
-	}
-	/**
-	* Map a row with its joined relations based on the joins definition
-	*/
-	mapRowWithJoins(record, row, schema$1, joins, parentKey) {
-		for (const join of joins) if (join.parent === parentKey) {
-			const joinedData = row[join.table];
-			if (this.isAllNull(joinedData)) record[join.key] = void 0;
-			else {
-				record[join.key] = joinedData;
-				this.mapRowWithJoins(record[join.key], row, schema$1, joins, parentKey ? `${parentKey}.${join.key}` : join.key);
-			}
-		}
-		return record;
-	}
-	/**
-	* Check if all values in an object are null (indicates a left join with no match)
-	*/
-	isAllNull(obj) {
-		if (obj === null || obj === void 0) return true;
-		if (typeof obj !== "object") return false;
-		return Object.values(obj).every((val) => val === null);
-	}
-	/**
-	* Build a schema that includes all join properties recursively
-	*/
-	buildSchemaWithJoins(baseSchema, joins, parentPath) {
-		const schema$1 = alepha.TypeBoxValue.Clone(baseSchema);
-		const joinsAtThisLevel = joins.filter((j) => j.parent === parentPath);
-		for (const join of joinsAtThisLevel) {
-			const joinPath = parentPath ? `${parentPath}.${join.key}` : join.key;
-			const childJoins = joins.filter((j) => j.parent === joinPath);
-			let joinSchema = join.schema;
-			if (childJoins.length > 0) joinSchema = this.buildSchemaWithJoins(join.schema, joins, joinPath);
-			schema$1.properties[join.key] = alepha.t.optional(joinSchema);
-		}
-		return schema$1;
-	}
-};
-
-//#endregion
-//#region src/orm/services/PgJsonQueryManager.ts
-/**
-* Manages JSONB query generation for nested object and array queries in PostgreSQL.
-* This class handles complex nested queries using PostgreSQL's JSONB operators.
-*/
-var PgJsonQueryManager = class {
-	/**
-	* Check if a query contains nested JSONB queries.
-	* A nested query is when the value is an object with operator keys.
-	*/
-	hasNestedQuery(where) {
-		for (const [key, value] of Object.entries(where)) {
-			if (key === "and" || key === "or" || key === "not") continue;
-			if (value && typeof value === "object" && !Array.isArray(value)) {
-				const keys = Object.keys(value);
-				if (!keys.some((k) => [
-					"eq",
-					"ne",
-					"gt",
-					"gte",
-					"lt",
-					"lte",
-					"like",
-					"ilike",
-					"isNull",
-					"isNotNull",
-					"inArray",
-					"notInArray"
-				].includes(k)) && keys.length > 0) return true;
-			}
-		}
-		return false;
-	}
-	/**
-	* Build a JSONB query condition for nested object queries.
-	* Supports deep nesting like: { profile: { contact: { email: { eq: "test@example.com" } } } }
-	*
-	* @param column The JSONB column
-	* @param path The path to the nested property (e.g., ['profile', 'contact', 'email'])
-	* @param operator The filter operator (e.g., { eq: "test@example.com" })
-	* @param dialect Database dialect (postgresql or sqlite)
-	* @param columnSchema Optional schema of the JSON column for type inference
-	* @returns SQL condition
-	*/
-	buildJsonbCondition(column, path, operator, dialect, columnSchema) {
-		if (path.length === 0) return;
-		const isArrayOperator = operator.arrayContains !== void 0 || operator.arrayContained !== void 0 || operator.arrayOverlaps !== void 0;
-		let jsonValue;
-		if (dialect === "sqlite") jsonValue = drizzle_orm.sql`json_extract(${column}, ${`$.${path.join(".")}`})`;
-		else {
-			let jsonPath = drizzle_orm.sql`${column}`;
-			for (let i = 0; i < path.length - 1; i++) jsonPath = drizzle_orm.sql`${jsonPath}->${path[i]}`;
-			const lastPath = path[path.length - 1];
-			if (isArrayOperator) jsonValue = drizzle_orm.sql`${jsonPath}->${lastPath}`;
-			else jsonValue = drizzle_orm.sql`${jsonPath}->>${lastPath}`;
-		}
-		const fieldType = columnSchema ? this.getFieldType(columnSchema, path) : void 0;
-		return this.applyOperatorToJsonValue(jsonValue, operator, dialect, fieldType);
-	}
-	/**
-	* Build JSONB array query conditions.
-	* Supports queries like: { addresses: { city: { eq: "Wonderland" } } }
-	* which translates to: EXISTS (SELECT 1 FROM jsonb_array_elements(addresses) elem WHERE elem->>'city' = 'Wonderland')
-	*
-	* @param dialect Database dialect (postgresql or sqlite)
-	* Note: SQLite array queries are not yet supported
-	*/
-	buildJsonbArrayCondition(column, path, arrayPath, operator, dialect) {
-		if (dialect === "sqlite") throw new Error("Array queries in JSON columns are not yet supported for SQLite. Please use PostgreSQL for complex JSON array queries, or restructure your data.");
-		if (path.length === 0) return;
-		let jsonPath = drizzle_orm.sql`${column}`;
-		if (arrayPath) jsonPath = drizzle_orm.sql`${jsonPath}->${arrayPath}`;
-		const elemCondition = drizzle_orm.sql`elem->>${path[0]}`;
-		const condition = this.applyOperatorToJsonValue(elemCondition, operator, dialect);
-		if (!condition) return;
-		return drizzle_orm.sql`EXISTS (SELECT 1 FROM jsonb_array_elements(${jsonPath}) AS elem WHERE ${condition})`;
-	}
-	/**
-	* Apply a filter operator to a JSONB value.
-	* @param dialect Database dialect for appropriate casting syntax
-	* @param fieldType Optional field type from schema for smart casting
-	*/
-	applyOperatorToJsonValue(jsonValue, operator, dialect, fieldType) {
-		const castForNumeric = (value) => {
-			if (dialect === "sqlite") {
-				if (fieldType === "integer" || fieldType === "int") return drizzle_orm.sql`CAST(${value} AS INTEGER)`;
-				return drizzle_orm.sql`CAST(${value} AS REAL)`;
-			}
-			return drizzle_orm.sql`(${value})::numeric`;
-		};
-		if (typeof operator !== "object") return drizzle_orm.sql`${jsonValue} = ${operator}`;
-		const conditions = [];
-		if (operator.eq !== void 0) conditions.push(drizzle_orm.sql`${jsonValue} = ${operator.eq}`);
-		if (operator.ne !== void 0) conditions.push(drizzle_orm.sql`${jsonValue} != ${operator.ne}`);
-		if (operator.gt !== void 0) conditions.push(drizzle_orm.sql`${castForNumeric(jsonValue)} > ${operator.gt}`);
-		if (operator.gte !== void 0) conditions.push(drizzle_orm.sql`${castForNumeric(jsonValue)} >= ${operator.gte}`);
-		if (operator.lt !== void 0) conditions.push(drizzle_orm.sql`${castForNumeric(jsonValue)} < ${operator.lt}`);
-		if (operator.lte !== void 0) conditions.push(drizzle_orm.sql`${castForNumeric(jsonValue)} <= ${operator.lte}`);
-		if (operator.like !== void 0) conditions.push(drizzle_orm.sql`${jsonValue} LIKE ${operator.like}`);
-		if (operator.ilike !== void 0) if (dialect === "sqlite") conditions.push(drizzle_orm.sql`${jsonValue} LIKE ${operator.ilike}`);
-		else conditions.push(drizzle_orm.sql`${jsonValue} ILIKE ${operator.ilike}`);
-		if (operator.notLike !== void 0) conditions.push(drizzle_orm.sql`${jsonValue} NOT LIKE ${operator.notLike}`);
-		if (operator.notIlike !== void 0) if (dialect === "sqlite") conditions.push(drizzle_orm.sql`${jsonValue} NOT LIKE ${operator.notIlike}`);
-		else conditions.push(drizzle_orm.sql`${jsonValue} NOT ILIKE ${operator.notIlike}`);
-		if (operator.isNull !== void 0) conditions.push(drizzle_orm.sql`${jsonValue} IS NULL`);
-		if (operator.isNotNull !== void 0) conditions.push(drizzle_orm.sql`${jsonValue} IS NOT NULL`);
-		if (operator.inArray !== void 0 && Array.isArray(operator.inArray)) conditions.push(drizzle_orm.sql`${jsonValue} IN (${drizzle_orm.sql.join(operator.inArray.map((v) => drizzle_orm.sql`${v}`), drizzle_orm.sql`, `)})`);
-		if (operator.notInArray !== void 0 && Array.isArray(operator.notInArray)) conditions.push(drizzle_orm.sql`${jsonValue} NOT IN (${drizzle_orm.sql.join(operator.notInArray.map((v) => drizzle_orm.sql`${v}`), drizzle_orm.sql`, `)})`);
-		if (operator.arrayContains !== void 0) {
-			if (dialect === "postgresql") {
-				const jsonArray = JSON.stringify(Array.isArray(operator.arrayContains) ? operator.arrayContains : [operator.arrayContains]);
-				conditions.push(drizzle_orm.sql`${jsonValue} @> ${jsonArray}::jsonb`);
-			}
-		}
-		if (operator.arrayContained !== void 0) {
-			if (dialect === "postgresql") {
-				const jsonArray = JSON.stringify(Array.isArray(operator.arrayContained) ? operator.arrayContained : [operator.arrayContained]);
-				conditions.push(drizzle_orm.sql`${jsonValue} <@ ${jsonArray}::jsonb`);
-			}
-		}
-		if (operator.arrayOverlaps !== void 0) {
-			if (dialect === "postgresql") {
-				const overlapConditions = (Array.isArray(operator.arrayOverlaps) ? operator.arrayOverlaps : [operator.arrayOverlaps]).map((val) => {
-					return drizzle_orm.sql`${jsonValue} @> ${JSON.stringify(val)}::jsonb`;
-				});
-				if (overlapConditions.length > 0) conditions.push(drizzle_orm.sql`(${drizzle_orm.sql.join(overlapConditions, drizzle_orm.sql` OR `)})`);
-			}
-		}
-		if (conditions.length === 0) return;
-		if (conditions.length === 1) return conditions[0];
-		return drizzle_orm.sql.join(conditions, drizzle_orm.sql` AND `);
-	}
-	/**
-	* Parse a nested query object and extract the path and operator.
-	* For example: { profile: { contact: { email: { eq: "test@example.com" } } } }
-	* Returns: { path: ['profile', 'contact', 'email'], operator: { eq: "test@example.com" } }
-	*/
-	parseNestedQuery(nestedQuery, currentPath = []) {
-		const results = [];
-		for (const [key, value] of Object.entries(nestedQuery)) if (value && typeof value === "object" && !Array.isArray(value)) if (Object.keys(value).some((k) => [
-			"eq",
-			"ne",
-			"gt",
-			"gte",
-			"lt",
-			"lte",
-			"like",
-			"ilike",
-			"notLike",
-			"notIlike",
-			"isNull",
-			"isNotNull",
-			"inArray",
-			"notInArray",
-			"arrayContains",
-			"arrayContained",
-			"arrayOverlaps"
-		].includes(k))) results.push({
-			path: [...currentPath, key],
-			operator: value
-		});
-		else {
-			const nestedResults = this.parseNestedQuery(value, [...currentPath, key]);
-			results.push(...nestedResults);
-		}
-		return results;
-	}
-	/**
-	* Determine if a property is a JSONB column based on the schema.
-	* A column is JSONB if it's defined as an object or array in the TypeBox schema.
-	*/
-	isJsonbColumn(schema$1, columnName) {
-		const property = schema$1.properties[columnName];
-		if (!property) return false;
-		return property.type === "object" || property.type === "array";
-	}
-	/**
-	* Check if an array property contains primitive types (string, number, boolean, etc.)
-	* rather than objects. Primitive arrays should use native Drizzle operators.
-	* @returns true if the array contains primitives, false if it contains objects
-	*/
-	isPrimitiveArray(schema$1, columnName) {
-		const property = schema$1.properties[columnName];
-		if (!property || property.type !== "array") return false;
-		const items = property.items;
-		if (!items) return false;
-		const itemType = items.type;
-		return itemType === "string" || itemType === "number" || itemType === "integer" || itemType === "boolean" || itemType === "null";
-	}
-	/**
-	* Get the type of a field by navigating through a schema path.
-	* Used for smart type casting in SQL queries.
-	*
-	* @param columnSchema The schema of the JSON column (e.g., t.object({ age: t.integer() }))
-	* @param path The path to navigate (e.g., ['contact', 'email'])
-	* @returns The type string (e.g., 'integer', 'number', 'string') or undefined if not found
-	*/
-	getFieldType(columnSchema, path) {
-		let current = columnSchema;
-		for (const segment of path) if (current.type === "object" && current.properties) {
-			current = current.properties[segment];
-			if (!current) return;
-		} else return;
-		return current.type;
-	}
-	/**
-	* Check if a nested path points to an array property.
-	*/
-	isArrayProperty(schema$1, path) {
-		if (path.length === 0) return false;
-		let currentSchema = schema$1.properties[path[0]];
-		if (!currentSchema) return false;
-		if (currentSchema.type === "array") return true;
-		for (let i = 1; i < path.length; i++) if (currentSchema.type === "object" && currentSchema.properties) {
-			currentSchema = currentSchema.properties[path[i]];
-			if (!currentSchema) return false;
-			if (currentSchema.type === "array") return true;
-		} else return false;
-		return false;
-	}
-};
-
-//#endregion
-//#region src/orm/services/QueryManager.ts
-var QueryManager = class {
-	jsonQueryManager = (0, alepha.$inject)(PgJsonQueryManager);
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	/**
-	* Convert a query object to a SQL query.
-	*/
-	toSQL(query, options) {
-		const { schema: schema$1, col, joins } = options;
-		const conditions = [];
-		if ((0, drizzle_orm.isSQLWrapper)(query)) conditions.push(query);
-		else {
-			const keys = Object.keys(query);
-			for (const key of keys) {
-				const operator = query[key];
-				if (typeof query[key] === "object" && query[key] != null && !Array.isArray(query[key]) && joins?.length) {
-					const matchingJoins = joins.filter((j) => j.key === key);
-					if (matchingJoins.length > 0) {
-						const join = matchingJoins[0];
-						const joinPath = join.parent ? `${join.parent}.${key}` : key;
-						const recursiveJoins = joins.filter((j) => {
-							if (!j.parent) return false;
-							return j.parent === joinPath || j.parent.startsWith(`${joinPath}.`);
-						}).map((j) => {
-							const newParent = j.parent === joinPath ? void 0 : j.parent.substring(joinPath.length + 1);
-							return {
-								...j,
-								parent: newParent
-							};
-						});
-						const sql$8 = this.toSQL(query[key], {
-							schema: join.schema,
-							col: join.col,
-							joins: recursiveJoins.length > 0 ? recursiveJoins : void 0,
-							dialect: options.dialect
-						});
-						if (sql$8) conditions.push(sql$8);
-						continue;
-					}
-				}
-				if (Array.isArray(operator)) {
-					const operations = operator.map((it) => {
-						if ((0, drizzle_orm.isSQLWrapper)(it)) return it;
-						return this.toSQL(it, {
-							schema: schema$1,
-							col,
-							joins,
-							dialect: options.dialect
-						});
-					}).filter((it) => it != null);
-					if (key === "and") return (0, drizzle_orm.and)(...operations);
-					if (key === "or") return (0, drizzle_orm.or)(...operations);
-				}
-				if (key === "not") {
-					const where = this.toSQL(operator, {
-						schema: schema$1,
-						col,
-						joins,
-						dialect: options.dialect
-					});
-					if (where) return (0, drizzle_orm.not)(where);
-				}
-				if (operator) if (this.jsonQueryManager.isJsonbColumn(schema$1, key) && !this.jsonQueryManager.isPrimitiveArray(schema$1, key) && typeof operator === "object" && !Array.isArray(operator) && this.jsonQueryManager.hasNestedQuery({ [key]: operator })) {
-					const column = col(key);
-					const jsonbSql = this.buildJsonbQuery(column, operator, schema$1, key, options.dialect);
-					if (jsonbSql) conditions.push(jsonbSql);
-				} else {
-					const column = col(key);
-					const sql$8 = this.mapOperatorToSql(operator, column, schema$1, key, options.dialect);
-					if (sql$8) conditions.push(sql$8);
-				}
-			}
-		}
-		if (conditions.length === 1) return conditions[0];
-		return (0, drizzle_orm.and)(...conditions);
-	}
-	/**
-	* Build a JSONB query for nested object/array queries.
-	*/
-	buildJsonbQuery(column, nestedQuery, schema$1, columnName, dialect) {
-		const queries = this.jsonQueryManager.parseNestedQuery(nestedQuery);
-		if (queries.length === 0) return;
-		const columnSchema = schema$1.properties[columnName];
-		const conditions = [];
-		for (const { path, operator } of queries) {
-			const isArrayOperator = operator.arrayContains !== void 0 || operator.arrayContained !== void 0 || operator.arrayOverlaps !== void 0;
-			const isArrayProp = this.jsonQueryManager.isArrayProperty(schema$1, [columnName, ...path]);
-			if (isArrayProp && isArrayOperator) {
-				const condition = this.jsonQueryManager.buildJsonbCondition(column, path, operator, dialect, columnSchema);
-				if (condition) conditions.push(condition);
-			} else if (isArrayProp && !isArrayOperator) {
-				const condition = this.jsonQueryManager.buildJsonbArrayCondition(column, path, "", operator, dialect);
-				if (condition) conditions.push(condition);
-			} else {
-				const condition = this.jsonQueryManager.buildJsonbCondition(column, path, operator, dialect, columnSchema);
-				if (condition) conditions.push(condition);
-			}
-		}
-		if (conditions.length === 0) return;
-		if (conditions.length === 1) return conditions[0];
-		return (0, drizzle_orm.and)(...conditions);
-	}
-	/**
-	* Check if an object has any filter operator properties.
-	*/
-	hasFilterOperatorProperties(obj) {
-		if (!obj || typeof obj !== "object") return false;
-		return [
-			"eq",
-			"ne",
-			"gt",
-			"gte",
-			"lt",
-			"lte",
-			"inArray",
-			"notInArray",
-			"isNull",
-			"isNotNull",
-			"like",
-			"notLike",
-			"ilike",
-			"notIlike",
-			"contains",
-			"startsWith",
-			"endsWith",
-			"between",
-			"notBetween",
-			"arrayContains",
-			"arrayContained",
-			"arrayOverlaps"
-		].some((key) => key in obj);
-	}
-	/**
-	* Map a filter operator to a SQL query.
-	*/
-	mapOperatorToSql(operator, column, columnSchema, columnName, dialect = "postgresql") {
-		const encodeValue = (value) => {
-			if (value == null) return value;
-			if (columnSchema && columnName) try {
-				const fieldSchema = columnSchema.properties[columnName];
-				if (fieldSchema) return this.alepha.codec.encode(fieldSchema, value, { encoder: "drizzle" });
-			} catch (error) {}
-			return value;
-		};
-		const encodeArray = (values) => {
-			return values.map((v) => encodeValue(v));
-		};
-		if (typeof operator !== "object" || operator == null || !this.hasFilterOperatorProperties(operator)) return (0, drizzle_orm.eq)(column, encodeValue(operator));
-		const conditions = [];
-		if (operator?.eq != null) conditions.push((0, drizzle_orm.eq)(column, encodeValue(operator.eq)));
-		if (operator?.ne != null) conditions.push((0, drizzle_orm.ne)(column, encodeValue(operator.ne)));
-		if (operator?.gt != null) conditions.push((0, drizzle_orm.gt)(column, encodeValue(operator.gt)));
-		if (operator?.gte != null) conditions.push((0, drizzle_orm.gte)(column, encodeValue(operator.gte)));
-		if (operator?.lt != null) conditions.push((0, drizzle_orm.lt)(column, encodeValue(operator.lt)));
-		if (operator?.lte != null) conditions.push((0, drizzle_orm.lte)(column, encodeValue(operator.lte)));
-		if (operator?.inArray != null) {
-			if (!Array.isArray(operator.inArray) || operator.inArray.length === 0) throw new alepha.AlephaError("inArray operator requires at least one value");
-			conditions.push((0, drizzle_orm.inArray)(column, encodeArray(operator.inArray)));
-		}
-		if (operator?.notInArray != null) {
-			if (!Array.isArray(operator.notInArray) || operator.notInArray.length === 0) throw new alepha.AlephaError("notInArray operator requires at least one value");
-			conditions.push((0, drizzle_orm.notInArray)(column, encodeArray(operator.notInArray)));
-		}
-		if (operator?.isNull != null) conditions.push((0, drizzle_orm.isNull)(column));
-		if (operator?.isNotNull != null) conditions.push((0, drizzle_orm.isNotNull)(column));
-		if (operator?.like != null) conditions.push((0, drizzle_orm.like)(column, encodeValue(operator.like)));
-		if (operator?.notLike != null) conditions.push((0, drizzle_orm.notLike)(column, encodeValue(operator.notLike)));
-		if (operator?.ilike != null) conditions.push((0, drizzle_orm.ilike)(column, encodeValue(operator.ilike)));
-		if (operator?.notIlike != null) conditions.push((0, drizzle_orm.notIlike)(column, encodeValue(operator.notIlike)));
-		if (operator?.contains != null) {
-			const escapedValue = String(operator.contains).replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-			if (dialect === "sqlite") conditions.push(drizzle_orm.sql`LOWER(${column}) LIKE LOWER(${encodeValue(`%${escapedValue}%`)})`);
-			else conditions.push((0, drizzle_orm.ilike)(column, encodeValue(`%${escapedValue}%`)));
-		}
-		if (operator?.startsWith != null) {
-			const escapedValue = String(operator.startsWith).replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-			if (dialect === "sqlite") conditions.push(drizzle_orm.sql`LOWER(${column}) LIKE LOWER(${encodeValue(`${escapedValue}%`)})`);
-			else conditions.push((0, drizzle_orm.ilike)(column, encodeValue(`${escapedValue}%`)));
-		}
-		if (operator?.endsWith != null) {
-			const escapedValue = String(operator.endsWith).replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-			if (dialect === "sqlite") conditions.push(drizzle_orm.sql`LOWER(${column}) LIKE LOWER(${encodeValue(`%${escapedValue}`)})`);
-			else conditions.push((0, drizzle_orm.ilike)(column, encodeValue(`%${escapedValue}`)));
-		}
-		if (operator?.between != null) {
-			if (!Array.isArray(operator.between) || operator.between.length !== 2) throw new Error("between operator requires exactly 2 values [min, max]");
-			conditions.push((0, drizzle_orm.between)(column, encodeValue(operator.between[0]), encodeValue(operator.between[1])));
-		}
-		if (operator?.notBetween != null) {
-			if (!Array.isArray(operator.notBetween) || operator.notBetween.length !== 2) throw new Error("notBetween operator requires exactly 2 values [min, max]");
-			conditions.push((0, drizzle_orm.notBetween)(column, encodeValue(operator.notBetween[0]), encodeValue(operator.notBetween[1])));
-		}
-		if (operator?.arrayContains != null) conditions.push((0, drizzle_orm.arrayContains)(column, encodeValue(operator.arrayContains)));
-		if (operator?.arrayContained != null) conditions.push((0, drizzle_orm.arrayContained)(column, encodeValue(operator.arrayContained)));
-		if (operator?.arrayOverlaps != null) conditions.push((0, drizzle_orm.arrayOverlaps)(column, encodeValue(operator.arrayOverlaps)));
-		if (conditions.length === 0) return;
-		if (conditions.length === 1) return conditions[0];
-		return (0, drizzle_orm.and)(...conditions);
-	}
-	/**
-	* Parse pagination sort string to orderBy format.
-	* Format: "firstName,-lastName" -> [{ column: "firstName", direction: "asc" }, { column: "lastName", direction: "desc" }]
-	* - Columns separated by comma
-	* - Prefix with '-' for DESC direction
-	*
-	* @param sort Pagination sort string
-	* @returns OrderBy array or single object
-	*/
-	parsePaginationSort(sort) {
-		const orderByClauses = sort.split(",").map((field) => field.trim()).map((field) => {
-			if (field.startsWith("-")) return {
-				column: field.substring(1),
-				direction: "desc"
-			};
-			return {
-				column: field,
-				direction: "asc"
-			};
-		});
-		return orderByClauses.length === 1 ? orderByClauses[0] : orderByClauses;
-	}
-	/**
-	* Normalize orderBy parameter to array format.
-	* Supports 3 modes:
-	* 1. String: "name" -> [{ column: "name", direction: "asc" }]
-	* 2. Object: { column: "name", direction: "desc" } -> [{ column: "name", direction: "desc" }]
-	* 3. Array: [{ column: "name" }, { column: "age", direction: "desc" }] -> normalized array
-	*
-	* @param orderBy The orderBy parameter
-	* @returns Normalized array of order by clauses
-	*/
-	normalizeOrderBy(orderBy) {
-		if (typeof orderBy === "string") return [{
-			column: orderBy,
-			direction: "asc"
-		}];
-		if (!Array.isArray(orderBy) && typeof orderBy === "object") return [{
-			column: orderBy.column,
-			direction: orderBy.direction ?? "asc"
-		}];
-		if (Array.isArray(orderBy)) return orderBy.map((item) => ({
-			column: item.column,
-			direction: item.direction ?? "asc"
-		}));
-		return [];
-	}
-	/**
-	* Create a pagination object.
-	*
-	* @deprecated Use `createPagination` from alepha instead.
-	* This method now delegates to the framework-level helper.
-	*
-	* @param entities The entities to paginate.
-	* @param limit The limit of the pagination.
-	* @param offset The offset of the pagination.
-	* @param sort Optional sort metadata to include in response.
-	*/
-	createPagination(entities, limit = 10, offset = 0, sort) {
-		return (0, alepha.createPagination)(entities, limit, offset, sort);
-	}
-};
-
-//#endregion
-//#region src/orm/services/Repository.ts
-var Repository = class {
-	entity;
-	provider;
-	relationManager = (0, alepha.$inject)(PgRelationManager);
-	queryManager = (0, alepha.$inject)(QueryManager);
-	dateTimeProvider = (0, alepha.$inject)(alepha_datetime.DateTimeProvider);
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	constructor(entity, provider = DatabaseProvider) {
-		this.entity = entity;
-		this.provider = this.alepha.inject(provider);
-		this.provider.registerEntity(entity);
-	}
-	/**
-	* Represents the primary key of the table.
-	* - Key is the name of the primary key column.
-	* - Type is the type (TypeBox) of the primary key column.
-	*
-	* ID is mandatory. If the table does not have a primary key, it will throw an error.
-	*/
-	get id() {
-		return this.getPrimaryKey(this.entity.schema);
-	}
-	/**
-	* Get Drizzle table object.
-	*/
-	get table() {
-		return this.provider.table(this.entity);
-	}
-	/**
-	* Get SQL table name. (from Drizzle table object)
-	*/
-	get tableName() {
-		return this.entity.name;
-	}
-	/**
-	* Getter for the database connection from the database provider.
-	*/
-	get db() {
-		return this.provider.db;
-	}
-	/**
-	* Execute a SQL query.
-	*
-	* This method allows executing raw SQL queries against the database.
-	* This is by far the easiest way to run custom queries that are not covered by the repository's built-in methods!
-	*
-	* You must use the `sql` tagged template function from Drizzle ORM to create the query. https://orm.drizzle.team/docs/sql
-	*
-	* @example
-	* ```ts
-	* class App {
-	*   repository = $repository({ ... });
-	*   async getAdults() {
-	*     const users = repository.table; // Drizzle table object
-	*     await repository.query(sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
-	*     // or better
-	*     await repository.query((users) => sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
-	*   }
-	* }
-	* ```
-	*/
-	async query(query, schema$1) {
-		const raw = typeof query === "function" ? query(this.table, this.db) : query;
-		if (typeof raw === "string" && raw.includes("[object Object]")) throw new alepha.AlephaError("Invalid SQL query. Did you forget to call the 'sql' function?");
-		return (await this.provider.execute(raw)).map((it) => {
-			return this.clean(this.mapRawFieldsToEntity(it), schema$1 ?? this.entity.schema);
-		});
-	}
-	/**
-	* Map raw database fields to entity fields. (handles column name differences)
-	*/
-	mapRawFieldsToEntity(row) {
-		const entity = {};
-		for (const key of Object.keys(row)) {
-			entity[key] = row[key];
-			for (const colKey of Object.keys(this.table)) if (this.table[colKey].name === key) {
-				entity[colKey] = row[key];
-				break;
-			}
-		}
-		return entity;
-	}
-	/**
-	* Get a Drizzle column from the table by his name.
-	*/
-	col(name) {
-		const column = this.table[name];
-		if (!column) throw new alepha.AlephaError(`Invalid access. Column ${String(name)} not found in table ${this.tableName}`);
-		return column;
-	}
-	/**
-	* Run a transaction.
-	*/
-	async transaction(transaction, config) {
-		return await this.db.transaction(transaction, config);
-	}
-	/**
-	* Start a SELECT query on the table.
-	*/
-	rawSelect(opts = {}) {
-		return (opts.tx ?? this.db).select().from(this.table);
-	}
-	/**
-	* Start a SELECT DISTINCT query on the table.
-	*/
-	rawSelectDistinct(opts = {}, columns = []) {
-		const db = opts.tx ?? this.db;
-		const table = this.table;
-		const fields = {};
-		for (const column of columns) if (typeof column === "string") fields[column] = this.col(column);
-		return db.selectDistinct(fields).from(table);
-	}
-	/**
-	* Start an INSERT query on the table.
-	*/
-	rawInsert(opts = {}) {
-		return (opts.tx ?? this.db).insert(this.table);
-	}
-	/**
-	* Start an UPDATE query on the table.
-	*/
-	rawUpdate(opts = {}) {
-		return (opts.tx ?? this.db).update(this.table);
-	}
-	/**
-	* Start a DELETE query on the table.
-	*/
-	rawDelete(opts = {}) {
-		return (opts.tx ?? this.db).delete(this.table);
-	}
-	/**
-	* Create a Drizzle `select` query based on a JSON query object.
-	*
-	* > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
-	*/
-	async findMany(query = {}, opts = {}) {
-		await this.alepha.events.emit("repository:read:before", {
-			tableName: this.tableName,
-			query
-		});
-		const columns = query.columns ?? query.distinct;
-		const builder = query.distinct ? this.rawSelectDistinct(opts, query.distinct) : this.rawSelect(opts);
-		const joins = [];
-		if (query.with) this.relationManager.buildJoins(this.provider, builder, joins, query.with, this.table);
-		const where = this.withDeletedAt(query.where ?? {}, opts);
-		builder.where(() => this.toSQL(where, joins));
-		if (query.offset) {
-			builder.offset(query.offset);
-			if (this.provider.dialect === "sqlite" && !query.limit) query.limit = 1e3;
-		}
-		if (query.limit) builder.limit(query.limit);
-		if (query.orderBy) {
-			const orderByClauses = this.queryManager.normalizeOrderBy(query.orderBy);
-			builder.orderBy(...orderByClauses.map((clause) => clause.direction === "desc" ? (0, drizzle_orm.desc)(this.col(clause.column)) : (0, drizzle_orm.asc)(this.col(clause.column))));
-		}
-		if (query.groupBy) builder.groupBy(...query.groupBy.map((key) => this.col(key)));
-		if (opts.for) {
-			if (typeof opts.for === "string") builder.for(opts.for);
-			else if (opts.for) builder.for(opts.for.strength, opts.for.config);
-		}
-		try {
-			let rows = await builder.execute();
-			let schema$1 = this.entity.schema;
-			if (columns) schema$1 = alepha.t.pick(schema$1, columns);
-			if (joins.length) rows = rows.map((row) => {
-				const rowSchema = {
-					...schema$1,
-					properties: { ...schema$1.properties }
-				};
-				return this.relationManager.mapRowWithJoins(row[this.tableName], row, rowSchema, joins);
-			});
-			rows = rows.map((row) => {
-				if (joins.length) {
-					const joinedSchema = this.relationManager.buildSchemaWithJoins(schema$1, joins);
-					return this.cleanWithJoins(row, joinedSchema, joins);
-				}
-				return this.clean(row, schema$1);
-			});
-			await this.alepha.events.emit("repository:read:after", {
-				tableName: this.tableName,
-				query,
-				entities: rows
-			});
-			return rows;
-		} catch (error) {
-			throw new DbError("Query select has failed", error);
-		}
-	}
-	/**
-	* Find a single entity.
-	*/
-	async findOne(query, opts = {}) {
-		const [entity] = await this.findMany({
-			limit: 1,
-			...query
-		}, opts);
-		if (!entity) throw new DbEntityNotFoundError(this.tableName);
-		return entity;
-	}
-	/**
-	* Find entities with pagination.
-	*
-	* It uses the same parameters as `find()`, but adds pagination metadata to the response.
-	*
-	* > Pagination CAN also do a count query to get the total number of elements.
-	*/
-	async paginate(pagination = {}, query = {}, opts = {}) {
-		const limit = query.limit ?? pagination.size ?? 10;
-		const page = pagination.page ?? 0;
-		const offset = query.offset ?? page * limit;
-		let orderBy = query.orderBy;
-		if (!query.orderBy && pagination.sort) orderBy = this.queryManager.parsePaginationSort(pagination.sort);
-		const now = Date.now();
-		const timers = {
-			query: now,
-			count: now
-		};
-		const tasks = [];
-		tasks.push(this.findMany({
-			offset,
-			limit: limit + 1,
-			orderBy,
-			...query
-		}, opts).then((it) => {
-			timers.query = Date.now() - timers.query;
-			return it;
-		}));
-		if (opts.count) {
-			const where = (0, drizzle_orm.isSQLWrapper)(query.where) ? query.where : query.where ? this.toSQL(query.where) : void 0;
-			tasks.push(this.db.$count(this.table, where).then((it) => {
-				timers.count = Date.now() - timers.count;
-				return it;
-			}));
-		}
-		const [entities, countResult] = await Promise.all(tasks);
-		let sortMetadata;
-		if (orderBy) sortMetadata = this.queryManager.normalizeOrderBy(orderBy);
-		const response = this.queryManager.createPagination(entities, limit, offset, sortMetadata);
-		response.page.totalElements = countResult;
-		if (countResult != null) response.page.totalPages = Math.ceil(countResult / limit);
-		return response;
-	}
-	/**
-	* Find an entity by ID.
-	*
-	* This is a convenience method for `findOne` with a where clause on the primary key.
-	* If you need more complex queries, use `findOne` instead.
-	*/
-	async findById(id, opts = {}) {
-		return await this.findOne({ where: this.getWhereId(id) }, opts);
-	}
-	/**
-	* Helper to create a type-safe query object.
-	*/
-	createQuery() {
-		return {};
-	}
-	/**
-	* Helper to create a type-safe where clause.
-	*/
-	createQueryWhere() {
-		return {};
-	}
-	/**
-	* Create an entity.
-	*
-	* @param data The entity to create.
-	* @param opts The options for creating the entity.
-	* @returns The ID of the created entity.
-	*/
-	async create(data, opts = {}) {
-		await this.alepha.events.emit("repository:create:before", {
-			tableName: this.tableName,
-			data
-		});
-		try {
-			const entity = await this.rawInsert(opts).values(this.cast(data ?? {}, true)).returning(this.table).then(([it]) => this.clean(it, this.entity.schema));
-			await this.alepha.events.emit("repository:create:after", {
-				tableName: this.tableName,
-				data,
-				entity
-			});
-			return entity;
-		} catch (error) {
-			throw this.handleError(error, "Insert query has failed");
-		}
-	}
-	/**
-	* Create many entities.
-	*
-	* @param values The entities to create.
-	* @param opts The statement options.
-	* @returns The created entities.
-	*/
-	async createMany(values, opts = {}) {
-		if (values.length === 0) return [];
-		await this.alepha.events.emit("repository:create:before", {
-			tableName: this.tableName,
-			data: values
-		});
-		try {
-			const entities = await this.rawInsert(opts).values(values.map((data) => this.cast(data, true))).returning(this.table).then((rows) => rows.map((it) => this.clean(it, this.entity.schema)));
-			await this.alepha.events.emit("repository:create:after", {
-				tableName: this.tableName,
-				data: values,
-				entity: entities
-			});
-			return entities;
-		} catch (error) {
-			throw this.handleError(error, "Insert query has failed");
-		}
-	}
-	/**
-	* Find an entity and update it.
-	*/
-	async updateOne(where, data, opts = {}) {
-		await this.alepha.events.emit("repository:update:before", {
-			tableName: this.tableName,
-			where,
-			data
-		});
-		let row = data;
-		const updatedAtField = getAttrFields(this.entity.schema, PG_UPDATED_AT)?.[0];
-		if (updatedAtField) row[updatedAtField.key] = this.dateTimeProvider.of(opts.now).toISOString();
-		where = this.withDeletedAt(where, opts);
-		row = this.cast(row, false);
-		delete row[this.id.key];
-		const response = await this.rawUpdate(opts).set(row).where(this.toSQL(where)).returning(this.table).catch((error) => {
-			throw this.handleError(error, "Update query has failed");
-		});
-		if (!response[0]) throw new DbEntityNotFoundError(this.tableName);
-		try {
-			const entity = this.clean(response[0], this.entity.schema);
-			await this.alepha.events.emit("repository:update:after", {
-				tableName: this.tableName,
-				where,
-				data,
-				entities: [entity]
-			});
-			return entity;
-		} catch (error) {
-			throw this.handleError(error, "Update query has failed");
-		}
-	}
-	/**
-	* Save a given entity.
-	*
-	* @example
-	* ```ts
-	* const entity = await repository.findById(1);
-	* entity.name = "New Name"; // update a field
-	* delete entity.description; // delete a field
-	* await repository.save(entity);
-	* ```
-	*
-	* Difference with `updateById/updateOne`:
-	*
-	* - requires the entity to be fetched first (whole object is expected)
-	* - check pg.version() if present -> optimistic locking
-	* - validate entity against schema
-	* - undefined values will be set to null, not ignored!
-	*
-	* @see {@link DbVersionMismatchError}
-	*/
-	async save(entity, opts = {}) {
-		const row = entity;
-		const id = row[this.id.key];
-		if (id == null) throw new alepha.AlephaError("Cannot save entity without ID - missing primary key in value");
-		for (const key of Object.keys(this.entity.schema.properties)) if (row[key] === void 0) row[key] = null;
-		let where = this.createQueryWhere();
-		where.id = { eq: id };
-		const versionField = getAttrFields(this.entity.schema, PG_VERSION)?.[0];
-		if (versionField && typeof row[versionField.key] === "number") {
-			where = { and: [where, { [versionField.key]: { eq: row[versionField.key] } }] };
-			row[versionField.key] += 1;
-		}
-		try {
-			const newValue = await this.updateOne(where, row, opts);
-			for (const key of Object.keys(this.entity.schema.properties)) row[key] = void 0;
-			Object.assign(row, newValue);
-		} catch (error) {
-			if (error instanceof DbEntityNotFoundError && versionField) try {
-				await this.findById(id);
-				throw new DbVersionMismatchError(this.tableName, id);
-			} catch (lookupError) {
-				if (lookupError instanceof DbEntityNotFoundError) throw error;
-				if (lookupError instanceof DbVersionMismatchError) throw lookupError;
-				throw lookupError;
-			}
-			throw error;
-		}
-	}
-	/**
-	* Find an entity by ID and update it.
-	*/
-	async updateById(id, data, opts = {}) {
-		return await this.updateOne(this.getWhereId(id), data, opts);
-	}
-	/**
-	* Find many entities and update all of them.
-	*/
-	async updateMany(where, data, opts = {}) {
-		await this.alepha.events.emit("repository:update:before", {
-			tableName: this.tableName,
-			where,
-			data
-		});
-		const updatedAtField = getAttrFields(this.entity.schema, PG_UPDATED_AT)?.[0];
-		if (updatedAtField) data[updatedAtField.key] = this.dateTimeProvider.of(opts.now).toISOString();
-		where = this.withDeletedAt(where, opts);
-		data = this.cast(data, false);
-		try {
-			const entities = await this.rawUpdate(opts).set(data).where(this.toSQL(where)).returning();
-			await this.alepha.events.emit("repository:update:after", {
-				tableName: this.tableName,
-				where,
-				data,
-				entities
-			});
-			return entities.map((it) => it[this.id.key]);
-		} catch (error) {
-			throw this.handleError(error, "Update query has failed");
-		}
-	}
-	/**
-	* Find many and delete all of them.
-	* @returns Array of deleted entity IDs
-	*/
-	async deleteMany(where = {}, opts = {}) {
-		const deletedAt = this.deletedAt();
-		if (deletedAt && !opts.force) return await this.updateMany(where, { [deletedAt.key]: opts.now ?? this.dateTimeProvider.nowISOString() }, opts);
-		await this.alepha.events.emit("repository:delete:before", {
-			tableName: this.tableName,
-			where
-		});
-		try {
-			const ids = (await this.rawDelete(opts).where(this.toSQL(where)).returning({ id: this.table[this.id.key] })).map((row) => row.id);
-			await this.alepha.events.emit("repository:delete:after", {
-				tableName: this.tableName,
-				where,
-				ids
-			});
-			return ids;
-		} catch (error) {
-			throw new DbError("Delete query has failed", error);
-		}
-	}
-	/**
-	* Delete all entities.
-	* @returns Array of deleted entity IDs
-	*/
-	clear(opts = {}) {
-		return this.deleteMany({}, opts);
-	}
-	/**
-	* Delete the given entity.
-	*
-	* You must fetch the entity first in order to delete it.
-	* @returns Array containing the deleted entity ID
-	*/
-	async destroy(entity, opts = {}) {
-		const id = entity[this.id.key];
-		if (id == null) throw new alepha.AlephaError("Cannot destroy entity without ID");
-		const deletedAt = this.deletedAt();
-		if (deletedAt && !opts.force) {
-			opts.now ??= this.dateTimeProvider.nowISOString();
-			entity[deletedAt.key] = opts.now;
-		}
-		return await this.deleteById(id, opts);
-	}
-	/**
-	* Find an entity and delete it.
-	* @returns Array of deleted entity IDs (should contain at most one ID)
-	*/
-	async deleteOne(where = {}, opts = {}) {
-		return await this.deleteMany(where, opts);
-	}
-	/**
-	* Find an entity by ID and delete it.
-	* @returns Array containing the deleted entity ID
-	* @throws DbEntityNotFoundError if the entity is not found
-	*/
-	async deleteById(id, opts = {}) {
-		const result = await this.deleteMany(this.getWhereId(id), opts);
-		if (result.length === 0) throw new DbEntityNotFoundError(`Entity with ID ${id} not found in ${this.tableName}`);
-		return result;
-	}
-	/**
-	* Count entities.
-	*/
-	async count(where = {}, opts = {}) {
-		where = this.withDeletedAt(where, opts);
-		return (opts.tx ?? this.db).$count(this.table, this.toSQL(where));
-	}
-	conflictMessagePattern = "duplicate key value violates unique constraint";
-	handleError(error, message) {
-		if (!(error instanceof Error)) return new DbError(message);
-		if (error.cause?.message.includes(this.conflictMessagePattern) || error.message.includes(this.conflictMessagePattern)) return new DbConflictError(message, error);
-		return new DbError(message, error);
-	}
-	withDeletedAt(where, opts = {}) {
-		if (opts.force) return where;
-		const deletedAt = this.deletedAt();
-		if (!deletedAt) return where;
-		return { and: [where, { [deletedAt.key]: { isNull: true } }] };
-	}
-	deletedAt() {
-		const deletedAtFields = getAttrFields(this.entity.schema, PG_DELETED_AT);
-		if (deletedAtFields.length > 0) return deletedAtFields[0];
-	}
-	/**
-	* Convert something to valid Pg Insert Value.
-	*/
-	cast(data, insert) {
-		const schema$1 = insert ? this.entity.insertSchema : alepha.t.partial(this.entity.updateSchema);
-		return this.alepha.codec.encode(schema$1, data);
-	}
-	/**
-	* Transform a row from the database into a clean entity.
-	*/
-	clean(row, schema$1) {
-		for (const key of Object.keys(schema$1.properties)) {
-			const value = schema$1.properties[key];
-			if (typeof row[key] === "string") {
-				if (alepha.t.schema.isDateTime(value)) row[key] = this.dateTimeProvider.of(row[key]).toISOString();
-				else if (alepha.t.schema.isDate(value)) row[key] = this.dateTimeProvider.of(`${row[key]}T00:00:00Z`).toISOString().split("T")[0];
-			}
-			if (typeof row[key] === "bigint" && alepha.t.schema.isBigInt(value)) row[key] = row[key].toString();
-		}
-		return this.alepha.codec.decode(schema$1, row);
-	}
-	/**
-	* Clean a row with joins recursively
-	*/
-	cleanWithJoins(row, schema$1, joins, parentPath) {
-		const joinsAtThisLevel = joins.filter((j) => j.parent === parentPath);
-		const cleanRow = { ...row };
-		const joinedData = {};
-		for (const join of joinsAtThisLevel) {
-			joinedData[join.key] = cleanRow[join.key];
-			delete cleanRow[join.key];
-		}
-		const entity = this.clean(cleanRow, schema$1);
-		for (const join of joinsAtThisLevel) {
-			const joinedValue = joinedData[join.key];
-			if (joinedValue != null) {
-				const joinPath = parentPath ? `${parentPath}.${join.key}` : join.key;
-				if (joins.filter((j) => j.parent === joinPath).length > 0) entity[join.key] = this.cleanWithJoins(joinedValue, join.schema, joins, joinPath);
-				else entity[join.key] = this.clean(joinedValue, join.schema);
-			} else entity[join.key] = void 0;
-		}
-		return entity;
-	}
-	/**
-	* Convert a where clause to SQL.
-	*/
-	toSQL(where, joins) {
-		return this.queryManager.toSQL(where, {
-			schema: this.entity.schema,
-			col: (name) => {
-				return this.col(name);
-			},
-			joins,
-			dialect: this.provider.dialect
-		});
-	}
-	/**
-	* Get the where clause for an ID.
-	*
-	* @param id The ID to get the where clause for.
-	* @returns The where clause for the ID.
-	*/
-	getWhereId(id) {
-		return { [this.id.key]: { eq: alepha.t.schema.isString(this.id.type) ? String(id) : Number(id) } };
-	}
-	/**
-	* Find a primary key in the schema.
-	*/
-	getPrimaryKey(schema$1) {
-		const primaryKeys = getAttrFields(schema$1, PG_PRIMARY_KEY);
-		if (primaryKeys.length === 0) throw new alepha.AlephaError("Primary key not found in schema");
-		if (primaryKeys.length > 1) throw new alepha.AlephaError(`Multiple primary keys (${primaryKeys.length}) are not supported`);
-		return {
-			key: primaryKeys[0].key,
-			col: this.col(primaryKeys[0].key),
-			type: primaryKeys[0].type
-		};
-	}
-};
-
-//#endregion
-//#region src/orm/providers/RepositoryProvider.ts
-var RepositoryProvider = class {
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	registry = /* @__PURE__ */ new Map();
-	getRepositories(provider) {
-		const repositories = this.alepha.services(Repository);
-		if (provider) return repositories.filter((it) => it.provider === provider);
-		return repositories;
-	}
-	getRepository(entity) {
-		const RepositoryClass = this.createClassRepository(entity);
-		return this.alepha.inject(RepositoryClass);
-	}
-	createClassRepository(entity) {
-		let name = entity.name.charAt(0).toUpperCase() + entity.name.slice(1);
-		if (name.endsWith("s")) name = name.slice(0, -1);
-		name = `${name}Repository`;
-		if (this.registry.has(entity)) return this.registry.get(entity);
-		class GenericRepository extends Repository {
-			constructor() {
-				super(entity);
-			}
-		}
-		Object.defineProperty(GenericRepository, "name", { value: name });
-		this.registry.set(entity, GenericRepository);
-		return GenericRepository;
-	}
-};
-
-//#endregion
-//#region src/orm/descriptors/$repository.ts
-/**
-* Get the repository for the given entity.
-*/
-const $repository = (entity) => {
-	const { alepha: alepha$1 } = (0, alepha.$context)();
-	return (0, alepha.$inject)(alepha$1.inject(RepositoryProvider).createClassRepository(entity));
-};
-
-//#endregion
-//#region src/orm/descriptors/$sequence.ts
-/**
-* Creates a PostgreSQL sequence descriptor for generating unique numeric values.
-*/
-const $sequence = (options = {}) => {
-	return (0, alepha.createDescriptor)(SequenceDescriptor, options);
-};
-var SequenceDescriptor = class extends alepha.Descriptor {
-	provider = this.$provider();
-	onInit() {
-		this.provider.registerSequence(this);
-	}
-	get name() {
-		return this.options.name ?? this.config.propertyKey;
-	}
-	async next() {
-		return this.provider.execute(drizzle_orm.sql`SELECT nextval('${drizzle_orm.sql.raw(this.provider.schema)}."${drizzle_orm.sql.raw(this.name)}"')`).then((rows) => Number(rows[0]?.nextval));
-	}
-	async current() {
-		return this.provider.execute(drizzle_orm.sql`SELECT last_value FROM ${drizzle_orm.sql.raw(this.provider.schema)}."${drizzle_orm.sql.raw(this.name)}"`).then((rows) => Number(rows[0]?.last_value));
-	}
-	$provider() {
-		return this.options.provider ?? this.alepha.inject(DatabaseProvider);
-	}
-};
-$sequence[alepha.KIND] = SequenceDescriptor;
-
-//#endregion
-//#region src/orm/providers/DrizzleKitProvider.ts
-var DrizzleKitProvider = class {
-	log = (0, alepha_logger.$logger)();
-	alepha = (0, alepha.$inject)(alepha.Alepha);
-	/**
-	* Synchronize database with current schema definitions.
-	*
-	* In development mode, it will generate and execute migrations based on the current state.
-	* In testing mode, it will generate migrations from scratch without applying them.
-	*
-	* Does nothing in production mode, you must handle migrations manually.
-	*/
-	async synchronize(provider) {
-		if (this.alepha.isProduction()) {
-			this.log.warn("Synchronization skipped in production mode.");
-			return;
-		}
-		if (provider.schema !== "public") await this.createSchemaIfNotExists(provider, provider.schema);
-		const now = Date.now();
-		if (this.alepha.isTest()) {
-			const { statements } = await this.generateMigration(provider);
-			await this.executeStatements(statements, provider);
-		} else {
-			const entry = await this.loadDevMigrations(provider);
-			const { statements, snapshot } = await this.generateMigration(provider, entry?.snapshot ? JSON.parse(entry.snapshot) : void 0);
-			await this.executeStatements(statements, provider, true);
-			await this.saveDevMigrations(provider, snapshot, entry);
-		}
-		this.log.info(`Db '${provider.name}' synchronization OK [${Date.now() - now}ms]`);
-	}
-	/**
-	* Mostly used for testing purposes. You can generate SQL migration statements without executing them.
-	*/
-	async generateMigration(provider, prevSnapshot) {
-		const kit = this.importDrizzleKit();
-		const models = this.getModels(provider);
-		if (Object.keys(models).length > 0) {
-			if (provider.dialect === "sqlite") {
-				const prev$1 = prevSnapshot ?? await kit.generateSQLiteDrizzleJson({});
-				const curr$1 = await kit.generateSQLiteDrizzleJson(models);
-				return {
-					models,
-					statements: await kit.generateSQLiteMigration(prev$1, curr$1),
-					snapshot: curr$1
-				};
-			}
-			const prev = prevSnapshot ?? await kit.generateDrizzleJson({});
-			const curr = await kit.generateDrizzleJson(models);
-			return {
-				models,
-				statements: await kit.generateMigration(prev, curr),
-				snapshot: curr
-			};
-		}
-		return {
-			models,
-			statements: [],
-			snapshot: {}
-		};
-	}
-	/**
-	* Load all tables, enums, sequences, etc. from the provider's repositories.
-	*/
-	getModels(provider) {
-		const models = {};
-		for (const [key, value] of provider.tables.entries()) {
-			if (models[key]) throw new alepha.AlephaError(`Model name conflict: '${key}' is already defined.`);
-			models[key] = value;
-		}
-		for (const [key, value] of provider.enums.entries()) {
-			if (models[key]) throw new alepha.AlephaError(`Model name conflict: '${key}' is already defined.`);
-			models[key] = value;
-		}
-		for (const [key, value] of provider.sequences.entries()) {
-			if (models[key]) throw new alepha.AlephaError(`Model name conflict: '${key}' is already defined.`);
-			models[key] = value;
-		}
-		return models;
-	}
-	/**
-	* Load the migration snapshot from the database.
-	*/
-	async loadDevMigrations(provider) {
-		const name = `${this.alepha.env.APP_NAME ?? "APP"}-${provider.constructor.name}`.toLowerCase();
-		if (provider.url.includes(":memory:")) {
-			this.log.trace(`In-memory database detected for '${name}', skipping migration snapshot load.`);
-			return;
-		}
-		if (provider.dialect === "sqlite") {
-			try {
-				const text = await (0, node_fs_promises.readFile)(`node_modules/.alepha/sqlite-${name}.json`, "utf-8");
-				return this.alepha.codec.decode(devMigrationsSchema, text);
-			} catch (e) {
-				this.log.trace(`No existing migration snapshot for '${name}'`, e);
-			}
-			return;
-		}
-		await provider.execute(drizzle_orm.sql`CREATE SCHEMA IF NOT EXISTS "drizzle";`);
-		await provider.execute(drizzle_orm.sql`
-					CREATE TABLE IF NOT EXISTS "drizzle"."__drizzle_dev_migrations" (
-						"id" SERIAL PRIMARY KEY,
-						"name" TEXT NOT NULL,
-						"created_at" TIMESTAMPTZ NOT NULL DEFAULT NOW(),
-						"snapshot" TEXT NOT NULL
-					);
-				`);
-		const rows = await provider.run(drizzle_orm.sql`SELECT * FROM "drizzle"."__drizzle_dev_migrations" WHERE "name" = ${name} LIMIT 1`, devMigrationsSchema);
-		if (rows.length === 0) {
-			this.log.trace(`No existing migration snapshot for '${name}'`);
-			return;
-		}
-		return this.alepha.codec.decode(devMigrationsSchema, rows[0]);
-	}
-	async saveDevMigrations(provider, curr, devMigrations) {
-		if (provider.url.includes(":memory:")) {
-			this.log.trace(`In-memory database detected for '${provider.constructor.name}', skipping migration snapshot save.`);
-			return;
-		}
-		const name = `${this.alepha.env.APP_NAME ?? "APP"}-${provider.constructor.name}`.toLowerCase();
-		if (provider.dialect === "sqlite") {
-			const filePath = `node_modules/.alepha/sqlite-${name}.json`;
-			await (0, node_fs_promises.mkdir)("node_modules/.alepha", { recursive: true }).catch(() => null);
-			await (0, node_fs_promises.writeFile)(filePath, JSON.stringify({
-				id: devMigrations?.id ?? 1,
-				name,
-				created_at: /* @__PURE__ */ new Date(),
-				snapshot: JSON.stringify(curr)
-			}, null, 2));
-			this.log.debug(`Saved migration snapshot to '${filePath}'`);
-			return;
-		}
-		if (!devMigrations) await provider.execute(drizzle_orm.sql`INSERT INTO "drizzle"."__drizzle_dev_migrations" ("name", "snapshot") VALUES (${name}, ${JSON.stringify(curr)})`);
-		else {
-			const newSnapshot = JSON.stringify(curr);
-			if (devMigrations.snapshot !== newSnapshot) await provider.execute(drizzle_orm.sql`UPDATE "drizzle"."__drizzle_dev_migrations" SET "snapshot" = ${newSnapshot} WHERE "id" = ${devMigrations.id}`);
-		}
-	}
-	async executeStatements(statements, provider, catchErrors = false) {
-		let nErrors = 0;
-		for (const statement of statements) {
-			if (statement.startsWith("DROP SCHEMA")) continue;
-			try {
-				await provider.execute(drizzle_orm.sql.raw(statement));
-			} catch (error) {
-				const errorMessage = `Error executing statement: ${statement}`;
-				if (catchErrors) {
-					nErrors++;
-					this.log.warn(errorMessage, { context: [error] });
-				} else throw error;
-			}
-		}
-		if (nErrors > 0) this.log.warn(`Executed ${statements.length} statements with ${nErrors} errors.`);
-	}
-	async createSchemaIfNotExists(provider, schemaName) {
-		if (!/^[a-z0-9_]+$/i.test(schemaName)) throw new Error(`Invalid schema name: ${schemaName}. Must only contain alphanumeric characters and underscores.`);
-		const sqlSchema = drizzle_orm.sql.raw(schemaName);
-		if (schemaName.startsWith("test_")) {
-			this.log.info(`Drop test schema '${schemaName}' ...`, schemaName);
-			await provider.execute(drizzle_orm.sql`DROP SCHEMA IF EXISTS ${sqlSchema} CASCADE`);
-		}
-		this.log.debug(`Ensuring schema '${schemaName}' exists`);
-		await provider.execute(drizzle_orm.sql`CREATE SCHEMA IF NOT EXISTS ${sqlSchema}`);
-	}
-	/**
-	* Try to load the official Drizzle Kit API.
-	* If not available, fallback to the local kit import.
-	*/
-	importDrizzleKit() {
-		try {
-			return (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("drizzle-kit/api");
-		} catch (_) {
-			throw new Error("Drizzle Kit is not installed. Please install it with `npm install -D drizzle-kit`.");
-		}
-	}
-};
-const devMigrationsSchema = alepha.t.object({
-	id: alepha.t.number(),
-	name: alepha.t.text(),
-	snapshot: alepha.t.string(),
-	created_at: alepha.t.string()
-});
-
-//#endregion
-//#region src/orm/errors/DbMigrationError.ts
-var DbMigrationError = class extends DbError {
-	name = "DbMigrationError";
-	constructor(cause) {
-		super("Failed to migrate database", cause);
-	}
-};
-
-//#endregion
-//#region src/orm/types/byte.ts
-/**
-* Postgres bytea type.
-*/
-const byte = (0, drizzle_orm_pg_core.customType)({ dataType: () => "bytea" });
-
-//#endregion
-//#region src/orm/services/ModelBuilder.ts
-/**
-* Abstract base class for transforming Alepha Descriptors (Entity, Sequence, etc...)
-* into drizzle models (tables, enums, sequences, etc...).
-*/
-var ModelBuilder = class {
-	/**
-	* Convert camelCase to snake_case for column names.
-	*/
-	toColumnName(str) {
-		return str[0].toLowerCase() + str.slice(1).replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
-	}
-	/**
-	* Build the table configuration function for any database.
-	* This includes indexes, foreign keys, constraints, and custom config.
-	*
-	* @param entity - The entity descriptor
-	* @param builders - Database-specific builder functions
-	* @param tableResolver - Function to resolve entity references to table columns
-	* @param customConfigHandler - Optional handler for custom config
-	*/
-	buildTableConfig(entity, builders, tableResolver, customConfigHandler) {
-		if (!entity.options.indexes && !entity.options.foreignKeys && !entity.options.constraints && !entity.options.config) return;
-		return (self) => {
-			const configs = [];
-			if (entity.options.indexes) {
-				for (const indexDef of entity.options.indexes) if (typeof indexDef === "string") {
-					const columnName = this.toColumnName(indexDef);
-					const indexName = `${entity.name}_${columnName}_idx`;
-					if (self[indexDef]) configs.push(builders.index(indexName).on(self[indexDef]));
-				} else if (typeof indexDef === "object" && indexDef !== null) {
-					if ("column" in indexDef) {
-						const columnName = this.toColumnName(indexDef.column);
-						const indexName = indexDef.name || `${entity.name}_${columnName}_idx`;
-						if (self[indexDef.column]) if (indexDef.unique) configs.push(builders.uniqueIndex(indexName).on(self[indexDef.column]));
-						else configs.push(builders.index(indexName).on(self[indexDef.column]));
-					} else if ("columns" in indexDef) {
-						const columnNames = indexDef.columns.map((col) => this.toColumnName(col));
-						const indexName = indexDef.name || `${entity.name}_${columnNames.join("_")}_idx`;
-						const cols = indexDef.columns.map((col) => self[col]).filter(Boolean);
-						if (cols.length === indexDef.columns.length) if (indexDef.unique) configs.push(builders.uniqueIndex(indexName).on(...cols));
-						else configs.push(builders.index(indexName).on(...cols));
-					}
-				}
-			}
-			if (entity.options.foreignKeys) for (const fkDef of entity.options.foreignKeys) {
-				const columnNames = fkDef.columns.map((col) => this.toColumnName(col));
-				const cols = fkDef.columns.map((col) => self[col]).filter(Boolean);
-				if (cols.length === fkDef.columns.length) {
-					const fkName = fkDef.name || `${entity.name}_${columnNames.join("_")}_fk`;
-					const foreignColumns = fkDef.foreignColumns.map((colRef) => {
-						const entityCol = colRef();
-						if (!entityCol || !entityCol.entity || !entityCol.name) throw new Error(`Invalid foreign column reference in ${entity.name}`);
-						if (tableResolver) {
-							const foreignTable = tableResolver(entityCol.entity.name);
-							if (!foreignTable) throw new Error(`Foreign table ${entityCol.entity.name} not found for ${entity.name}`);
-							return foreignTable[entityCol.name];
-						}
-						return entityCol;
-					});
-					configs.push(builders.foreignKey({
-						name: fkName,
-						columns: cols,
-						foreignColumns
-					}));
-				}
-			}
-			if (entity.options.constraints) for (const constraintDef of entity.options.constraints) {
-				const columnNames = constraintDef.columns.map((col) => this.toColumnName(col));
-				const cols = constraintDef.columns.map((col) => self[col]).filter(Boolean);
-				if (cols.length === constraintDef.columns.length) {
-					if (constraintDef.unique) {
-						const constraintName = constraintDef.name || `${entity.name}_${columnNames.join("_")}_unique`;
-						configs.push(builders.unique(constraintName).on(...cols));
-					}
-					if (constraintDef.check) {
-						const constraintName = constraintDef.name || `${entity.name}_${columnNames.join("_")}_check`;
-						configs.push(builders.check(constraintName, constraintDef.check));
-					}
-				}
-			}
-			if (entity.options.config && customConfigHandler) configs.push(...customConfigHandler(entity.options.config, self));
-			else if (entity.options.config) {
-				const customConfigs = entity.options.config(self);
-				if (Array.isArray(customConfigs)) configs.push(...customConfigs);
-			}
-			return configs;
-		};
-	}
-};
-
-//#endregion
-//#region src/orm/services/PostgresModelBuilder.ts
-var PostgresModelBuilder = class extends ModelBuilder {
-	schemas = /* @__PURE__ */ new Map();
-	getPgSchema(name) {
-		if (!this.schemas.has(name) && name !== "public") this.schemas.set(name, (0, drizzle_orm_pg_core.pgSchema)(name));
-		const nsp = name !== "public" ? this.schemas.get(name) : {
-			enum: drizzle_orm_pg_core.pgEnum,
-			table: drizzle_orm_pg_core.pgTable
-		};
-		if (!nsp) throw new alepha.AlephaError(`Postgres schema ${name} not found`);
-		return nsp;
-	}
-	buildTable(entity, options) {
-		const tableName = entity.name;
-		if (options.tables.has(tableName)) return;
-		const nsp = this.getPgSchema(options.schema);
-		const columns = this.schemaToPgColumns(tableName, entity.schema, nsp, options.enums, options.tables);
-		const configFn = this.getTableConfig(entity, options.tables);
-		const table = nsp.table(tableName, columns, configFn);
-		options.tables.set(tableName, table);
-	}
-	buildSequence(sequence, options) {
-		const sequenceName = sequence.name;
-		if (options.sequences.has(sequenceName)) return;
-		const nsp = this.getPgSchema(options.schema);
-		options.sequences.set(sequenceName, nsp.sequence(sequenceName, sequence.options));
-	}
-	/**
-	* Get PostgreSQL-specific config builder for the table.
-	*/
-	getTableConfig(entity, tables) {
-		const pgBuilders = {
-			index: drizzle_orm_pg_core.index,
-			uniqueIndex: drizzle_orm_pg_core.uniqueIndex,
-			unique: drizzle_orm_pg_core.unique,
-			check: drizzle_orm_pg_core.check,
-			foreignKey: drizzle_orm_pg_core.foreignKey
-		};
-		const tableResolver = (entityName) => {
-			return tables.get(entityName);
-		};
-		return this.buildTableConfig(entity, pgBuilders, tableResolver);
-	}
-	schemaToPgColumns = (tableName, schema$1, nsp, enums, tables) => {
-		return Object.entries(schema$1.properties).reduce((columns, [key, value]) => {
-			let col = this.mapFieldToColumn(tableName, key, value, nsp, enums);
-			if ("default" in value && value.default != null) col = col.default(value.default);
-			if (PG_PRIMARY_KEY in value) col = col.primaryKey();
-			if (PG_REF in value) {
-				const config = value[PG_REF];
-				col = col.references(() => {
-					const ref = config.ref();
-					const table = tables.get(ref.entity.name);
-					if (!table) throw new alepha.AlephaError(`Referenced table ${ref.entity.name} not found for ${tableName}.${key}`);
-					const target = table[ref.name];
-					if (!target) throw new alepha.AlephaError(`Referenced column ${ref.name} not found in table ${ref.entity.name} for ${tableName}.${key}`);
-					return target;
-				}, config.actions);
-			}
-			if (schema$1.required?.includes(key)) col = col.notNull();
-			return {
-				...columns,
-				[key]: col
-			};
-		}, {});
-	};
-	mapFieldToColumn = (tableName, fieldName, value, nsp, enums) => {
-		const key = this.toColumnName(fieldName);
-		if ("anyOf" in value && Array.isArray(value.anyOf) && value.anyOf.length === 2 && value.anyOf.some((it) => alepha.t.schema.isNull(it))) value = value.anyOf.find((it) => !alepha.t.schema.isNull(it));
-		if (alepha.t.schema.isInteger(value)) {
-			if (PG_SERIAL in value) return drizzle_orm_pg_core.serial(key);
-			if (PG_IDENTITY in value) {
-				const options = value[PG_IDENTITY];
-				if (options.mode === "byDefault") return drizzle_orm_pg_core.integer().generatedByDefaultAsIdentity(options);
-				return drizzle_orm_pg_core.integer().generatedAlwaysAsIdentity(options);
-			}
-			return drizzle_orm_pg_core.integer(key);
-		}
-		if (alepha.t.schema.isBigInt(value)) {
-			if (PG_IDENTITY in value) {
-				const options = value[PG_IDENTITY];
-				if (options.mode === "byDefault") return drizzle_orm_pg_core.bigint({ mode: "bigint" }).generatedByDefaultAsIdentity(options);
-				return drizzle_orm_pg_core.bigint({ mode: "bigint" }).generatedAlwaysAsIdentity(options);
-			}
-		}
-		if (alepha.t.schema.isNumber(value)) {
-			if (PG_IDENTITY in value) {
-				const options = value[PG_IDENTITY];
-				if (options.mode === "byDefault") return drizzle_orm_pg_core.bigint({ mode: "number" }).generatedByDefaultAsIdentity(options);
-				return drizzle_orm_pg_core.bigint({ mode: "number" }).generatedAlwaysAsIdentity(options);
-			}
-			if (value.format === "int64") return drizzle_orm_pg_core.bigint(key, { mode: "number" });
-			return drizzle_orm_pg_core.numeric(key);
-		}
-		if (alepha.t.schema.isString(value)) return this.mapStringToColumn(key, value);
-		if (alepha.t.schema.isBoolean(value)) return drizzle_orm_pg_core.boolean(key);
-		if (alepha.t.schema.isObject(value)) return schema(key, value);
-		if (alepha.t.schema.isRecord(value)) return schema(key, value);
-		if (alepha.t.schema.isArray(value)) {
-			if (alepha.t.schema.isObject(value.items)) return schema(key, value);
-			if (alepha.t.schema.isRecord(value.items)) return schema(key, value);
-			if (alepha.t.schema.isString(value.items)) return drizzle_orm_pg_core.text(key).array();
-			if (alepha.t.schema.isInteger(value.items)) return drizzle_orm_pg_core.integer(key).array();
-			if (alepha.t.schema.isNumber(value.items)) return drizzle_orm_pg_core.numeric(key).array();
-			if (alepha.t.schema.isBoolean(value.items)) return drizzle_orm_pg_core.boolean(key).array();
-		}
-		if (alepha.t.schema.isUnsafe(value) && "type" in value && value.type === "string" && "enum" in value && Array.isArray(value.enum)) {
-			if (!value.enum.every((it) => typeof it === "string")) throw new alepha.AlephaError(`Enum for ${fieldName} must be an array of strings, got ${JSON.stringify(value.enum)}`);
-			if (PG_ENUM in value && value[PG_ENUM]) {
-				const enumName = value[PG_ENUM].name ?? `${tableName}_${key}_enum`;
-				if (enums.has(enumName)) {
-					const values = enums.get(enumName).enumValues.join(",");
-					const newValues = value.enum.join(",");
-					if (values !== newValues) throw new alepha.AlephaError(`Enum name conflict for ${enumName}: [${values}] vs [${newValues}]`);
-				}
-				enums.set(enumName, nsp.enum(enumName, value.enum));
-				return enums.get(enumName)(key);
-			}
-			return this.mapStringToColumn(key, value);
-		}
-		throw new alepha.AlephaError(`Unsupported schema type for ${fieldName} as ${JSON.stringify(value)}`);
-	};
-	/**
-	* Map a string to a PG column.
-	*
-	* @param key The key of the field.
-	* @param value The value of the field.
-	*/
-	mapStringToColumn = (key, value) => {
-		if ("format" in value) {
-			if (value.format === "uuid") {
-				if (PG_PRIMARY_KEY in value) return drizzle_orm_pg_core.uuid(key).defaultRandom();
-				return drizzle_orm_pg_core.uuid(key);
-			}
-			if (value.format === "byte") return byte(key);
-			if (value.format === "date-time") {
-				if (PG_CREATED_AT in value) return drizzle_orm_pg_core.timestamp(key, {
-					mode: "string",
-					withTimezone: true
-				}).defaultNow();
-				if (PG_UPDATED_AT in value) return drizzle_orm_pg_core.timestamp(key, {
-					mode: "string",
-					withTimezone: true
-				}).defaultNow();
-				return drizzle_orm_pg_core.timestamp(key, {
-					mode: "string",
-					withTimezone: true
-				});
-			}
-			if (value.format === "date") return drizzle_orm_pg_core.date(key, { mode: "string" });
-		}
-		return drizzle_orm_pg_core.text(key);
-	};
-};
-
-//#endregion
-//#region src/orm/providers/drivers/NodePostgresProvider.ts
-const envSchema$2 = alepha.t.object({
-	DATABASE_URL: alepha.t.optional(alepha.t.text()),
-	POSTGRES_SCHEMA: alepha.t.optional(alepha.t.text())
-});
-var NodePostgresProvider = class NodePostgresProvider extends DatabaseProvider {
-	static SSL_MODES = [
-		"require",
-		"allow",
-		"prefer",
-		"verify-full"
-	];
-	log = (0, alepha_logger.$logger)();
-	env = (0, alepha.$env)(envSchema$2);
-	kit = (0, alepha.$inject)(DrizzleKitProvider);
-	builder = (0, alepha.$inject)(PostgresModelBuilder);
-	client;
-	pg;
-	dialect = "postgresql";
-	get name() {
-		return "postgres";
-	}
-	/**
-	* In testing mode, the schema name will be generated and deleted after the test.
-	*/
-	schemaForTesting = this.alepha.isTest() ? this.env.POSTGRES_SCHEMA?.startsWith("test_") ? this.env.POSTGRES_SCHEMA : this.generateTestSchemaName() : void 0;
-	get url() {
-		if (!this.env.DATABASE_URL) throw new alepha.AlephaError("DATABASE_URL is not defined in the environment");
-		return this.env.DATABASE_URL;
-	}
-	/**
-	* Execute a SQL statement.
-	*/
-	execute(statement) {
-		try {
-			return this.db.execute(statement);
-		} catch (error) {
-			throw new DbError("Error executing statement", error);
-		}
-	}
-	/**
-	* Get Postgres schema used by this provider.
-	*/
-	get schema() {
-		if (this.schemaForTesting) return this.schemaForTesting;
-		if (this.env.POSTGRES_SCHEMA) return this.env.POSTGRES_SCHEMA;
-		return "public";
-	}
-	/**
-	* Get the Drizzle Postgres database instance.
-	*/
-	get db() {
-		if (!this.pg) throw new alepha.AlephaError("Database not initialized");
-		return this.pg;
-	}
-	async executeMigrations(migrationsFolder) {
-		await (0, drizzle_orm_postgres_js_migrator.migrate)(this.db, { migrationsFolder });
-	}
-	onStart = (0, alepha.$hook)({
-		on: "start",
-		handler: async () => {
-			await this.connect();
-			if (!this.alepha.isServerless()) try {
-				await this.migrate.run();
-			} catch (error) {
-				throw new DbMigrationError(error);
-			}
-		}
-	});
-	onStop = (0, alepha.$hook)({
-		on: "stop",
-		handler: async () => {
-			if (this.alepha.isTest() && this.schemaForTesting && this.schemaForTesting.startsWith("test_")) {
-				if (!/^test_[a-z0-9_]+$/i.test(this.schemaForTesting)) throw new alepha.AlephaError(`Invalid test schema name: ${this.schemaForTesting}. Must match pattern: test_[a-z0-9_]+`);
-				this.log.warn(`Deleting test schema '${this.schemaForTesting}' ...`);
-				await this.execute(drizzle_orm.sql`DROP SCHEMA IF EXISTS ${drizzle_orm.sql.raw(this.schemaForTesting)} CASCADE`);
-				this.log.info(`Test schema '${this.schemaForTesting}' deleted`);
-			}
-			await this.close();
-		}
-	});
-	async connect() {
-		this.log.debug("Connect ..");
-		const client = (0, postgres.default)(this.getClientOptions());
-		await client`SELECT 1`;
-		this.client = client;
-		this.pg = (0, drizzle_orm_postgres_js.drizzle)(client, { logger: { logQuery: (query, params) => {
-			this.log.trace(query, { params });
-		} } });
-		this.log.info("Connection OK");
-	}
-	async close() {
-		if (this.client) {
-			this.log.debug("Close...");
-			await this.client.end();
-			this.client = void 0;
-			this.pg = void 0;
-			this.log.info("Connection closed");
-		}
-	}
-	migrate = (0, alepha_lock.$lock)({ handler: async () => {
-		await this.migrateDatabase();
-	} });
-	/**
-	* Map the DATABASE_URL to postgres client options.
-	*/
-	getClientOptions() {
-		const url = new URL(this.url);
-		return {
-			host: url.hostname,
-			user: decodeURIComponent(url.username),
-			database: decodeURIComponent(url.pathname.replace("/", "")),
-			password: decodeURIComponent(url.password),
-			port: Number(url.port || 5432),
-			ssl: this.ssl(url),
-			onnotice: () => {}
-		};
-	}
-	ssl(url) {
-		const mode = url.searchParams.get("sslmode");
-		for (const it of NodePostgresProvider.SSL_MODES) if (mode === it) return it;
-	}
-	/**
-	* For testing purposes, generate a unique schema name.
-	* The schema name will be generated based on the current date and time.
-	* It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
-	*/
-	generateTestSchemaName() {
-		const pad = (n) => n.toString().padStart(2, "0");
-		const now = /* @__PURE__ */ new Date();
-		return `test_${`${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}_${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`}_${Math.random().toString(36).slice(2, 6)}`;
-	}
-};
-
-//#endregion
-//#region src/orm/services/SqliteModelBuilder.ts
-var SqliteModelBuilder = class extends ModelBuilder {
-	buildTable(entity, options) {
-		const tableName = entity.name;
-		if (options.tables.has(tableName)) return;
-		const table = (0, drizzle_orm_sqlite_core.sqliteTable)(tableName, this.schemaToSqliteColumns(tableName, entity.schema, options.enums, options.tables), this.getTableConfig(entity, options.tables));
-		options.tables.set(tableName, table);
-	}
-	buildSequence(sequence, options) {
-		throw new alepha.AlephaError("SQLite does not support sequences");
-	}
-	/**
-	* Get SQLite-specific config builder for the table.
-	*/
-	getTableConfig(entity, tables) {
-		const sqliteBuilders = {
-			index: drizzle_orm_sqlite_core.index,
-			uniqueIndex: drizzle_orm_sqlite_core.uniqueIndex,
-			unique: drizzle_orm_sqlite_core.unique,
-			check: drizzle_orm_sqlite_core.check,
-			foreignKey: drizzle_orm_sqlite_core.foreignKey
-		};
-		const tableResolver = (entityName) => {
-			return tables.get(entityName);
-		};
-		return this.buildTableConfig(entity, sqliteBuilders, tableResolver, (config, self) => {
-			const customConfigs = config(self);
-			return Array.isArray(customConfigs) ? customConfigs : [];
-		});
-	}
-	schemaToSqliteColumns = (tableName, schema$1, enums, tables) => {
-		return Object.entries(schema$1.properties).reduce((columns, [key, value]) => {
-			let col = this.mapFieldToSqliteColumn(tableName, key, value, enums);
-			if ("default" in value && value.default != null) col = col.default(value.default);
-			if (PG_PRIMARY_KEY in value) col = col.primaryKey();
-			if (PG_REF in value) {
-				const config = value[PG_REF];
-				col = col.references(() => {
-					const ref = config.ref();
-					const table = tables.get(ref.entity.name);
-					if (!table) throw new alepha.AlephaError(`Referenced table ${ref.entity.name} not found for ${tableName}.${key}`);
-					const target = table[ref.name];
-					if (!target) throw new alepha.AlephaError(`Referenced column ${ref.name} not found in table ${ref.entity.name} for ${tableName}.${key}`);
-					return target;
-				}, config.actions);
-			}
-			if (schema$1.required?.includes(key)) col = col.notNull();
-			return {
-				...columns,
-				[key]: col
-			};
-		}, {});
-	};
-	mapFieldToSqliteColumn = (tableName, fieldName, value, enums) => {
-		const key = this.toColumnName(fieldName);
-		if ("anyOf" in value && Array.isArray(value.anyOf) && value.anyOf.length === 2 && value.anyOf.some((it) => alepha.t.schema.isNull(it))) value = value.anyOf.find((it) => !alepha.t.schema.isNull(it));
-		if (alepha.t.schema.isInteger(value)) {
-			if (PG_SERIAL in value || PG_IDENTITY in value) return drizzle_orm_sqlite_core.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
-			return drizzle_orm_sqlite_core.integer(key);
-		}
-		if (alepha.t.schema.isNumber(value)) {
-			if (PG_IDENTITY in value) return drizzle_orm_sqlite_core.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
-			return drizzle_orm_sqlite_core.numeric(key);
-		}
-		if (alepha.t.schema.isString(value)) return this.mapStringToSqliteColumn(key, value);
-		if (alepha.t.schema.isBoolean(value)) return this.sqliteBool(key, value);
-		if (alepha.t.schema.isObject(value)) return this.sqliteJson(key, value);
-		if (alepha.t.schema.isRecord(value)) return this.sqliteJson(key, value);
-		if (alepha.t.schema.isAny(value)) return this.sqliteJson(key, value);
-		if (alepha.t.schema.isArray(value)) {
-			if (alepha.t.schema.isObject(value.items)) return this.sqliteJson(key, value);
-			if (alepha.t.schema.isRecord(value.items)) return this.sqliteJson(key, value);
-			if (alepha.t.schema.isAny(value.items)) return this.sqliteJson(key, value);
-			if (alepha.t.schema.isString(value.items)) return this.sqliteJson(key, value);
-			if (alepha.t.schema.isInteger(value.items)) return this.sqliteJson(key, value);
-			if (alepha.t.schema.isNumber(value.items)) return this.sqliteJson(key, value);
-			if (alepha.t.schema.isBoolean(value.items)) return this.sqliteJson(key, value);
-		}
-		if (alepha.t.schema.isUnsafe(value) && "type" in value && value.type === "string") return this.mapStringToSqliteColumn(key, value);
-		throw new Error(`Unsupported schema for field '${tableName}.${fieldName}' (schema: ${JSON.stringify(value)})`);
-	};
-	mapStringToSqliteColumn = (key, value) => {
-		if (value.format === "uuid") {
-			if (PG_PRIMARY_KEY in value) return drizzle_orm_sqlite_core.text(key).primaryKey().$defaultFn(() => (0, node_crypto.randomUUID)());
-			return drizzle_orm_sqlite_core.text(key);
-		}
-		if (value.format === "byte") return this.sqliteJson(key, value);
-		if (value.format === "date-time") {
-			if (PG_CREATED_AT in value) return this.sqliteDateTime(key, {}).default(drizzle_orm.sql`(unixepoch('subsec') * 1000)`);
-			if (PG_UPDATED_AT in value) return this.sqliteDateTime(key, {}).default(drizzle_orm.sql`(unixepoch('subsec') * 1000)`);
-			return this.sqliteDateTime(key, {});
-		}
-		if (value.format === "date") return this.sqliteDate(key, {});
-		return drizzle_orm_sqlite_core.text(key);
-	};
-	sqliteJson = (name, document) => drizzle_orm_sqlite_core.customType({
-		dataType: () => "text",
-		toDriver: (value) => JSON.stringify(value),
-		fromDriver: (value) => {
-			return value && typeof value === "string" ? JSON.parse(value) : value;
-		}
-	})(name, { document }).$type();
-	sqliteDateTime = drizzle_orm_sqlite_core.customType({
-		dataType: () => "integer",
-		toDriver: (value) => new Date(value).getTime(),
-		fromDriver: (value) => {
-			return new Date(value).toISOString();
-		}
-	});
-	sqliteBool = drizzle_orm_sqlite_core.customType({
-		dataType: () => "integer",
-		toDriver: (value) => value ? 1 : 0,
-		fromDriver: (value) => value === 1
-	});
-	sqliteDate = drizzle_orm_sqlite_core.customType({
-		dataType: () => "integer",
-		toDriver: (value) => new Date(value).getTime(),
-		fromDriver: (value) => {
-			return new Date(value).toISOString().split("T")[0];
-		}
-	});
-};
-
-//#endregion
-//#region src/orm/providers/drivers/NodeSqliteProvider.ts
-const envSchema$1 = alepha.t.object({ DATABASE_URL: alepha.t.optional(alepha.t.text()) });
-/**
-* Configuration options for the Node.js SQLite database provider.
-*/
-const nodeSqliteOptions = (0, alepha.$atom)({
-	name: "alepha.postgres.node-sqlite.options",
-	schema: alepha.t.object({ path: alepha.t.optional(alepha.t.string({ description: "Filepath or :memory:. If empty, provider will use DATABASE_URL from env." })) }),
-	default: {}
-});
-/**
-* Add a fake support for SQLite in Node.js based on Postgres interfaces.
-*
-* This is NOT a real SQLite provider, it's a workaround to use SQLite with Drizzle ORM.
-* This is NOT recommended for production use.
-*/
-var NodeSqliteProvider = class extends DatabaseProvider {
-	kit = (0, alepha.$inject)(DrizzleKitProvider);
-	log = (0, alepha_logger.$logger)();
-	env = (0, alepha.$env)(envSchema$1);
-	builder = (0, alepha.$inject)(SqliteModelBuilder);
-	options = (0, alepha.$use)(nodeSqliteOptions);
-	sqlite;
-	get name() {
-		return "sqlite";
-	}
-	dialect = "sqlite";
-	get url() {
-		const path = this.options.path ?? this.env.DATABASE_URL;
-		if (path) {
-			if (path.startsWith("postgres://")) throw new alepha.AlephaError("Postgres URL is not supported for SQLite provider.");
-			return path;
-		}
-		if (this.alepha.isTest()) return ":memory:";
-		else return "node_modules/sqlite.db";
-	}
-	async execute(query) {
-		const { sql: sql$8, params, method } = this.db.all(query).getQuery();
-		this.log.trace(`${sql$8}`, params);
-		const statement = this.sqlite.prepare(sql$8);
-		if (method === "run") {
-			statement.run(...params);
-			return [];
-		}
-		if (method === "get") {
-			const data = statement.get(...params);
-			return data ? [{ ...data }] : [];
-		}
-		return statement.all(...params);
-	}
-	db = (0, drizzle_orm_sqlite_proxy.drizzle)(async (sql$8, params, method) => {
-		const statement = this.sqlite.prepare(sql$8);
-		this.log.trace(`${sql$8}`, { params });
-		if (method === "get") {
-			const data = statement.get(...params);
-			return { rows: data ? [{ ...data }] : [] };
-		}
-		if (method === "run") {
-			statement.run(...params);
-			return { rows: [] };
-		}
-		if (method === "all") return { rows: statement.all(...params).map((row) => Object.values(row)) };
-		if (method === "values") return { rows: statement.all(...params).map((row) => Object.values(row)) };
-		throw new alepha.AlephaError(`Unsupported method: ${method}`);
-	});
-	onStart = (0, alepha.$hook)({
-		on: "start",
-		handler: async () => {
-			const { DatabaseSync } = await import("node:sqlite");
-			const filepath = this.url.replace("sqlite://", "");
-			if (filepath !== ":memory:" && filepath !== "") {
-				const dirname = filepath.split("/").slice(0, -1).join("/");
-				if (dirname) await (0, node_fs_promises.mkdir)(dirname, { recursive: true });
-			}
-			this.sqlite = new DatabaseSync(filepath);
-			await this.migrateDatabase();
-			this.log.info(`Using SQLite database at ${filepath}`);
-		}
-	});
-	async executeMigrations(migrationsFolder) {
-		await (0, drizzle_orm_sqlite_proxy_migrator.migrate)(this.db, async (migrationQueries) => {
-			this.log.debug("Executing migration queries", { migrationQueries });
-			for (const query of migrationQueries) this.sqlite.prepare(query).run();
-		}, { migrationsFolder });
-	}
-};
-
-//#endregion
-//#region src/orm/providers/drivers/PglitePostgresProvider.ts
-const envSchema = alepha.t.object({ DATABASE_URL: alepha.t.optional(alepha.t.text()) });
-var PglitePostgresProvider = class PglitePostgresProvider extends DatabaseProvider {
-	static importPglite() {
-		try {
-			return (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("@electric-sql/pglite");
-		} catch {}
-	}
-	env = (0, alepha.$env)(envSchema);
-	log = (0, alepha_logger.$logger)();
-	kit = (0, alepha.$inject)(DrizzleKitProvider);
-	builder = (0, alepha.$inject)(PostgresModelBuilder);
-	client;
-	pglite;
-	get name() {
-		return "pglite";
-	}
-	dialect = "postgresql";
-	get url() {
-		let path = this.env.DATABASE_URL;
-		if (!path) if (this.alepha.isTest()) path = ":memory:";
-		else path = "node_modules/.db";
-		else if (path.includes(":memory:")) path = ":memory:";
-		else if (path.startsWith("file://")) path = path.replace("file://", "");
-		return path;
-	}
-	get db() {
-		if (!this.pglite) throw new alepha.AlephaError("Database not initialized");
-		return this.pglite;
-	}
-	async execute(statement) {
-		const { rows } = await this.db.execute(statement);
-		return rows;
-	}
-	onStart = (0, alepha.$hook)({
-		on: "start",
-		handler: async () => {
-			if (Object.keys(this.kit.getModels(this)).length === 0) return;
-			const module$1 = PglitePostgresProvider.importPglite();
-			if (!module$1) throw new alepha.AlephaError("@electric-sql/pglite is not installed. Please install it to use the pglite driver.");
-			const { drizzle: drizzle$2 } = (0, node_module.createRequire)(require("url").pathToFileURL(__filename).href)("drizzle-orm/pglite");
-			const path = this.url;
-			if (path !== ":memory:") {
-				await (0, node_fs_promises.mkdir)(path, { recursive: true }).catch(() => null);
-				this.client = new module$1.PGlite(path);
-			} else this.client = new module$1.PGlite();
-			this.pglite = drizzle$2({ client: this.client });
-			await this.migrateDatabase();
-			this.log.info(`Using PGlite database at ${path}`);
-		}
-	});
-	onStop = (0, alepha.$hook)({
-		on: "stop",
-		handler: async () => {
-			if (this.client) {
-				this.log.debug("Closing PGlite connection...");
-				await this.client.close();
-				this.client = void 0;
-				this.pglite = void 0;
-				this.log.info("PGlite connection closed");
-			}
-		}
-	});
-	async executeMigrations(migrationsFolder) {
-		await (0, drizzle_orm_pglite_migrator.migrate)(this.db, { migrationsFolder });
-	}
-};
-
-//#endregion
-//#region src/orm/descriptors/$transaction.ts
-/**
-* Creates a transaction descriptor for database operations requiring atomicity and consistency.
-*
-* This descriptor provides a convenient way to wrap database operations in PostgreSQL
-* transactions, ensuring ACID properties and automatic retry logic for version conflicts.
-* It integrates seamlessly with the repository pattern and provides built-in handling
-* for optimistic locking scenarios with automatic retry on version mismatches.
-*
-* **Important Notes**:
-* - All operations within the transaction handler are atomic
-* - Automatic retry on `PgVersionMismatchError` for optimistic locking
-* - Pass `{ tx }` option to all repository operations within the transaction
-* - Transactions are automatically rolled back on any unhandled error
-* - Use appropriate isolation levels based on your consistency requirements
-*/
-const $transaction = (opts) => {
-	const { alepha: alepha$1 } = (0, alepha.$context)();
-	const provider = alepha$1.inject(DatabaseProvider);
-	return (0, alepha_retry.$retry)({
-		when: (err) => err instanceof DbVersionMismatchError,
-		handler: (...args) => provider.db.transaction(async (tx) => opts.handler(tx, ...args), opts.config)
-	});
-};
-
-//#endregion
-//#region src/orm/helpers/parseQueryString.ts
-/**
-* Parse a string query into a PgQueryWhere object.
-*
-* Supported syntax:
-* - Simple equality: "name=John"
-* - Wildcard patterns: "name=John*" (startsWith), "name=*John" (endsWith), "name=*John*" (contains)
-* - Operators: "age>18", "age>=18", "age<65", "age<=65", "status!=active"
-* - NULL checks: "deletedAt=null", "email!=null"
-* - IN arrays: "status=[pending,active]"
-* - AND conditions: "name=John&age>18"
-* - OR conditions: "name=John|email=john@example.com"
-* - Nested AND/OR: "(name=John|name=Jane)&age>18"
-* - JSONB nested: "profile.city=Paris"
-*
-* @example
-* ```ts
-* // Simple equality
-* parseQueryString("name=John")
-* // => { name: { eq: "John" } }
-*
-* // Wildcard patterns
-* parseQueryString("name=John*")  // startsWith
-* // => { name: { startsWith: "John" } }
-* parseQueryString("name=*Smith")  // endsWith
-* // => { name: { endsWith: "Smith" } }
-* parseQueryString("name=*oh*")  // contains
-* // => { name: { contains: "oh" } }
-*
-* // Multiple conditions
-* parseQueryString("name=John&age>18")
-* // => { and: [{ name: { eq: "John" } }, { age: { gt: 18 } }] }
-*
-* // OR conditions
-* parseQueryString("status=active|status=pending")
-* // => { or: [{ status: { eq: "active" } }, { status: { eq: "pending" } }] }
-*
-* // Complex nested
-* parseQueryString("(name=John|name=Jane)&age>18&status!=archived")
-* // => { and: [
-* //      { or: [{ name: { eq: "John" } }, { name: { eq: "Jane" } }] },
-* //      { age: { gt: 18 } },
-* //      { status: { ne: "archived" } }
-* //    ] }
-*
-* // JSONB nested query
-* parseQueryString("profile.city=Paris&profile.age>25")
-* // => { profile: { city: { eq: "Paris" }, age: { gt: 25 } } }
-* ```
-*/
-function parseQueryString(query) {
-	if (!query || query.trim() === "") return {};
-	return new QueryStringParser(query).parse();
-}
-var QueryStringParser = class {
-	pos = 0;
-	query;
-	constructor(query) {
-		this.query = query.trim();
-	}
-	parse() {
-		return this.parseExpression();
-	}
-	parseExpression() {
-		return this.parseOr();
-	}
-	parseOr() {
-		const left = this.parseAnd();
-		if (this.peek() === "|") {
-			const conditions = [left];
-			while (this.peek() === "|") {
-				this.consume("|");
-				conditions.push(this.parseAnd());
-			}
-			return { or: conditions };
-		}
-		return left;
-	}
-	parseAnd() {
-		const left = this.parsePrimary();
-		if (this.peek() === "&") {
-			const conditions = [left];
-			while (this.peek() === "&") {
-				this.consume("&");
-				conditions.push(this.parsePrimary());
-			}
-			return { and: conditions };
-		}
-		return left;
-	}
-	parsePrimary() {
-		this.skipWhitespace();
-		if (this.peek() === "(") {
-			this.consume("(");
-			const expr = this.parseExpression();
-			this.consume(")");
-			return expr;
-		}
-		return this.parseCondition();
-	}
-	parseCondition() {
-		const field = this.parseFieldPath();
-		this.skipWhitespace();
-		const operator = this.parseOperator();
-		this.skipWhitespace();
-		const value = this.parseValue();
-		if (value === "") throw new alepha.AlephaError(`Expected value for field '${field.join(".")}'`);
-		return this.buildCondition(field, operator, value);
-	}
-	parseFieldPath() {
-		const path = [];
-		let current = "";
-		while (this.pos < this.query.length) {
-			const ch = this.query[this.pos];
-			if (ch === "." && current) {
-				path.push(current);
-				current = "";
-				this.pos++;
-				continue;
-			}
-			if (ch === "=" || ch === "!" || ch === ">" || ch === "<" || ch === " ") break;
-			current += ch;
-			this.pos++;
-		}
-		if (current) path.push(current);
-		return path;
-	}
-	parseOperator() {
-		this.skipWhitespace();
-		const remaining = this.query.slice(this.pos);
-		if (remaining.startsWith(">=")) {
-			this.pos += 2;
-			return ">=";
-		}
-		if (remaining.startsWith("<=")) {
-			this.pos += 2;
-			return "<=";
-		}
-		if (remaining.startsWith("!=")) {
-			this.pos += 2;
-			return "!=";
-		}
-		const ch = this.query[this.pos];
-		if (ch === "=" || ch === ">" || ch === "<") {
-			this.pos++;
-			return ch;
-		}
-		throw new Error(`Expected operator at position ${this.pos}`);
-	}
-	parseValue() {
-		this.skipWhitespace();
-		if (this.query.slice(this.pos, this.pos + 4).toLowerCase() === "null") {
-			this.pos += 4;
-			return null;
-		}
-		if (this.query[this.pos] === "[") return this.parseArray();
-		if (this.query[this.pos] === "\"" || this.query[this.pos] === "'") return this.parseQuotedString();
-		let value = "";
-		while (this.pos < this.query.length) {
-			const ch = this.query[this.pos];
-			if (ch === "&" || ch === "|" || ch === ")") break;
-			value += ch;
-			this.pos++;
-		}
-		return this.coerceValue(value.trim());
-	}
-	parseArray() {
-		this.consume("[");
-		const values = [];
-		while (this.pos < this.query.length && this.query[this.pos] !== "]") {
-			this.skipWhitespace();
-			if (this.query[this.pos] === "\"" || this.query[this.pos] === "'") values.push(this.parseQuotedString());
-			else {
-				let value = "";
-				while (this.pos < this.query.length && this.query[this.pos] !== "," && this.query[this.pos] !== "]") {
-					value += this.query[this.pos];
-					this.pos++;
-				}
-				values.push(this.coerceValue(value.trim()));
-			}
-			this.skipWhitespace();
-			if (this.query[this.pos] === ",") this.pos++;
-		}
-		this.consume("]");
-		return values;
-	}
-	parseQuotedString() {
-		const quote = this.query[this.pos];
-		this.pos++;
-		let value = "";
-		let escaped = false;
-		while (this.pos < this.query.length) {
-			const ch = this.query[this.pos];
-			if (escaped) {
-				value += ch;
-				escaped = false;
-				this.pos++;
-				continue;
-			}
-			if (ch === "\\") {
-				escaped = true;
-				this.pos++;
-				continue;
-			}
-			if (ch === quote) {
-				this.pos++;
-				break;
-			}
-			value += ch;
-			this.pos++;
-		}
-		return value;
-	}
-	coerceValue(value) {
-		if (/^-?\d+$/.test(value)) return parseInt(value, 10);
-		if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
-		if (value.toLowerCase() === "true") return true;
-		if (value.toLowerCase() === "false") return false;
-		return value;
-	}
-	buildCondition(path, operator, value) {
-		let filterOp;
-		if (operator === "=") if (value === null) filterOp = { isNull: true };
-		else if (Array.isArray(value)) filterOp = { inArray: value };
-		else if (typeof value === "string" && value.includes("*")) {
-			const startsWithAsterisk = value.startsWith("*");
-			const endsWithAsterisk = value.endsWith("*");
-			const cleanValue = value.replace(/^\*|\*$/g, "");
-			if (startsWithAsterisk && endsWithAsterisk) filterOp = { contains: cleanValue };
-			else if (startsWithAsterisk) filterOp = { endsWith: cleanValue };
-			else if (endsWithAsterisk) filterOp = { startsWith: cleanValue };
-			else filterOp = { eq: value };
-		} else filterOp = { eq: value };
-		else if (operator === "!=") if (value === null) filterOp = { isNotNull: true };
-		else filterOp = { ne: value };
-		else if (operator === ">") filterOp = { gt: value };
-		else if (operator === ">=") filterOp = { gte: value };
-		else if (operator === "<") filterOp = { lt: value };
-		else if (operator === "<=") filterOp = { lte: value };
-		else throw new Error(`Unsupported operator: ${operator}`);
-		if (path.length === 1) return { [path[0]]: filterOp };
-		let result = filterOp;
-		for (let i = path.length - 1; i >= 0; i--) result = { [path[i]]: result };
-		return result;
-	}
-	peek() {
-		this.skipWhitespace();
-		return this.query[this.pos] || "";
-	}
-	consume(expected) {
-		this.skipWhitespace();
-		if (this.query[this.pos] !== expected) throw new Error(`Expected '${expected}' at position ${this.pos}, got '${this.query[this.pos]}'`);
-		this.pos++;
-	}
-	skipWhitespace() {
-		while (this.pos < this.query.length && /\s/.test(this.query[this.pos])) this.pos++;
-	}
-};
-/**
-* Helper function to build query strings programmatically
-*
-* @example
-* ```ts
-* buildQueryString({
-*   and: [
-*     { name: "eq:John" },
-*     { age: "gt:18" }
-*   ]
-* })
-* // => "name=John&age>18"
-* ```
-*/
-function buildQueryString(where) {
-	if (!where || typeof where !== "object") return "";
-	if ("and" in where && Array.isArray(where.and)) return where.and.map((w) => buildQueryString(w)).join("&");
-	if ("or" in where && Array.isArray(where.or)) {
-		const parts$1 = where.or.map((w) => buildQueryString(w));
-		return parts$1.length > 1 ? `(${parts$1.join("|")})` : parts$1[0];
-	}
-	if ("not" in where) return "";
-	const parts = [];
-	for (const [field, condition] of Object.entries(where)) {
-		if (typeof condition !== "object" || condition === null) {
-			parts.push(`${field}=${condition}`);
-			continue;
-		}
-		if ("eq" in condition) parts.push(`${field}=${condition.eq}`);
-		else if ("ne" in condition) parts.push(`${field}!=${condition.ne}`);
-		else if ("gt" in condition) parts.push(`${field}>${condition.gt}`);
-		else if ("gte" in condition) parts.push(`${field}>=${condition.gte}`);
-		else if ("lt" in condition) parts.push(`${field}<${condition.lt}`);
-		else if ("lte" in condition) parts.push(`${field}<=${condition.lte}`);
-		else if ("contains" in condition) parts.push(`${field}=*${condition.contains}*`);
-		else if ("startsWith" in condition) parts.push(`${field}=${condition.startsWith}*`);
-		else if ("endsWith" in condition) parts.push(`${field}=*${condition.endsWith}`);
-		else if ("isNull" in condition && condition.isNull) parts.push(`${field}=null`);
-		else if ("isNotNull" in condition && condition.isNotNull) parts.push(`${field}!=null`);
-		else if ("inArray" in condition && Array.isArray(condition.inArray)) {
-			const values = condition.inArray.map((v) => typeof v === "string" ? `"${v}"` : v);
-			parts.push(`${field}=[${values.join(",")}]`);
-		} else {
-			const nested = buildQueryString(condition);
-			if (nested) parts.push(`${field}.${nested}`);
-		}
-	}
-	return parts.join("&");
-}
-
-//#endregion
-//#region src/orm/providers/PostgresTypeProvider.ts
-var PostgresTypeProvider = class {
-	attr = pgAttr;
-	/**
-	* Creates a primary key with an identity column.
-	*/
-	identityPrimaryKey = (identity, options) => pgAttr(pgAttr(pgAttr(alepha.t.integer(options), PG_PRIMARY_KEY), PG_IDENTITY, identity), PG_DEFAULT);
-	/**
-	* Creates a primary key with a big identity column. (default)
-	*/
-	bigIdentityPrimaryKey = (identity, options) => pgAttr(pgAttr(pgAttr(alepha.t.int64(options), PG_PRIMARY_KEY), PG_IDENTITY, identity), PG_DEFAULT);
-	/**
-	* Creates a primary key with a UUID column.
-	*/
-	uuidPrimaryKey = () => pgAttr(pgAttr(alepha.t.uuid(), PG_PRIMARY_KEY), PG_DEFAULT);
-	primaryKey(type, options, identity) {
-		if (!type || alepha.t.schema.isInteger(type)) return pgAttr(pgAttr(pgAttr(alepha.t.integer(options), PG_PRIMARY_KEY), PG_IDENTITY, identity), PG_DEFAULT);
-		if (alepha.t.schema.isString(type) && type.format === "uuid") return pgAttr(pgAttr(alepha.t.uuid(), PG_PRIMARY_KEY), PG_DEFAULT);
-		if (alepha.t.schema.isNumber(type) && type.format === "int64") return pgAttr(pgAttr(pgAttr(alepha.t.number(options), PG_PRIMARY_KEY), PG_IDENTITY, identity), PG_DEFAULT);
-		if (alepha.t.schema.isBigInt(type)) return pgAttr(pgAttr(pgAttr(alepha.t.bigint(options), PG_PRIMARY_KEY), PG_IDENTITY, identity), PG_DEFAULT);
-		throw new alepha.AlephaError(`Unsupported type for primary key: ${type}`);
-	}
-	/**
-	* Wrap a schema with "default" attribute.
-	* This is used to set a default value for a column in the database.
-	*/
-	default = (type, value) => {
-		if (value != null) Object.assign(type, { default: value });
-		return this.attr(type, PG_DEFAULT);
-	};
-	/**
-	* Creates a column 'version'.
-	*
-	* This is used to track the version of a row in the database.
-	*
-	* You can use it for optimistic concurrency control (OCC) with {@link RepositoryDescriptor#save}.
-	*
-	* @see {@link RepositoryDescriptor#save}
-	* @see {@link PgVersionMismatchError}
-	*/
-	version = (options = {}) => this.default(pgAttr(alepha.t.integer(options), PG_VERSION), 0);
-	/**
-	* Creates a column Created At. So just a datetime column with a default value of the current timestamp.
-	*/
-	createdAt = (options) => pgAttr(pgAttr(alepha.t.datetime(options), PG_CREATED_AT), PG_DEFAULT);
-	/**
-	* Creates a column Updated At. Like createdAt, but it is updated on every update of the row.
-	*/
-	updatedAt = (options) => pgAttr(pgAttr(alepha.t.datetime(options), PG_UPDATED_AT), PG_DEFAULT);
-	/**
-	* Creates a column Deleted At for soft delete functionality.
-	* This is used to mark rows as deleted without actually removing them from the database.
-	* The column is nullable - NULL means not deleted, timestamp means deleted.
-	*/
-	deletedAt = (options) => pgAttr(alepha.t.optional(alepha.t.datetime(options)), PG_DELETED_AT);
-	/**
-	* Creates a Postgres ENUM type.
-	*
-	* > By default, `t.enum()` is mapped to a TEXT column in Postgres.
-	* > Using this method, you can create a real ENUM type in the database.
-	*
-	* @example
-	* ```ts
-	* const statusEnum = pg.enum(["pending", "active", "archived"], { name: "status_enum" });
-	* ```
-	*/
-	enum = (values, pgEnumOptions, typeOptions) => {
-		return pgAttr(alepha.t.enum(values, {
-			description: pgEnumOptions?.description,
-			...typeOptions
-		}), PG_ENUM, pgEnumOptions);
-	};
-	/**
-	* Creates a reference to another table or schema. Basically a foreign key.
-	*/
-	ref = (type, ref, actions) => {
-		const finalActions = actions ?? { onDelete: alepha.t.schema.isOptional(type) ? "set null" : "cascade" };
-		return this.attr(type, PG_REF, {
-			ref,
-			actions: finalActions
-		});
-	};
-	/**
-	* Creates a page schema for a given object schema.
-	* It's used by {@link RepositoryDescriptor#paginate} method.
-	*/
-	page = (resource, options) => {
-		return (0, alepha.pageSchema)(resource, options);
-	};
-};
-const pg = new PostgresTypeProvider();
-
-//#endregion
-//#region src/orm/schemas/legacyIdSchema.ts
-/**
-* @deprecated Use `pg.primaryKey()` instead.
-*/
-const legacyIdSchema = pgAttr(pgAttr(pgAttr(alepha.t.integer(), PG_PRIMARY_KEY), PG_SERIAL), PG_DEFAULT);
-
-//#endregion
-//#region src/orm/index.ts
-/**
-* Postgres client based on Drizzle ORM, Alepha type-safe friendly.
-*
-* ```ts
-* const users = $entity({
-*   name: "users",
-*   schema: t.object({
-*     id: pg.primaryKey(),
-*     name: t.text(),
-*     email: t.text(),
-*   }),
-* });
-*
-* class Db {
-*   users = $repository(users);
-* }
-*
-* const db = alepha.inject(Db);
-* const user = await db.users.one({ name: { eq: "John Doe" } });
-* ```
-*
-* This is not a full ORM, but rather a set of tools to work with Postgres databases in a type-safe way.
-*
-* It provides:
-* - A type-safe way to define entities and repositories. (via `$entity` and `$repository`)
-* - Custom query builders and filters.
-* - Built-in special columns like `createdAt`, `updatedAt`, `deletedAt`, `version`.
-* - Automatic JSONB support.
-* - Automatic synchronization of entities with the database schema (for testing and development).
-* - Fallback to raw SQL via Drizzle ORM `sql` function.
-*
-* Migrations are supported via Drizzle ORM, you need to use the `drizzle-kit` CLI tool to generate and run migrations.
-*
-* @see {@link $entity}
-* @see {@link $sequence}
-* @see {@link $repository}
-* @see {@link $transaction}
-* @module alepha.postgres
-*/
-const AlephaPostgres = (0, alepha.$module)({
-	name: "alepha.postgres",
-	descriptors: [$sequence, $entity],
-	services: [
-		alepha_datetime.AlephaDateTime,
-		DatabaseProvider,
-		NodePostgresProvider,
-		PglitePostgresProvider,
-		NodeSqliteProvider,
-		SqliteModelBuilder,
-		PostgresModelBuilder,
-		DrizzleKitProvider,
-		RepositoryProvider,
-		Repository
-	],
-	register: (alepha$1) => {
-		const env = alepha$1.parseEnv(alepha.t.object({ DATABASE_URL: alepha.t.optional(alepha.t.text()) }));
-		alepha$1.with(DrizzleKitProvider);
-		alepha$1.with(RepositoryProvider);
-		const url = env.DATABASE_URL;
-		const hasPGlite = !!PglitePostgresProvider.importPglite();
-		const isPostgres = url?.startsWith("postgres:");
-		const isSqlite = url?.startsWith("sqlite:");
-		const isMemory = url?.includes(":memory:");
-		if (hasPGlite && (isMemory || !!url && !isPostgres && !isMemory || !url) && !isSqlite) {
-			alepha$1.with({
-				optional: true,
-				provide: DatabaseProvider,
-				use: PglitePostgresProvider
-			});
-			return;
-		}
-		if (isPostgres) {
-			alepha$1.with({
-				optional: true,
-				provide: DatabaseProvider,
-				use: NodePostgresProvider
-			});
-			return;
-		}
-		alepha$1.with({
-			optional: true,
-			provide: DatabaseProvider,
-			use: NodeSqliteProvider
-		});
-	}
-});
-
-//#endregion
-exports.$entity = $entity;
-exports.$repository = $repository;
-exports.$sequence = $sequence;
-exports.$transaction = $transaction;
-exports.AlephaPostgres = AlephaPostgres;
-exports.DatabaseProvider = DatabaseProvider;
-exports.DbConflictError = DbConflictError;
-exports.DbEntityNotFoundError = DbEntityNotFoundError;
-exports.DbError = DbError;
-exports.DbMigrationError = DbMigrationError;
-exports.DbVersionMismatchError = DbVersionMismatchError;
-exports.DrizzleKitProvider = DrizzleKitProvider;
-exports.EntityDescriptor = EntityDescriptor;
-exports.NodePostgresProvider = NodePostgresProvider;
-exports.NodeSqliteProvider = NodeSqliteProvider;
-exports.PG_CREATED_AT = PG_CREATED_AT;
-exports.PG_DEFAULT = PG_DEFAULT;
-exports.PG_DELETED_AT = PG_DELETED_AT;
-exports.PG_ENUM = PG_ENUM;
-exports.PG_IDENTITY = PG_IDENTITY;
-exports.PG_PRIMARY_KEY = PG_PRIMARY_KEY;
-exports.PG_REF = PG_REF;
-exports.PG_SERIAL = PG_SERIAL;
-exports.PG_UPDATED_AT = PG_UPDATED_AT;
-exports.PG_VERSION = PG_VERSION;
-exports.PostgresTypeProvider = PostgresTypeProvider;
-exports.Repository = Repository;
-exports.RepositoryProvider = RepositoryProvider;
-exports.SequenceDescriptor = SequenceDescriptor;
-exports.buildQueryString = buildQueryString;
-Object.defineProperty(exports, 'drizzle', {
-  enumerable: true,
-  get: function () {
-    return drizzle_orm;
-  }
-});
-exports.getAttrFields = getAttrFields;
-exports.insertSchema = insertSchema;
-exports.legacyIdSchema = legacyIdSchema;
-exports.nodeSqliteOptions = nodeSqliteOptions;
-Object.defineProperty(exports, 'pageQuerySchema', {
-  enumerable: true,
-  get: function () {
-    return alepha.pageQuerySchema;
-  }
-});
-Object.defineProperty(exports, 'pageSchema', {
-  enumerable: true,
-  get: function () {
-    return alepha.pageSchema;
-  }
-});
-exports.parseQueryString = parseQueryString;
-exports.pg = pg;
-exports.pgAttr = pgAttr;
-exports.schema = schema;
-Object.defineProperty(exports, 'sql', {
-  enumerable: true,
-  get: function () {
-    return drizzle_orm.sql;
-  }
-});
-exports.updateSchema = updateSchema;
-Object.keys(drizzle_orm_pg_core).forEach(function (k) {
-  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-    enumerable: true,
-    get: function () { return drizzle_orm_pg_core[k]; }
-  });
-});
-
-//# sourceMappingURL=index.cjs.map