alepha 0.14.3 → 0.15.0

package/dist/orm/index.js

@@ -1,13 +1,13 @@
+import { n as __reExport, t as __exportAll } from "./chunk-DtkW-qnP.js";
 import { createRequire } from "node:module";
 import { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaError, KIND, Primitive, Value, createPagination, createPrimitive, pageQuerySchema, pageSchema, pageSchema as pageSchema$1, t } from "alepha";
 import { AlephaDateTime, DateTimeProvider } from "alepha/datetime";
-import * as drizzle from "drizzle-orm";
-import { and, arrayContained, arrayContains, arrayOverlaps, asc, between, desc, eq, getTableName, gt, gte, ilike, inArray, isNotNull, isNull, isSQLWrapper, like, lt, lte, ne, not, notBetween, notIlike, notInArray, notLike, or, sql, sql as sql$1 } from "drizzle-orm";
 import * as pg$2 from "drizzle-orm/pg-core";
 import { alias, check, customType, foreignKey, index, pgEnum, pgSchema, pgTable, unique, uniqueIndex } from "drizzle-orm/pg-core";
+import * as drizzle from "drizzle-orm";
+import { and, arrayContained, arrayContains, arrayOverlaps, asc, between, desc, eq, getTableName, gt, gte, ilike, inArray, isNotNull, isNull, isSQLWrapper, like, lt, lte, ne, not, notBetween, notIlike, notInArray, notLike, or, sql, sql as sql$1 } from "drizzle-orm";
 import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { $logger } from "alepha/logger";
-import { isSQLWrapper as isSQLWrapper$1 } from "drizzle-orm/sql/sql";
 import { $lock } from "alepha/lock";
 import { randomUUID } from "node:crypto";
 import * as pg$1 from "drizzle-orm/sqlite-core";
@@ -18,6 +18,7 @@ import postgres from "postgres";
 import { drizzle as drizzle$2 } from "drizzle-orm/sqlite-proxy";
 import { migrate as migrate$1 } from "drizzle-orm/sqlite-proxy/migrator";
 import { migrate as migrate$2 } from "drizzle-orm/pglite/migrator";
+import { isSQLWrapper as isSQLWrapper$1 } from "drizzle-orm/sql/sql";
 import { $retry } from "alepha/retry";
 
 export * from "drizzle-orm/pg-core"
@@ -139,74 +140,6 @@ var DbError = class extends AlephaError {
 	}
 };
 
-//#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 {
@@ -218,6 +151,9 @@ var DatabaseProvider = class {
 	get name() {
 		return "default";
 	}
+	get driver() {
+		return this.dialect;
+	}
 	get schema() {
 		return "public";
 	}
@@ -302,2126 +238,2195 @@ var DatabaseProvider = class {
 };
 
 //#endregion
-//#region ../../src/orm/services/PgRelationManager.ts
-var PgRelationManager = class {
+//#region ../../src/orm/primitives/$sequence.ts
+/**
+* Creates a PostgreSQL sequence primitive for generating unique numeric values.
+*/
+const $sequence = (options = {}) => {
+	return createPrimitive(SequencePrimitive, options);
+};
+var SequencePrimitive = class extends Primitive {
+	provider = this.$provider();
+	onInit() {
+		this.provider.registerSequence(this);
+	}
+	get name() {
+		return this.options.name ?? this.config.propertyKey;
+	}
+	async next() {
+		return this.provider.execute(sql$1`SELECT nextval('${sql$1.raw(this.provider.schema)}."${sql$1.raw(this.name)}"')`).then((rows) => Number(rows[0]?.nextval));
+	}
+	async current() {
+		return this.provider.execute(sql$1`SELECT last_value FROM ${sql$1.raw(this.provider.schema)}."${sql$1.raw(this.name)}"`).then((rows) => Number(rows[0]?.last_value));
+	}
+	$provider() {
+		return this.options.provider ?? this.alepha.inject(DatabaseProvider);
+	}
+};
+$sequence[KIND] = SequencePrimitive;
+
+//#endregion
+//#region ../../src/orm/providers/DrizzleKitProvider.ts
+var DrizzleKitProvider = class {
+	log = $logger();
+	alepha = $inject(Alepha);
 	/**
-	* Recursively build joins for the query builder based on the relations map
+	* 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.
 	*/
-	buildJoins(provider, builder, joins, withRelations, table, parentKey) {
-		for (const [key, join] of Object.entries(withRelations)) {
-			const from = provider.table(join.join);
-			const on = isSQLWrapper$1(join.on) ? join.on : sql$1`${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: 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);
+	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]`);
 	}
 	/**
-	* Map a row with its joined relations based on the joins definition
+	* Mostly used for testing purposes. You can generate SQL migration statements without executing them.
 	*/
-	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);
+	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 record;
+		return {
+			models,
+			statements: [],
+			snapshot: {}
+		};
 	}
 	/**
-	* Check if all values in an object are null (indicates a left join with no match)
+	* Load all tables, enums, sequences, etc. from the provider's repositories.
 	*/
-	isAllNull(obj) {
-		if (obj === null || obj === void 0) return true;
-		if (typeof obj !== "object") return false;
-		return Object.values(obj).every((val) => val === null);
+	getModels(provider) {
+		const models = {};
+		for (const [key, value] of provider.tables.entries()) {
+			if (models[key]) throw new AlephaError(`Model name conflict: '${key}' is already defined.`);
+			models[key] = value;
+		}
+		for (const [key, value] of provider.enums.entries()) {
+			if (models[key]) throw new AlephaError(`Model name conflict: '${key}' is already defined.`);
+			models[key] = value;
+		}
+		for (const [key, value] of provider.sequences.entries()) {
+			if (models[key]) throw new AlephaError(`Model name conflict: '${key}' is already defined.`);
+			models[key] = value;
+		}
+		return models;
 	}
 	/**
-	* Build a schema that includes all join properties recursively
+	* Load the migration snapshot from the database.
 	*/
-	buildSchemaWithJoins(baseSchema, joins, parentPath) {
-		const schema$1 = Value.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] = t.optional(joinSchema);
+	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;
 		}
-		return schema$1;
+		if (provider.dialect === "sqlite") {
+			try {
+				const text = await 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(sql$1`CREATE SCHEMA IF NOT EXISTS "drizzle";`);
+		await provider.execute(sql$1`
+					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(sql$1`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]);
 	}
-};
-
-//#endregion
-//#region ../../src/orm/services/QueryManager.ts
-var QueryManager = class {
-	alepha = $inject(Alepha);
-	/**
-	* Convert a query object to a SQL query.
-	*/
-	toSQL(query, options) {
-		const { schema: schema$1, col, joins } = options;
-		const conditions = [];
-		if (isSQLWrapper(query)) conditions.push(query);
+	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 mkdir("node_modules/.alepha", { recursive: true }).catch(() => null);
+			await 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(sql$1`INSERT INTO "drizzle"."__drizzle_dev_migrations" ("name", "snapshot") VALUES (${name}, ${JSON.stringify(curr)})`);
 		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$2 = this.toSQL(query[key], {
-							schema: join.schema,
-							col: join.col,
-							joins: recursiveJoins.length > 0 ? recursiveJoins : void 0,
-							dialect: options.dialect
-						});
-						if (sql$2) conditions.push(sql$2);
-						continue;
-					}
-				}
-				if (Array.isArray(operator)) {
-					const operations = operator.map((it) => {
-						if (isSQLWrapper(it)) return it;
-						return this.toSQL(it, {
-							schema: schema$1,
-							col,
-							joins,
-							dialect: options.dialect
-						});
-					}).filter((it) => it != null);
-					if (key === "and") return and(...operations);
-					if (key === "or") return or(...operations);
-				}
-				if (key === "not") {
-					const where = this.toSQL(operator, {
-						schema: schema$1,
-						col,
-						joins,
-						dialect: options.dialect
-					});
-					if (where) return not(where);
-				}
-				if (operator) {
-					const column = col(key);
-					const sql$2 = this.mapOperatorToSql(operator, column, schema$1, key, options.dialect);
-					if (sql$2) conditions.push(sql$2);
-				}
+			const newSnapshot = JSON.stringify(curr);
+			if (devMigrations.snapshot !== newSnapshot) await provider.execute(sql$1`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(sql$1.raw(statement));
+			} catch (error) {
+				const errorMessage = `Error executing statement: ${statement}`;
+				if (catchErrors) {
+					nErrors++;
+					this.log.warn(errorMessage, { context: [error] });
+				} else throw error;
 			}
 		}
-		if (conditions.length === 1) return conditions[0];
-		return and(...conditions);
+		if (nErrors > 0) this.log.warn(`Executed ${statements.length} statements with ${nErrors} errors.`);
 	}
-	/**
-	* 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);
+	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 = sql$1.raw(schemaName);
+		if (schemaName.startsWith("test_")) {
+			this.log.info(`Drop test schema '${schemaName}' ...`, schemaName);
+			await provider.execute(sql$1`DROP SCHEMA IF EXISTS ${sqlSchema} CASCADE`);
+		}
+		this.log.debug(`Ensuring schema '${schemaName}' exists`);
+		await provider.execute(sql$1`CREATE SCHEMA IF NOT EXISTS ${sqlSchema}`);
 	}
 	/**
-	* Map a filter operator to a SQL query.
+	* Try to load the official Drizzle Kit API.
+	* If not available, fallback to the local kit import.
 	*/
-	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 eq(column, encodeValue(operator));
-		const conditions = [];
-		if (operator?.eq != null) conditions.push(eq(column, encodeValue(operator.eq)));
-		if (operator?.ne != null) conditions.push(ne(column, encodeValue(operator.ne)));
-		if (operator?.gt != null) conditions.push(gt(column, encodeValue(operator.gt)));
-		if (operator?.gte != null) conditions.push(gte(column, encodeValue(operator.gte)));
-		if (operator?.lt != null) conditions.push(lt(column, encodeValue(operator.lt)));
-		if (operator?.lte != null) conditions.push(lte(column, encodeValue(operator.lte)));
-		if (operator?.inArray != null) {
-			if (!Array.isArray(operator.inArray) || operator.inArray.length === 0) throw new AlephaError("inArray operator requires at least one value");
-			conditions.push(inArray(column, encodeArray(operator.inArray)));
-		}
-		if (operator?.notInArray != null) {
-			if (!Array.isArray(operator.notInArray) || operator.notInArray.length === 0) throw new AlephaError("notInArray operator requires at least one value");
-			conditions.push(notInArray(column, encodeArray(operator.notInArray)));
-		}
-		if (operator?.isNull != null) conditions.push(isNull(column));
-		if (operator?.isNotNull != null) conditions.push(isNotNull(column));
-		if (operator?.like != null) conditions.push(like(column, encodeValue(operator.like)));
-		if (operator?.notLike != null) conditions.push(notLike(column, encodeValue(operator.notLike)));
-		if (operator?.ilike != null) conditions.push(ilike(column, encodeValue(operator.ilike)));
-		if (operator?.notIlike != null) conditions.push(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(sql$1`LOWER(${column}) LIKE LOWER(${encodeValue(`%${escapedValue}%`)})`);
-			else conditions.push(ilike(column, encodeValue(`%${escapedValue}%`)));
-		}
-		if (operator?.startsWith != null) {
-			const escapedValue = String(operator.startsWith).replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-			if (dialect === "sqlite") conditions.push(sql$1`LOWER(${column}) LIKE LOWER(${encodeValue(`${escapedValue}%`)})`);
-			else conditions.push(ilike(column, encodeValue(`${escapedValue}%`)));
-		}
-		if (operator?.endsWith != null) {
-			const escapedValue = String(operator.endsWith).replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
-			if (dialect === "sqlite") conditions.push(sql$1`LOWER(${column}) LIKE LOWER(${encodeValue(`%${escapedValue}`)})`);
-			else conditions.push(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(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(notBetween(column, encodeValue(operator.notBetween[0]), encodeValue(operator.notBetween[1])));
+	importDrizzleKit() {
+		try {
+			return createRequire(import.meta.url)("drizzle-kit/api");
+		} catch (_) {
+			throw new Error("Drizzle Kit is not installed. Please install it with `npm install -D drizzle-kit`.");
 		}
-		if (operator?.arrayContains != null) conditions.push(arrayContains(column, encodeValue(operator.arrayContains)));
-		if (operator?.arrayContained != null) conditions.push(arrayContained(column, encodeValue(operator.arrayContained)));
-		if (operator?.arrayOverlaps != null) conditions.push(arrayOverlaps(column, encodeValue(operator.arrayOverlaps)));
-		if (conditions.length === 0) return;
-		if (conditions.length === 1) return conditions[0];
-		return and(...conditions);
 	}
+};
+const devMigrationsSchema = t.object({
+	id: t.number(),
+	name: t.text(),
+	snapshot: t.string(),
+	created_at: 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 = customType({ dataType: () => "bytea" });
+
+//#endregion
+//#region ../../src/orm/services/ModelBuilder.ts
+/**
+* Abstract base class for transforming Alepha Primitives (Entity, Sequence, etc...)
+* into drizzle models (tables, enums, sequences, etc...).
+*/
+var ModelBuilder = class {
 	/**
-	* 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
+	* Convert camelCase to snake_case for column names.
 	*/
-	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;
+	toColumnName(str) {
+		return str[0].toLowerCase() + str.slice(1).replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
 	}
 	/**
-	* 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.
+	* Build the table configuration function for any database.
+	* This includes indexes, foreign keys, constraints, and custom config.
 	*
-	* @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.
+	* @param entity - The entity primitive
+	* @param builders - Database-specific builder functions
+	* @param tableResolver - Function to resolve entity references to table columns
+	* @param customConfigHandler - Optional handler for custom config
 	*/
-	createPagination(entities, limit = 10, offset = 0, sort) {
-		return createPagination(entities, limit, offset, sort);
+	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/Repository.ts
-var Repository = class {
-	entity;
-	provider;
-	relationManager = $inject(PgRelationManager);
-	queryManager = $inject(QueryManager);
-	dateTimeProvider = $inject(DateTimeProvider);
-	alepha = $inject(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);
+//#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, pgSchema(name));
+		const nsp = name !== "public" ? this.schemas.get(name) : {
+			enum: pgEnum,
+			table: pgTable
+		};
+		if (!nsp) throw new AlephaError(`Postgres schema ${name} not found`);
+		return nsp;
 	}
-	/**
-	* Get SQL table name. (from Drizzle table object)
-	*/
-	get tableName() {
-		return this.entity.name;
+	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);
 	}
-	/**
-	* Getter for the database connection from the database provider.
-	*/
-	get db() {
-		return this.provider.db;
+	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));
 	}
 	/**
-	* 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}`);
-	*   }
-	* }
-	* ```
+	* Get PostgreSQL-specific config builder for the table.
 	*/
-	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 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);
-		});
+	getTableConfig(entity, tables) {
+		const pgBuilders = {
+			index,
+			uniqueIndex,
+			unique,
+			check,
+			foreignKey
+		};
+		const tableResolver = (entityName) => {
+			return tables.get(entityName);
+		};
+		return this.buildTableConfig(entity, pgBuilders, tableResolver);
 	}
-	/**
-	* 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;
+	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 AlephaError(`Referenced table ${ref.entity.name} not found for ${tableName}.${key}`);
+					const target = table[ref.name];
+					if (!target) throw new 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) => t.schema.isNull(it))) value = value.anyOf.find((it) => !t.schema.isNull(it));
+		if (t.schema.isInteger(value)) {
+			if (PG_SERIAL in value) return pg$2.serial(key);
+			if (PG_IDENTITY in value) {
+				const options = value[PG_IDENTITY];
+				if (options.mode === "byDefault") return pg$2.integer().generatedByDefaultAsIdentity(options);
+				return pg$2.integer().generatedAlwaysAsIdentity(options);
 			}
+			return pg$2.integer(key);
 		}
-		return entity;
-	}
-	/**
-	* Get a Drizzle column from the table by his name.
-	*/
-	col(name) {
-		const column = this.table[name];
-		if (!column) throw new AlephaError(`Invalid access. Column ${String(name)} not found in table ${this.tableName}`);
-		return column;
-	}
+		if (t.schema.isBigInt(value)) {
+			if (PG_IDENTITY in value) {
+				const options = value[PG_IDENTITY];
+				if (options.mode === "byDefault") return pg$2.bigint({ mode: "bigint" }).generatedByDefaultAsIdentity(options);
+				return pg$2.bigint({ mode: "bigint" }).generatedAlwaysAsIdentity(options);
+			}
+		}
+		if (t.schema.isNumber(value)) {
+			if (PG_IDENTITY in value) {
+				const options = value[PG_IDENTITY];
+				if (options.mode === "byDefault") return pg$2.bigint({ mode: "number" }).generatedByDefaultAsIdentity(options);
+				return pg$2.bigint({ mode: "number" }).generatedAlwaysAsIdentity(options);
+			}
+			if (value.format === "int64") return pg$2.bigint(key, { mode: "number" });
+			return pg$2.numeric(key);
+		}
+		if (t.schema.isString(value)) return this.mapStringToColumn(key, value);
+		if (t.schema.isBoolean(value)) return pg$2.boolean(key);
+		if (t.schema.isObject(value)) return schema(key, value);
+		if (t.schema.isRecord(value)) return schema(key, value);
+		const isTypeEnum = (value$1) => t.schema.isUnsafe(value$1) && "type" in value$1 && value$1.type === "string" && "enum" in value$1 && Array.isArray(value$1.enum);
+		if (t.schema.isArray(value)) {
+			if (t.schema.isObject(value.items)) return schema(key, value);
+			if (t.schema.isRecord(value.items)) return schema(key, value);
+			if (t.schema.isString(value.items)) return pg$2.text(key).array();
+			if (t.schema.isInteger(value.items)) return pg$2.integer(key).array();
+			if (t.schema.isNumber(value.items)) return pg$2.numeric(key).array();
+			if (t.schema.isBoolean(value.items)) return pg$2.boolean(key).array();
+			if (isTypeEnum(value.items)) return pg$2.text(key).array();
+		}
+		if (isTypeEnum(value)) {
+			if (!value.enum.every((it) => typeof it === "string")) throw new 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 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 AlephaError(`Unsupported schema type for ${fieldName} as ${JSON.stringify(value)}`);
+	};
 	/**
-	* Run a transaction.
+	* Map a string to a PG column.
+	*
+	* @param key The key of the field.
+	* @param value The value of the field.
 	*/
-	async transaction(transaction, config) {
-		return await this.db.transaction(transaction, config);
+	mapStringToColumn = (key, value) => {
+		if ("format" in value) {
+			if (value.format === "uuid") {
+				if (PG_PRIMARY_KEY in value) return pg$2.uuid(key).defaultRandom();
+				return pg$2.uuid(key);
+			}
+			if (value.format === "byte") return byte(key);
+			if (value.format === "date-time") {
+				if (PG_CREATED_AT in value) return pg$2.timestamp(key, {
+					mode: "string",
+					withTimezone: true
+				}).defaultNow();
+				if (PG_UPDATED_AT in value) return pg$2.timestamp(key, {
+					mode: "string",
+					withTimezone: true
+				}).defaultNow();
+				return pg$2.timestamp(key, {
+					mode: "string",
+					withTimezone: true
+				});
+			}
+			if (value.format === "date") return pg$2.date(key, { mode: "string" });
+		}
+		return pg$2.text(key);
+	};
+};
+
+//#endregion
+//#region ../../src/orm/providers/drivers/BunPostgresProvider.ts
+const envSchema$4 = t.object({
+	DATABASE_URL: t.optional(t.text()),
+	POSTGRES_SCHEMA: t.optional(t.text())
+});
+/**
+* Bun PostgreSQL provider using Drizzle ORM with Bun's native SQL client.
+*
+* This provider uses Bun's built-in SQL class for PostgreSQL connections,
+* which provides excellent performance on the Bun runtime.
+*
+* @example
+* ```ts
+* // Set DATABASE_URL environment variable
+* // DATABASE_URL=postgres://user:password@localhost:5432/database
+*
+* // Or configure programmatically
+* alepha.with({
+*   provide: DatabaseProvider,
+*   use: BunPostgresProvider,
+* });
+* ```
+*/
+var BunPostgresProvider = class extends DatabaseProvider {
+	log = $logger();
+	env = $env(envSchema$4);
+	kit = $inject(DrizzleKitProvider);
+	builder = $inject(PostgresModelBuilder);
+	client;
+	bunDb;
+	dialect = "postgresql";
+	get name() {
+		return "postgres";
 	}
 	/**
-	* Start a SELECT query on the table.
+	* In testing mode, the schema name will be generated and deleted after the test.
 	*/
-	rawSelect(opts = {}) {
-		return (opts.tx ?? this.db).select().from(this.table);
+	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 AlephaError("DATABASE_URL is not defined in the environment");
+		return this.env.DATABASE_URL;
 	}
 	/**
-	* Start a SELECT DISTINCT query on the table.
+	* Execute a SQL statement.
 	*/
-	rawSelectDistinct(opts = {}, columns = []) {
-		const db$1 = 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$1.selectDistinct(fields).from(table);
+	execute(statement) {
+		try {
+			return this.db.execute(statement);
+		} catch (error) {
+			throw new DbError("Error executing statement", error);
+		}
 	}
 	/**
-	* Start an INSERT query on the table.
+	* Get Postgres schema used by this provider.
 	*/
-	rawInsert(opts = {}) {
-		return (opts.tx ?? this.db).insert(this.table);
+	get schema() {
+		if (this.schemaForTesting) return this.schemaForTesting;
+		if (this.env.POSTGRES_SCHEMA) return this.env.POSTGRES_SCHEMA;
+		return "public";
 	}
 	/**
-	* Start an UPDATE query on the table.
+	* Get the Drizzle Postgres database instance.
 	*/
-	rawUpdate(opts = {}) {
-		return (opts.tx ?? this.db).update(this.table);
+	get db() {
+		if (!this.bunDb) throw new AlephaError("Database not initialized");
+		return this.bunDb;
 	}
-	/**
-	* Start a DELETE query on the table.
-	*/
-	rawDelete(opts = {}) {
-		return (opts.tx ?? this.db).delete(this.table);
+	async executeMigrations(migrationsFolder) {
+		const { migrate: migrate$3 } = await import("drizzle-orm/bun-sql/migrator");
+		await migrate$3(this.bunDb, { migrationsFolder });
 	}
-	/**
-	* 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" ? desc(this.col(clause.column)) : 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);
+	onStart = $hook({
+		on: "start",
+		handler: async () => {
+			await this.connect();
+			if (!this.alepha.isServerless()) try {
+				await this.migrateLock.run();
+			} catch (error) {
+				throw new DbMigrationError(error);
+			}
 		}
-		try {
-			let rows = await builder.execute();
-			let schema$1 = this.entity.schema;
-			if (columns) schema$1 = 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);
+	});
+	onStop = $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 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(sql$1`DROP SCHEMA IF EXISTS ${sql$1.raw(this.schemaForTesting)} CASCADE`);
+				this.log.info(`Test schema '${this.schemaForTesting}' deleted`);
+			}
+			await this.close();
 		}
+	});
+	async connect() {
+		this.log.debug("Connect ..");
+		if (typeof Bun === "undefined") throw new AlephaError("BunPostgresProvider requires the Bun runtime. Use NodePostgresProvider for Node.js.");
+		const { drizzle: drizzle$3 } = await import("drizzle-orm/bun-sql");
+		this.client = new Bun.SQL(this.url);
+		await this.client.unsafe("SELECT 1");
+		this.bunDb = drizzle$3({
+			client: this.client,
+			logger: { logQuery: (query, params) => {
+				this.log.trace(query, { params });
+			} }
+		});
+		this.log.info("Connection OK");
 	}
-	/**
-	* 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 = 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;
-			}));
+	async close() {
+		if (this.client) {
+			this.log.debug("Close...");
+			await this.client.close();
+			this.client = void 0;
+			this.bunDb = void 0;
+			this.log.info("Connection closed");
 		}
-		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 {};
+	migrateLock = $lock({ handler: async () => {
+		await this.migrate();
+	} });
+};
+
+//#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 = sqliteTable(tableName, this.schemaToSqliteColumns(tableName, entity.schema, options.enums, options.tables), this.getTableConfig(entity, options.tables));
+		options.tables.set(tableName, table);
 	}
-	/**
-	* Helper to create a type-safe where clause.
-	*/
-	createQueryWhere() {
-		return {};
+	buildSequence(sequence, options) {
+		throw new AlephaError("SQLite does not support sequences");
 	}
 	/**
-	* Create an entity.
-	*
-	* @param data The entity to create.
-	* @param opts The options for creating the entity.
-	* @returns The ID of the created entity.
+	* Get SQLite-specific config builder for the table.
 	*/
-	async create(data, opts = {}) {
-		await this.alepha.events.emit("repository:create:before", {
-			tableName: this.tableName,
-			data
+	getTableConfig(entity, tables) {
+		const sqliteBuilders = {
+			index: index$1,
+			uniqueIndex: uniqueIndex$1,
+			unique: unique$1,
+			check: check$1,
+			foreignKey: foreignKey$1
+		};
+		const tableResolver = (entityName) => {
+			return tables.get(entityName);
+		};
+		return this.buildTableConfig(entity, sqliteBuilders, tableResolver, (config, self) => {
+			const customConfigs = config(self);
+			return Array.isArray(customConfigs) ? customConfigs : [];
 		});
-		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.
-	*
-	* Inserts are batched in chunks of 1000 to avoid hitting database limits.
-	*
-	* @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
-		});
-		const batchSize = opts.batchSize ?? 1e3;
-		const allEntities = [];
-		try {
-			for (let i = 0; i < values.length; i += batchSize) {
-				const batch = values.slice(i, i + batchSize);
-				const entities = await this.rawInsert(opts).values(batch.map((data) => this.cast(data, true))).returning(this.table).then((rows) => rows.map((it) => this.clean(it, this.entity.schema)));
-				allEntities.push(...entities);
+	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 AlephaError(`Referenced table ${ref.entity.name} not found for ${tableName}.${key}`);
+					const target = table[ref.name];
+					if (!target) throw new AlephaError(`Referenced column ${ref.name} not found in table ${ref.entity.name} for ${tableName}.${key}`);
+					return target;
+				}, config.actions);
 			}
-			await this.alepha.events.emit("repository:create:after", {
-				tableName: this.tableName,
-				data: values,
-				entity: allEntities
-			});
-			return allEntities;
-		} catch (error) {
-			throw this.handleError(error, "Insert query has failed");
+			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) => t.schema.isNull(it))) value = value.anyOf.find((it) => !t.schema.isNull(it));
+		if (t.schema.isInteger(value)) {
+			if (PG_SERIAL in value || PG_IDENTITY in value) return pg$1.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
+			return pg$1.integer(key);
 		}
-	}
-	/**
-	* 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");
+		if (t.schema.isBigInt(value)) {
+			if (PG_PRIMARY_KEY in value || PG_IDENTITY in value) return pg$1.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
+			return pg$1.integer(key, { mode: "number" });
 		}
-	}
-	/**
-	* 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 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;
+		if (t.schema.isNumber(value)) {
+			if (PG_IDENTITY in value) return pg$1.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
+			return pg$1.numeric(key);
 		}
-		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");
+		if (t.schema.isString(value)) return this.mapStringToSqliteColumn(key, value);
+		if (t.schema.isBoolean(value)) return this.sqliteBool(key, value);
+		if (t.schema.isObject(value)) return this.sqliteJson(key, value);
+		if (t.schema.isRecord(value)) return this.sqliteJson(key, value);
+		if (t.schema.isAny(value)) return this.sqliteJson(key, value);
+		if (t.schema.isArray(value)) {
+			if (t.schema.isObject(value.items)) return this.sqliteJson(key, value);
+			if (t.schema.isRecord(value.items)) return this.sqliteJson(key, value);
+			if (t.schema.isAny(value.items)) return this.sqliteJson(key, value);
+			if (t.schema.isString(value.items)) return this.sqliteJson(key, value);
+			if (t.schema.isInteger(value.items)) return this.sqliteJson(key, value);
+			if (t.schema.isNumber(value.items)) return this.sqliteJson(key, value);
+			if (t.schema.isBoolean(value.items)) return this.sqliteJson(key, value);
 		}
-	}
-	/**
-	* 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);
+		if (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 pg$1.text(key).primaryKey().$defaultFn(() => randomUUID());
+			return pg$1.text(key);
 		}
-	}
-	/**
-	* 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 AlephaError("Cannot destroy entity without ID");
-		const deletedAt = this.deletedAt();
-		if (deletedAt && !opts.force) {
-			opts.now ??= this.dateTimeProvider.nowISOString();
-			entity[deletedAt.key] = opts.now;
+		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(sql$1`(unixepoch('subsec') * 1000)`);
+			if (PG_UPDATED_AT in value) return this.sqliteDateTime(key, {}).default(sql$1`(unixepoch('subsec') * 1000)`);
+			return this.sqliteDateTime(key, {});
 		}
-		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 : 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 (t.schema.isDateTime(value)) row[key] = this.dateTimeProvider.of(row[key]).toISOString();
-				else if (t.schema.isDate(value)) row[key] = this.dateTimeProvider.of(`${row[key]}T00:00:00Z`).toISOString().split("T")[0];
-			}
-			if (typeof row[key] === "bigint" && t.schema.isBigInt(value)) row[key] = row[key].toString();
+		if (value.format === "date") return this.sqliteDate(key, {});
+		return pg$1.text(key);
+	};
+	sqliteJson = (name, document) => pg$1.customType({
+		dataType: () => "text",
+		toDriver: (value) => JSON.stringify(value),
+		fromDriver: (value) => {
+			return value && typeof value === "string" ? JSON.parse(value) : value;
 		}
-		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];
+	})(name, { document }).$type();
+	sqliteDateTime = pg$1.customType({
+		dataType: () => "integer",
+		toDriver: (value) => new Date(value).getTime(),
+		fromDriver: (value) => {
+			return new Date(value).toISOString();
 		}
-		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;
+	});
+	sqliteBool = pg$1.customType({
+		dataType: () => "integer",
+		toDriver: (value) => value ? 1 : 0,
+		fromDriver: (value) => value === 1
+	});
+	sqliteDate = pg$1.customType({
+		dataType: () => "integer",
+		toDriver: (value) => new Date(value).getTime(),
+		fromDriver: (value) => {
+			return new Date(value).toISOString().split("T")[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: 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 AlephaError("Primary key not found in schema");
-		if (primaryKeys.length > 1) throw new 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 = $inject(Alepha);
-	registry = /* @__PURE__ */ new Map();
-	getRepositories(provider) {
-		const repositories = this.alepha.services(Repository);
-		if (provider) return repositories.filter((it) => it.provider === provider);
-		return repositories;
+//#region ../../src/orm/providers/drivers/BunSqliteProvider.ts
+const envSchema$3 = t.object({ DATABASE_URL: t.optional(t.text()) });
+/**
+* Configuration options for the Bun SQLite database provider.
+*/
+const bunSqliteOptions = $atom({
+	name: "alepha.postgres.bun-sqlite.options",
+	schema: t.object({ path: t.optional(t.string({ description: "Filepath or :memory:. If empty, provider will use DATABASE_URL from env." })) }),
+	default: {}
+});
+/**
+* Bun SQLite provider using Drizzle ORM with Bun's native SQLite client.
+*
+* This provider uses Bun's built-in `bun:sqlite` for SQLite connections,
+* which provides excellent performance on the Bun runtime.
+*
+* @example
+* ```ts
+* // Set DATABASE_URL environment variable
+* // DATABASE_URL=sqlite://./my-database.db
+*
+* // Or configure programmatically
+* alepha.with({
+*   provide: DatabaseProvider,
+*   use: BunSqliteProvider,
+* });
+*
+* // Or use options atom
+* alepha.store.mut(bunSqliteOptions, (old) => ({
+*   ...old,
+*   path: ":memory:",
+* }));
+* ```
+*/
+var BunSqliteProvider = class extends DatabaseProvider {
+	kit = $inject(DrizzleKitProvider);
+	log = $logger();
+	env = $env(envSchema$3);
+	builder = $inject(SqliteModelBuilder);
+	options = $use(bunSqliteOptions);
+	sqlite;
+	bunDb;
+	get name() {
+		return "sqlite";
 	}
-	getRepository(entity) {
-		const RepositoryClass = this.createClassRepository(entity);
-		return this.alepha.inject(RepositoryClass);
+	dialect = "sqlite";
+	get url() {
+		const path = this.options.path ?? this.env.DATABASE_URL;
+		if (path) {
+			if (path.startsWith("postgres://")) throw new AlephaError("Postgres URL is not supported for SQLite provider.");
+			return path;
+		}
+		if (this.alepha.isTest() || this.alepha.isServerless()) return ":memory:";
+		else return "node_modules/.alepha/bun-sqlite.db";
 	}
-	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);
+	get db() {
+		if (!this.bunDb) throw new AlephaError("Database not initialized");
+		return this.bunDb;
+	}
+	async execute(query) {
+		return this.bunDb.all(query);
+	}
+	onStart = $hook({
+		on: "start",
+		handler: async () => {
+			if (typeof Bun === "undefined") throw new AlephaError("BunSqliteProvider requires the Bun runtime. Use NodeSqliteProvider for Node.js.");
+			const { Database } = await import("bun:sqlite");
+			const { drizzle: drizzle$3 } = await import("drizzle-orm/bun-sqlite");
+			const filepath = this.url.replace("sqlite://", "").replace("sqlite:", "");
+			if (filepath !== ":memory:" && filepath !== "") {
+				const dirname = filepath.split("/").slice(0, -1).join("/");
+				if (dirname) await mkdir(dirname, { recursive: true }).catch(() => null);
+			}
+			this.sqlite = new Database(filepath);
+			this.bunDb = drizzle$3({
+				client: this.sqlite,
+				logger: { logQuery: (query, params) => {
+					this.log.trace(query, { params });
+				} }
+			});
+			await this.migrate();
+			this.log.info(`Using Bun SQLite database at ${filepath}`);
+		}
+	});
+	onStop = $hook({
+		on: "stop",
+		handler: async () => {
+			if (this.sqlite) {
+				this.log.debug("Closing Bun SQLite connection...");
+				this.sqlite.close();
+				this.sqlite = void 0;
+				this.bunDb = void 0;
+				this.log.info("Bun SQLite connection closed");
 			}
 		}
-		Object.defineProperty(GenericRepository, "name", { value: name });
-		this.registry.set(entity, GenericRepository);
-		return GenericRepository;
+	});
+	async executeMigrations(migrationsFolder) {
+		const { migrate: migrate$3 } = await import("drizzle-orm/bun-sqlite/migrator");
+		await migrate$3(this.bunDb, { migrationsFolder });
 	}
 };
 
 //#endregion
-//#region ../../src/orm/primitives/$repository.ts
-/**
-* Get the repository for the given entity.
-*/
-const $repository = (entity) => {
-	const { alepha } = $context();
-	return $inject(alepha.inject(RepositoryProvider).createClassRepository(entity));
-};
-
-//#endregion
-//#region ../../src/orm/primitives/$sequence.ts
+//#region ../../src/orm/providers/drivers/CloudflareD1Provider.ts
 /**
-* Creates a PostgreSQL sequence primitive for generating unique numeric values.
+* Cloudflare D1 SQLite provider using Drizzle ORM.
+*
+* This provider requires a D1 binding to be set via `cloudflareD1Options` before starting.
+* The binding is typically obtained from the Cloudflare Workers environment.
+*
+* @example
+* ```ts
+* // In your Cloudflare Worker
+* alepha.set(cloudflareD1Options, { binding: env.DB });
+* ```
 */
-const $sequence = (options = {}) => {
-	return createPrimitive(SequencePrimitive, options);
-};
-var SequencePrimitive = class extends Primitive {
-	provider = this.$provider();
-	onInit() {
-		this.provider.registerSequence(this);
-	}
+var CloudflareD1Provider = class extends DatabaseProvider {
+	kit = $inject(DrizzleKitProvider);
+	log = $logger();
+	builder = $inject(SqliteModelBuilder);
+	env = $env(t.object({ DATABASE_URL: t.string({ description: "Expect to be 'cloudflare-d1://name:id'" }) }));
+	d1;
+	drizzleDb;
 	get name() {
-		return this.options.name ?? this.config.propertyKey;
+		return "sqlite";
 	}
-	async next() {
-		return this.provider.execute(sql$1`SELECT nextval('${sql$1.raw(this.provider.schema)}."${sql$1.raw(this.name)}"')`).then((rows) => Number(rows[0]?.nextval));
+	get driver() {
+		return "d1";
 	}
-	async current() {
-		return this.provider.execute(sql$1`SELECT last_value FROM ${sql$1.raw(this.provider.schema)}."${sql$1.raw(this.name)}"`).then((rows) => Number(rows[0]?.last_value));
+	dialect = "sqlite";
+	get url() {
+		return this.env.DATABASE_URL;
 	}
-	$provider() {
-		return this.options.provider ?? this.alepha.inject(DatabaseProvider);
+	get db() {
+		if (!this.drizzleDb) throw new AlephaError("D1 database not initialized");
+		return this.drizzleDb;
+	}
+	async execute(query) {
+		const { rows } = await this.db.run(query);
+		return rows;
+	}
+	onStart = $hook({
+		on: "start",
+		handler: async () => {
+			const [bindingName] = this.env.DATABASE_URL.replace("cloudflare-d1://", "").split(":");
+			const cloudflareEnv = this.alepha.store.get("cloudflare.env");
+			if (!cloudflareEnv) throw new AlephaError("Cloudflare Workers environment not found in Alepha store under 'cloudflare.env'.");
+			const binding = cloudflareEnv[bindingName];
+			if (!binding) throw new AlephaError(`D1 binding '${bindingName}' not found in Cloudflare Workers environment.`);
+			this.d1 = binding;
+			const { drizzle: drizzle$3 } = await import("drizzle-orm/d1");
+			this.drizzleDb = drizzle$3(this.d1);
+			await this.migrate();
+			this.log.info("Using Cloudflare D1 database");
+		}
+	});
+	async executeMigrations(migrationsFolder) {
+		const { migrate: migrate$3 } = await import("drizzle-orm/d1/migrator");
+		await migrate$3(this.db, { migrationsFolder });
+	}
+	/**
+	* Override development migration to skip sync (not supported on D1).
+	* D1 requires proper migrations to be applied.
+	*/
+	async runDevelopmentMigration(migrationsFolder) {
+		await this.executeMigrations(migrationsFolder);
+	}
+	/**
+	* Override test migration to run migrations instead of sync.
+	* D1 doesn't support schema synchronization.
+	*/
+	async runTestMigration() {
+		const migrationsFolder = this.getMigrationsFolder();
+		try {
+			await this.executeMigrations(migrationsFolder);
+		} catch {
+			this.log.warn("D1 migrations failed in test environment - ensure migrations exist");
+		}
 	}
 };
-$sequence[KIND] = SequencePrimitive;
 
 //#endregion
-//#region ../../src/orm/providers/DrizzleKitProvider.ts
-var DrizzleKitProvider = class {
+//#region ../../src/orm/providers/drivers/NodePostgresProvider.ts
+const envSchema$2 = t.object({
+	DATABASE_URL: t.optional(t.text()),
+	POSTGRES_SCHEMA: t.optional(t.text())
+});
+var NodePostgresProvider = class NodePostgresProvider extends DatabaseProvider {
+	static SSL_MODES = [
+		"require",
+		"allow",
+		"prefer",
+		"verify-full"
+	];
 	log = $logger();
-	alepha = $inject(Alepha);
+	env = $env(envSchema$2);
+	kit = $inject(DrizzleKitProvider);
+	builder = $inject(PostgresModelBuilder);
+	client;
+	pg;
+	dialect = "postgresql";
+	get name() {
+		return "postgres";
+	}
 	/**
-	* 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.
+	* In testing mode, the schema name will be generated and deleted after the test.
 	*/
-	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]`);
+	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 AlephaError("DATABASE_URL is not defined in the environment");
+		return this.env.DATABASE_URL;
 	}
 	/**
-	* Mostly used for testing purposes. You can generate SQL migration statements without executing them.
+	* Execute a SQL statement.
 	*/
-	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
-			};
+	execute(statement) {
+		try {
+			return this.db.execute(statement);
+		} catch (error) {
+			throw new DbError("Error executing statement", error);
 		}
-		return {
-			models,
-			statements: [],
-			snapshot: {}
-		};
 	}
 	/**
-	* Load all tables, enums, sequences, etc. from the provider's repositories.
+	* Get Postgres schema used by this provider.
 	*/
-	getModels(provider) {
-		const models = {};
-		for (const [key, value] of provider.tables.entries()) {
-			if (models[key]) throw new AlephaError(`Model name conflict: '${key}' is already defined.`);
-			models[key] = value;
+	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 AlephaError("Database not initialized");
+		return this.pg;
+	}
+	async executeMigrations(migrationsFolder) {
+		await migrate(this.db, { migrationsFolder });
+	}
+	onStart = $hook({
+		on: "start",
+		handler: async () => {
+			await this.connect();
+			if (!this.alepha.isServerless()) try {
+				await this.migrateLock.run();
+			} catch (error) {
+				throw new DbMigrationError(error);
+			}
 		}
-		for (const [key, value] of provider.enums.entries()) {
-			if (models[key]) throw new AlephaError(`Model name conflict: '${key}' is already defined.`);
-			models[key] = value;
+	});
+	onStop = $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 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(sql$1`DROP SCHEMA IF EXISTS ${sql$1.raw(this.schemaForTesting)} CASCADE`);
+				this.log.info(`Test schema '${this.schemaForTesting}' deleted`);
+			}
+			await this.close();
 		}
-		for (const [key, value] of provider.sequences.entries()) {
-			if (models[key]) throw new AlephaError(`Model name conflict: '${key}' is already defined.`);
-			models[key] = value;
+	});
+	async connect() {
+		this.log.debug("Connect ..");
+		const client = postgres(this.getClientOptions());
+		await client`SELECT 1`;
+		this.client = client;
+		this.pg = drizzle$1(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");
 		}
-		return models;
 	}
+	migrateLock = $lock({ handler: async () => {
+		await this.migrate();
+	} });
 	/**
-	* Load the migration snapshot from the database.
+	* Map the DATABASE_URL to postgres client options.
 	*/
-	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;
+	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;
+	}
+};
+
+//#endregion
+//#region ../../src/orm/providers/drivers/NodeSqliteProvider.ts
+const envSchema$1 = t.object({ DATABASE_URL: t.optional(t.text()) });
+/**
+* Configuration options for the Node.js SQLite database provider.
+*/
+const nodeSqliteOptions = $atom({
+	name: "alepha.postgres.node-sqlite.options",
+	schema: t.object({ path: t.optional(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 = $inject(DrizzleKitProvider);
+	log = $logger();
+	env = $env(envSchema$1);
+	builder = $inject(SqliteModelBuilder);
+	options = $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 AlephaError("Postgres URL is not supported for SQLite provider.");
+			return path;
 		}
-		if (provider.dialect === "sqlite") {
-			try {
-				const text = await 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;
+		if (this.alepha.isTest() || this.alepha.isServerless()) return ":memory:";
+		else return "node_modules/.alepha/sqlite.db";
+	}
+	async execute(query) {
+		const { sql: sql$2, params, method } = this.db.all(query).getQuery();
+		this.log.trace(`${sql$2}`, params);
+		const statement = this.sqlite.prepare(sql$2);
+		if (method === "run") {
+			statement.run(...params);
+			return [];
 		}
-		await provider.execute(sql$1`CREATE SCHEMA IF NOT EXISTS "drizzle";`);
-		await provider.execute(sql$1`
-					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(sql$1`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;
+		if (method === "get") {
+			const data = statement.get(...params);
+			return data ? [{ ...data }] : [];
 		}
-		return this.alepha.codec.decode(devMigrationsSchema, rows[0]);
+		return statement.all(...params);
 	}
-	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 mkdir("node_modules/.alepha", { recursive: true }).catch(() => null);
-			await 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;
+	db = drizzle$2(async (sql$2, params, method) => {
+		const statement = this.sqlite.prepare(sql$2);
+		this.log.trace(`${sql$2}`, { params });
+		if (method === "get") {
+			const data = statement.get(...params);
+			return { rows: data ? [{ ...data }] : [] };
 		}
-		if (!devMigrations) await provider.execute(sql$1`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(sql$1`UPDATE "drizzle"."__drizzle_dev_migrations" SET "snapshot" = ${newSnapshot} WHERE "id" = ${devMigrations.id}`);
+		if (method === "run") {
+			statement.run(...params);
+			return { rows: [] };
 		}
-	}
-	async executeStatements(statements, provider, catchErrors = false) {
-		let nErrors = 0;
-		for (const statement of statements) {
-			if (statement.startsWith("DROP SCHEMA")) continue;
-			try {
-				await provider.execute(sql$1.raw(statement));
-			} catch (error) {
-				const errorMessage = `Error executing statement: ${statement}`;
-				if (catchErrors) {
-					nErrors++;
-					this.log.warn(errorMessage, { context: [error] });
-				} else throw error;
+		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 AlephaError(`Unsupported method: ${method}`);
+	});
+	onStart = $hook({
+		on: "start",
+		handler: async () => {
+			const { DatabaseSync } = await import("node:sqlite");
+			const filepath = this.url.replace("sqlite://", "").replace("sqlite:", "");
+			if (filepath !== ":memory:" && filepath !== "") {
+				const dirname = filepath.split("/").slice(0, -1).join("/");
+				if (dirname) await mkdir(dirname, { recursive: true }).catch(() => null);
 			}
+			this.sqlite = new DatabaseSync(filepath);
+			await this.migrate();
+			this.log.info(`Using SQLite database at ${filepath}`);
 		}
-		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 = sql$1.raw(schemaName);
-		if (schemaName.startsWith("test_")) {
-			this.log.info(`Drop test schema '${schemaName}' ...`, schemaName);
-			await provider.execute(sql$1`DROP SCHEMA IF EXISTS ${sqlSchema} CASCADE`);
-		}
-		this.log.debug(`Ensuring schema '${schemaName}' exists`);
-		await provider.execute(sql$1`CREATE SCHEMA IF NOT EXISTS ${sqlSchema}`);
+	});
+	async executeMigrations(migrationsFolder) {
+		await migrate$1(this.db, async (migrationQueries) => {
+			this.log.debug("Executing migration queries", { migrationQueries });
+			for (const query of migrationQueries) this.sqlite.prepare(query).run();
+		}, { migrationsFolder });
 	}
-	/**
-	* Try to load the official Drizzle Kit API.
-	* If not available, fallback to the local kit import.
-	*/
-	importDrizzleKit() {
+};
+
+//#endregion
+//#region ../../src/orm/providers/drivers/PglitePostgresProvider.ts
+const envSchema = t.object({ DATABASE_URL: t.optional(t.text()) });
+var PglitePostgresProvider = class PglitePostgresProvider extends DatabaseProvider {
+	static importPglite() {
 		try {
-			return createRequire(import.meta.url)("drizzle-kit/api");
-		} catch (_) {
-			throw new Error("Drizzle Kit is not installed. Please install it with `npm install -D drizzle-kit`.");
+			return createRequire(import.meta.url)("@electric-sql/pglite");
+		} catch {}
+	}
+	env = $env(envSchema);
+	log = $logger();
+	kit = $inject(DrizzleKitProvider);
+	builder = $inject(PostgresModelBuilder);
+	client;
+	pglite;
+	get name() {
+		return "postgres";
+	}
+	get driver() {
+		return "pglite";
+	}
+	dialect = "postgresql";
+	get url() {
+		let path = this.env.DATABASE_URL;
+		if (!path) if (this.alepha.isTest()) path = ":memory:";
+		else path = "node_modules/.alepha/pglite";
+		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 AlephaError("Database not initialized");
+		return this.pglite;
+	}
+	async execute(statement) {
+		const { rows } = await this.db.execute(statement);
+		return rows;
+	}
+	onStart = $hook({
+		on: "start",
+		handler: async () => {
+			if (Object.keys(this.kit.getModels(this)).length === 0) return;
+			const module = PglitePostgresProvider.importPglite();
+			if (!module) throw new AlephaError("@electric-sql/pglite is not installed. Please install it to use the pglite driver.");
+			const { drizzle: drizzle$3 } = createRequire(import.meta.url)("drizzle-orm/pglite");
+			const path = this.url;
+			if (path !== ":memory:") {
+				await mkdir(path, { recursive: true }).catch(() => null);
+				this.client = new module.PGlite(path);
+			} else this.client = new module.PGlite();
+			this.pglite = drizzle$3({ client: this.client });
+			await this.migrate();
+			this.log.info(`Using PGlite database at ${path}`);
+		}
+	});
+	onStop = $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 migrate$2(this.db, { migrationsFolder });
 	}
 };
-const devMigrationsSchema = t.object({
-	id: t.number(),
-	name: t.text(),
-	snapshot: t.string(),
-	created_at: t.string()
-});
 
 //#endregion
-//#region ../../src/orm/errors/DbMigrationError.ts
-var DbMigrationError = class extends DbError {
-	name = "DbMigrationError";
-	constructor(cause) {
-		super("Failed to migrate database", cause);
+//#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/types/byte.ts
+//#region ../../src/orm/errors/DbVersionMismatchError.ts
 /**
-* Postgres bytea type.
+* 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.
 */
-const byte = customType({ dataType: () => "bytea" });
+var DbVersionMismatchError = class extends DbError {
+	name = "DbVersionMismatchError";
+	constructor(table, id) {
+		super(`Version mismatch for table '${table}' and id '${id}'`);
+	}
+};
 
 //#endregion
-//#region ../../src/orm/services/ModelBuilder.ts
+//#region ../../src/orm/helpers/pgAttr.ts
 /**
-* Abstract base class for transforming Alepha Primitives (Entity, Sequence, etc...)
-* into drizzle models (tables, enums, sequences, etc...).
+* 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,
+* );
+* ```
 */
-var ModelBuilder = class {
+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/services/PgRelationManager.ts
+var PgRelationManager = class {
 	/**
-	* Convert camelCase to snake_case for column names.
+	* Recursively build joins for the query builder based on the relations map
 	*/
-	toColumnName(str) {
-		return str[0].toLowerCase() + str.slice(1).replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+	buildJoins(provider, builder, joins, withRelations, table, parentKey) {
+		for (const [key, join] of Object.entries(withRelations)) {
+			const from = provider.table(join.join);
+			const on = isSQLWrapper$1(join.on) ? join.on : sql$1`${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: 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);
+		}
 	}
 	/**
-	* Build the table configuration function for any database.
-	* This includes indexes, foreign keys, constraints, and custom config.
-	*
-	* @param entity - The entity primitive
-	* @param builders - Database-specific builder functions
-	* @param tableResolver - Function to resolve entity references to table columns
-	* @param customConfigHandler - Optional handler for custom config
+	* Map a row with its joined relations based on the joins definition
 	*/
-	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));
+	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 = Value.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] = t.optional(joinSchema);
+		}
+		return schema$1;
+	}
+};
+
+//#endregion
+//#region ../../src/orm/services/QueryManager.ts
+var QueryManager = class {
+	alepha = $inject(Alepha);
+	/**
+	* Convert a query object to a SQL query.
+	*/
+	toSQL(query, options) {
+		const { schema: schema$1, col, joins } = options;
+		const conditions = [];
+		if (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$2 = this.toSQL(query[key], {
+							schema: join.schema,
+							col: join.col,
+							joins: recursiveJoins.length > 0 ? recursiveJoins : void 0,
+							dialect: options.dialect
+						});
+						if (sql$2) conditions.push(sql$2);
+						continue;
 					}
 				}
-			}
-			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 (Array.isArray(operator)) {
+					const operations = operator.map((it) => {
+						if (isSQLWrapper(it)) return it;
+						return this.toSQL(it, {
+							schema: schema$1,
+							col,
+							joins,
+							dialect: options.dialect
+						});
+					}).filter((it) => it != null);
+					if (key === "and") return and(...operations);
+					if (key === "or") return or(...operations);
 				}
-			}
-			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 (key === "not") {
+					const where = this.toSQL(operator, {
+						schema: schema$1,
+						col,
+						joins,
+						dialect: options.dialect
+					});
+					if (where) return not(where);
+				}
+				if (operator) {
+					const column = col(key);
+					const sql$2 = this.mapOperatorToSql(operator, column, schema$1, key, options.dialect);
+					if (sql$2) conditions.push(sql$2);
 				}
 			}
-			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, pgSchema(name));
-		const nsp = name !== "public" ? this.schemas.get(name) : {
-			enum: pgEnum,
-			table: pgTable
-		};
-		if (!nsp) throw new 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);
+		}
+		if (conditions.length === 1) return conditions[0];
+		return and(...conditions);
 	}
-	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));
+	/**
+	* 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);
 	}
 	/**
-	* Get PostgreSQL-specific config builder for the table.
+	* Map a filter operator to a SQL query.
 	*/
-	getTableConfig(entity, tables) {
-		const pgBuilders = {
-			index,
-			uniqueIndex,
-			unique,
-			check,
-			foreignKey
+	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 tableResolver = (entityName) => {
-			return tables.get(entityName);
+		const encodeArray = (values) => {
+			return values.map((v) => encodeValue(v));
 		};
-		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 AlephaError(`Referenced table ${ref.entity.name} not found for ${tableName}.${key}`);
-					const target = table[ref.name];
-					if (!target) throw new 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) => t.schema.isNull(it))) value = value.anyOf.find((it) => !t.schema.isNull(it));
-		if (t.schema.isInteger(value)) {
-			if (PG_SERIAL in value) return pg$2.serial(key);
-			if (PG_IDENTITY in value) {
-				const options = value[PG_IDENTITY];
-				if (options.mode === "byDefault") return pg$2.integer().generatedByDefaultAsIdentity(options);
-				return pg$2.integer().generatedAlwaysAsIdentity(options);
-			}
-			return pg$2.integer(key);
+		if (typeof operator !== "object" || operator == null || !this.hasFilterOperatorProperties(operator)) return eq(column, encodeValue(operator));
+		const conditions = [];
+		if (operator?.eq != null) conditions.push(eq(column, encodeValue(operator.eq)));
+		if (operator?.ne != null) conditions.push(ne(column, encodeValue(operator.ne)));
+		if (operator?.gt != null) conditions.push(gt(column, encodeValue(operator.gt)));
+		if (operator?.gte != null) conditions.push(gte(column, encodeValue(operator.gte)));
+		if (operator?.lt != null) conditions.push(lt(column, encodeValue(operator.lt)));
+		if (operator?.lte != null) conditions.push(lte(column, encodeValue(operator.lte)));
+		if (operator?.inArray != null) {
+			if (!Array.isArray(operator.inArray) || operator.inArray.length === 0) throw new AlephaError("inArray operator requires at least one value");
+			conditions.push(inArray(column, encodeArray(operator.inArray)));
 		}
-		if (t.schema.isBigInt(value)) {
-			if (PG_IDENTITY in value) {
-				const options = value[PG_IDENTITY];
-				if (options.mode === "byDefault") return pg$2.bigint({ mode: "bigint" }).generatedByDefaultAsIdentity(options);
-				return pg$2.bigint({ mode: "bigint" }).generatedAlwaysAsIdentity(options);
-			}
+		if (operator?.notInArray != null) {
+			if (!Array.isArray(operator.notInArray) || operator.notInArray.length === 0) throw new AlephaError("notInArray operator requires at least one value");
+			conditions.push(notInArray(column, encodeArray(operator.notInArray)));
 		}
-		if (t.schema.isNumber(value)) {
-			if (PG_IDENTITY in value) {
-				const options = value[PG_IDENTITY];
-				if (options.mode === "byDefault") return pg$2.bigint({ mode: "number" }).generatedByDefaultAsIdentity(options);
-				return pg$2.bigint({ mode: "number" }).generatedAlwaysAsIdentity(options);
-			}
-			if (value.format === "int64") return pg$2.bigint(key, { mode: "number" });
-			return pg$2.numeric(key);
+		if (operator?.isNull != null) conditions.push(isNull(column));
+		if (operator?.isNotNull != null) conditions.push(isNotNull(column));
+		if (operator?.like != null) conditions.push(like(column, encodeValue(operator.like)));
+		if (operator?.notLike != null) conditions.push(notLike(column, encodeValue(operator.notLike)));
+		if (operator?.ilike != null) conditions.push(ilike(column, encodeValue(operator.ilike)));
+		if (operator?.notIlike != null) conditions.push(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(sql$1`LOWER(${column}) LIKE LOWER(${encodeValue(`%${escapedValue}%`)})`);
+			else conditions.push(ilike(column, encodeValue(`%${escapedValue}%`)));
 		}
-		if (t.schema.isString(value)) return this.mapStringToColumn(key, value);
-		if (t.schema.isBoolean(value)) return pg$2.boolean(key);
-		if (t.schema.isObject(value)) return schema(key, value);
-		if (t.schema.isRecord(value)) return schema(key, value);
-		const isTypeEnum = (value$1) => t.schema.isUnsafe(value$1) && "type" in value$1 && value$1.type === "string" && "enum" in value$1 && Array.isArray(value$1.enum);
-		if (t.schema.isArray(value)) {
-			if (t.schema.isObject(value.items)) return schema(key, value);
-			if (t.schema.isRecord(value.items)) return schema(key, value);
-			if (t.schema.isString(value.items)) return pg$2.text(key).array();
-			if (t.schema.isInteger(value.items)) return pg$2.integer(key).array();
-			if (t.schema.isNumber(value.items)) return pg$2.numeric(key).array();
-			if (t.schema.isBoolean(value.items)) return pg$2.boolean(key).array();
-			if (isTypeEnum(value.items)) return pg$2.text(key).array();
+		if (operator?.startsWith != null) {
+			const escapedValue = String(operator.startsWith).replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+			if (dialect === "sqlite") conditions.push(sql$1`LOWER(${column}) LIKE LOWER(${encodeValue(`${escapedValue}%`)})`);
+			else conditions.push(ilike(column, encodeValue(`${escapedValue}%`)));
 		}
-		if (isTypeEnum(value)) {
-			if (!value.enum.every((it) => typeof it === "string")) throw new 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 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);
+		if (operator?.endsWith != null) {
+			const escapedValue = String(operator.endsWith).replace(/\\/g, "\\\\").replace(/%/g, "\\%").replace(/_/g, "\\_");
+			if (dialect === "sqlite") conditions.push(sql$1`LOWER(${column}) LIKE LOWER(${encodeValue(`%${escapedValue}`)})`);
+			else conditions.push(ilike(column, encodeValue(`%${escapedValue}`)));
 		}
-		throw new AlephaError(`Unsupported schema type for ${fieldName} as ${JSON.stringify(value)}`);
-	};
+		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(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(notBetween(column, encodeValue(operator.notBetween[0]), encodeValue(operator.notBetween[1])));
+		}
+		if (operator?.arrayContains != null) conditions.push(arrayContains(column, encodeValue(operator.arrayContains)));
+		if (operator?.arrayContained != null) conditions.push(arrayContained(column, encodeValue(operator.arrayContained)));
+		if (operator?.arrayOverlaps != null) conditions.push(arrayOverlaps(column, encodeValue(operator.arrayOverlaps)));
+		if (conditions.length === 0) return;
+		if (conditions.length === 1) return conditions[0];
+		return 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 [];
+	}
 	/**
-	* Map a string to a PG column.
+	* Create a pagination object.
 	*
-	* @param key The key of the field.
-	* @param value The value of the field.
+	* @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.
 	*/
-	mapStringToColumn = (key, value) => {
-		if ("format" in value) {
-			if (value.format === "uuid") {
-				if (PG_PRIMARY_KEY in value) return pg$2.uuid(key).defaultRandom();
-				return pg$2.uuid(key);
-			}
-			if (value.format === "byte") return byte(key);
-			if (value.format === "date-time") {
-				if (PG_CREATED_AT in value) return pg$2.timestamp(key, {
-					mode: "string",
-					withTimezone: true
-				}).defaultNow();
-				if (PG_UPDATED_AT in value) return pg$2.timestamp(key, {
-					mode: "string",
-					withTimezone: true
-				}).defaultNow();
-				return pg$2.timestamp(key, {
-					mode: "string",
-					withTimezone: true
-				});
-			}
-			if (value.format === "date") return pg$2.date(key, { mode: "string" });
-		}
-		return pg$2.text(key);
-	};
+	createPagination(entities, limit = 10, offset = 0, sort) {
+		return createPagination(entities, limit, offset, sort);
+	}
 };
 
 //#endregion
-//#region ../../src/orm/providers/drivers/BunPostgresProvider.ts
-const envSchema$4 = t.object({
-	DATABASE_URL: t.optional(t.text()),
-	POSTGRES_SCHEMA: t.optional(t.text())
-});
-/**
-* Bun PostgreSQL provider using Drizzle ORM with Bun's native SQL client.
-*
-* This provider uses Bun's built-in SQL class for PostgreSQL connections,
-* which provides excellent performance on the Bun runtime.
-*
-* @example
-* ```ts
-* // Set DATABASE_URL environment variable
-* // DATABASE_URL=postgres://user:password@localhost:5432/database
-*
-* // Or configure programmatically
-* alepha.with({
-*   provide: DatabaseProvider,
-*   use: BunPostgresProvider,
-* });
-* ```
-*/
-var BunPostgresProvider = class extends DatabaseProvider {
+//#region ../../src/orm/services/Repository.ts
+var Repository = class {
+	entity;
+	provider;
 	log = $logger();
-	env = $env(envSchema$4);
-	kit = $inject(DrizzleKitProvider);
-	builder = $inject(PostgresModelBuilder);
-	client;
-	bunDb;
-	dialect = "postgresql";
-	get name() {
-		return "bun-postgres";
+	relationManager = $inject(PgRelationManager);
+	queryManager = $inject(QueryManager);
+	dateTimeProvider = $inject(DateTimeProvider);
+	alepha = $inject(Alepha);
+	constructor(entity, provider = DatabaseProvider) {
+		this.entity = entity;
+		this.provider = this.alepha.inject(provider);
+		this.provider.registerEntity(entity);
 	}
 	/**
-	* In testing mode, the schema name will be generated and deleted after the test.
+	* 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.
 	*/
-	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 AlephaError("DATABASE_URL is not defined in the environment");
-		return this.env.DATABASE_URL;
+	get id() {
+		return this.getPrimaryKey(this.entity.schema);
 	}
 	/**
-	* Execute a SQL statement.
+	* Get Drizzle table object.
 	*/
-	execute(statement) {
-		try {
-			return this.db.execute(statement);
-		} catch (error) {
-			throw new DbError("Error executing statement", error);
-		}
+	get table() {
+		return this.provider.table(this.entity);
 	}
 	/**
-	* Get Postgres schema used by this provider.
+	* Get SQL table name. (from Drizzle table object)
 	*/
-	get schema() {
-		if (this.schemaForTesting) return this.schemaForTesting;
-		if (this.env.POSTGRES_SCHEMA) return this.env.POSTGRES_SCHEMA;
-		return "public";
+	get tableName() {
+		return this.entity.name;
 	}
 	/**
-	* Get the Drizzle Postgres database instance.
+	* Getter for the database connection from the database provider.
 	*/
 	get db() {
-		if (!this.bunDb) throw new AlephaError("Database not initialized");
-		return this.bunDb;
+		return this.provider.db;
 	}
-	async executeMigrations(migrationsFolder) {
-		const { migrate: migrate$3 } = await import("drizzle-orm/bun-sql/migrator");
-		await migrate$3(this.bunDb, { migrationsFolder });
+	/**
+	* 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 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);
+		});
 	}
-	onStart = $hook({
-		on: "start",
-		handler: async () => {
-			await this.connect();
-			if (!this.alepha.isServerless()) try {
-				await this.migrateLock.run();
-			} catch (error) {
-				throw new DbMigrationError(error);
-			}
-		}
-	});
-	onStop = $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 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(sql$1`DROP SCHEMA IF EXISTS ${sql$1.raw(this.schemaForTesting)} CASCADE`);
-				this.log.info(`Test schema '${this.schemaForTesting}' deleted`);
+	/**
+	* 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;
 			}
-			await this.close();
 		}
-	});
-	async connect() {
-		this.log.debug("Connect ..");
-		if (typeof Bun === "undefined") throw new AlephaError("BunPostgresProvider requires the Bun runtime. Use NodePostgresProvider for Node.js.");
-		const { drizzle: drizzle$3 } = await import("drizzle-orm/bun-sql");
-		const { SQL: SQL$1 } = await import("bun");
-		this.client = new SQL$1(this.url);
-		await this.client.unsafe("SELECT 1");
-		this.bunDb = drizzle$3({
-			client: this.client,
-			logger: { logQuery: (query, params) => {
-				this.log.trace(query, { params });
-			} }
-		});
-		this.log.info("Connection OK");
+		return entity;
 	}
-	async close() {
-		if (this.client) {
-			this.log.debug("Close...");
-			await this.client.close();
-			this.client = void 0;
-			this.bunDb = void 0;
-			this.log.info("Connection closed");
+	/**
+	* Get a Drizzle column from the table by his name.
+	*/
+	col(name) {
+		const column = this.table[name];
+		if (!column) throw new AlephaError(`Invalid access. Column ${String(name)} not found in table ${this.tableName}`);
+		return column;
+	}
+	/**
+	* Run a transaction.
+	*/
+	async transaction(transaction, config) {
+		if (this.provider.driver === "pglite") {
+			this.log.warn("Transactions are not supported with pglite driver");
+			return await transaction(null);
 		}
+		this.log.debug(`Starting transaction on table ${this.tableName}`);
+		return await this.db.transaction(transaction, config);
 	}
-	migrateLock = $lock({ handler: async () => {
-		await this.migrate();
-	} });
-};
-
-//#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 = sqliteTable(tableName, this.schemaToSqliteColumns(tableName, entity.schema, options.enums, options.tables), this.getTableConfig(entity, options.tables));
-		options.tables.set(tableName, table);
+	/**
+	* 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$1 = 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$1.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);
 	}
-	buildSequence(sequence, options) {
-		throw new AlephaError("SQLite does not support sequences");
+	/**
+	* Start a DELETE query on the table.
+	*/
+	rawDelete(opts = {}) {
+		return (opts.tx ?? this.db).delete(this.table);
 	}
 	/**
-	* Get SQLite-specific config builder for the table.
+	* Create a Drizzle `select` query based on a JSON query object.
+	*
+	* > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
 	*/
-	getTableConfig(entity, tables) {
-		const sqliteBuilders = {
-			index: index$1,
-			uniqueIndex: uniqueIndex$1,
-			unique: unique$1,
-			check: check$1,
-			foreignKey: foreignKey$1
-		};
-		const tableResolver = (entityName) => {
-			return tables.get(entityName);
-		};
-		return this.buildTableConfig(entity, sqliteBuilders, tableResolver, (config, self) => {
-			const customConfigs = config(self);
-			return Array.isArray(customConfigs) ? customConfigs : [];
+	async findMany(query = {}, opts = {}) {
+		await this.alepha.events.emit("repository:read:before", {
+			tableName: this.tableName,
+			query
 		});
-	}
-	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 AlephaError(`Referenced table ${ref.entity.name} not found for ${tableName}.${key}`);
-					const target = table[ref.name];
-					if (!target) throw new 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) => t.schema.isNull(it))) value = value.anyOf.find((it) => !t.schema.isNull(it));
-		if (t.schema.isInteger(value)) {
-			if (PG_SERIAL in value || PG_IDENTITY in value) return pg$1.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
-			return pg$1.integer(key);
-		}
-		if (t.schema.isBigInt(value)) {
-			if (PG_PRIMARY_KEY in value || PG_IDENTITY in value) return pg$1.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
-			return pg$1.integer(key, { mode: "number" });
-		}
-		if (t.schema.isNumber(value)) {
-			if (PG_IDENTITY in value) return pg$1.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
-			return pg$1.numeric(key);
-		}
-		if (t.schema.isString(value)) return this.mapStringToSqliteColumn(key, value);
-		if (t.schema.isBoolean(value)) return this.sqliteBool(key, value);
-		if (t.schema.isObject(value)) return this.sqliteJson(key, value);
-		if (t.schema.isRecord(value)) return this.sqliteJson(key, value);
-		if (t.schema.isAny(value)) return this.sqliteJson(key, value);
-		if (t.schema.isArray(value)) {
-			if (t.schema.isObject(value.items)) return this.sqliteJson(key, value);
-			if (t.schema.isRecord(value.items)) return this.sqliteJson(key, value);
-			if (t.schema.isAny(value.items)) return this.sqliteJson(key, value);
-			if (t.schema.isString(value.items)) return this.sqliteJson(key, value);
-			if (t.schema.isInteger(value.items)) return this.sqliteJson(key, value);
-			if (t.schema.isNumber(value.items)) return this.sqliteJson(key, value);
-			if (t.schema.isBoolean(value.items)) return this.sqliteJson(key, value);
-		}
-		if (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 pg$1.text(key).primaryKey().$defaultFn(() => randomUUID());
-			return pg$1.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(sql$1`(unixepoch('subsec') * 1000)`);
-			if (PG_UPDATED_AT in value) return this.sqliteDateTime(key, {}).default(sql$1`(unixepoch('subsec') * 1000)`);
-			return this.sqliteDateTime(key, {});
+		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 (value.format === "date") return this.sqliteDate(key, {});
-		return pg$1.text(key);
-	};
-	sqliteJson = (name, document) => pg$1.customType({
-		dataType: () => "text",
-		toDriver: (value) => JSON.stringify(value),
-		fromDriver: (value) => {
-			return value && typeof value === "string" ? JSON.parse(value) : value;
+		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" ? desc(this.col(clause.column)) : asc(this.col(clause.column))));
 		}
-	})(name, { document }).$type();
-	sqliteDateTime = pg$1.customType({
-		dataType: () => "integer",
-		toDriver: (value) => new Date(value).getTime(),
-		fromDriver: (value) => {
-			return new Date(value).toISOString();
+		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);
 		}
-	});
-	sqliteBool = pg$1.customType({
-		dataType: () => "integer",
-		toDriver: (value) => value ? 1 : 0,
-		fromDriver: (value) => value === 1
-	});
-	sqliteDate = pg$1.customType({
-		dataType: () => "integer",
-		toDriver: (value) => new Date(value).getTime(),
-		fromDriver: (value) => {
-			return new Date(value).toISOString().split("T")[0];
+		try {
+			let rows = await builder.execute();
+			let schema$1 = this.entity.schema;
+			if (columns) schema$1 = 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);
 		}
-	});
-};
-
-//#endregion
-//#region ../../src/orm/providers/drivers/BunSqliteProvider.ts
-const envSchema$3 = t.object({ DATABASE_URL: t.optional(t.text()) });
-/**
-* Configuration options for the Bun SQLite database provider.
-*/
-const bunSqliteOptions = $atom({
-	name: "alepha.postgres.bun-sqlite.options",
-	schema: t.object({ path: t.optional(t.string({ description: "Filepath or :memory:. If empty, provider will use DATABASE_URL from env." })) }),
-	default: {}
-});
-/**
-* Bun SQLite provider using Drizzle ORM with Bun's native SQLite client.
-*
-* This provider uses Bun's built-in `bun:sqlite` for SQLite connections,
-* which provides excellent performance on the Bun runtime.
-*
-* @example
-* ```ts
-* // Set DATABASE_URL environment variable
-* // DATABASE_URL=sqlite://./my-database.db
-*
-* // Or configure programmatically
-* alepha.with({
-*   provide: DatabaseProvider,
-*   use: BunSqliteProvider,
-* });
-*
-* // Or use options atom
-* alepha.store.mut(bunSqliteOptions, (old) => ({
-*   ...old,
-*   path: ":memory:",
-* }));
-* ```
-*/
-var BunSqliteProvider = class extends DatabaseProvider {
-	kit = $inject(DrizzleKitProvider);
-	log = $logger();
-	env = $env(envSchema$3);
-	builder = $inject(SqliteModelBuilder);
-	options = $use(bunSqliteOptions);
-	sqlite;
-	bunDb;
-	get name() {
-		return "bun-sqlite";
 	}
-	dialect = "sqlite";
-	get url() {
-		const path = this.options.path ?? this.env.DATABASE_URL;
-		if (path) {
-			if (path.startsWith("postgres://")) throw new AlephaError("Postgres URL is not supported for SQLite provider.");
-			return path;
+	/**
+	* 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 = 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;
+			}));
 		}
-		if (this.alepha.isTest() || this.alepha.isServerless()) return ":memory:";
-		else return "node_modules/.alepha/bun-sqlite.db";
+		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;
 	}
-	get db() {
-		if (!this.bunDb) throw new AlephaError("Database not initialized");
-		return this.bunDb;
+	/**
+	* 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);
 	}
-	async execute(query) {
-		return this.bunDb.all(query);
+	/**
+	* Helper to create a type-safe query object.
+	*/
+	createQuery() {
+		return {};
 	}
-	onStart = $hook({
-		on: "start",
-		handler: async () => {
-			if (typeof Bun === "undefined") throw new AlephaError("BunSqliteProvider requires the Bun runtime. Use NodeSqliteProvider for Node.js.");
-			const { Database } = await import("bun:sqlite");
-			const { drizzle: drizzle$3 } = await import("drizzle-orm/bun-sqlite");
-			const filepath = this.url.replace("sqlite://", "").replace("sqlite:", "");
-			if (filepath !== ":memory:" && filepath !== "") {
-				const dirname = filepath.split("/").slice(0, -1).join("/");
-				if (dirname) await mkdir(dirname, { recursive: true }).catch(() => null);
-			}
-			this.sqlite = new Database(filepath);
-			this.bunDb = drizzle$3({
-				client: this.sqlite,
-				logger: { logQuery: (query, params) => {
-					this.log.trace(query, { params });
-				} }
+	/**
+	* 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
 			});
-			await this.migrate();
-			this.log.info(`Using Bun SQLite database at ${filepath}`);
+			return entity;
+		} catch (error) {
+			throw this.handleError(error, "Insert query has failed");
 		}
-	});
-	onStop = $hook({
-		on: "stop",
-		handler: async () => {
-			if (this.sqlite) {
-				this.log.debug("Closing Bun SQLite connection...");
-				this.sqlite.close();
-				this.sqlite = void 0;
-				this.bunDb = void 0;
-				this.log.info("Bun SQLite connection closed");
+	}
+	/**
+	* Create many entities.
+	*
+	* Inserts are batched in chunks of 1000 to avoid hitting database limits.
+	*
+	* @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
+		});
+		const batchSize = opts.batchSize ?? 1e3;
+		const allEntities = [];
+		try {
+			for (let i = 0; i < values.length; i += batchSize) {
+				const batch = values.slice(i, i + batchSize);
+				const entities = await this.rawInsert(opts).values(batch.map((data) => this.cast(data, true))).returning(this.table).then((rows) => rows.map((it) => this.clean(it, this.entity.schema)));
+				allEntities.push(...entities);
 			}
+			await this.alepha.events.emit("repository:create:after", {
+				tableName: this.tableName,
+				data: values,
+				entity: allEntities
+			});
+			return allEntities;
+		} catch (error) {
+			throw this.handleError(error, "Insert query has failed");
 		}
-	});
-	async executeMigrations(migrationsFolder) {
-		const { migrate: migrate$3 } = await import("drizzle-orm/bun-sqlite/migrator");
-		await migrate$3(this.bunDb, { migrationsFolder });
 	}
-};
-
-//#endregion
-//#region ../../src/orm/providers/drivers/CloudflareD1Provider.ts
-/**
-* Cloudflare D1 SQLite provider using Drizzle ORM.
-*
-* This provider requires a D1 binding to be set via `cloudflareD1Options` before starting.
-* The binding is typically obtained from the Cloudflare Workers environment.
-*
-* @example
-* ```ts
-* // In your Cloudflare Worker
-* alepha.set(cloudflareD1Options, { binding: env.DB });
-* ```
-*/
-var CloudflareD1Provider = class extends DatabaseProvider {
-	kit = $inject(DrizzleKitProvider);
-	log = $logger();
-	builder = $inject(SqliteModelBuilder);
-	env = $env(t.object({ DATABASE_URL: t.string({ description: "Expect to be 'cloudflare-d1://name:id'" }) }));
-	d1;
-	drizzleDb;
-	get name() {
-		return "d1";
-	}
-	dialect = "sqlite";
-	get url() {
-		return this.env.DATABASE_URL;
-	}
-	get db() {
-		if (!this.drizzleDb) throw new AlephaError("D1 database not initialized");
-		return this.drizzleDb;
-	}
-	async execute(query) {
-		const { rows } = await this.db.run(query);
-		return rows;
+	/**
+	* 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");
+		}
 	}
-	onStart = $hook({
-		on: "start",
-		handler: async () => {
-			const [bindingName] = this.env.DATABASE_URL.replace("cloudflare-d1://", "").split(":");
-			const cloudflareEnv = this.alepha.store.get("cloudflare.env");
-			if (!cloudflareEnv) throw new AlephaError("Cloudflare Workers environment not found in Alepha store under 'cloudflare.env'.");
-			const binding = cloudflareEnv[bindingName];
-			if (!binding) throw new AlephaError(`D1 binding '${bindingName}' not found in Cloudflare Workers environment.`);
-			this.d1 = binding;
-			const { drizzle: drizzle$3 } = await import("drizzle-orm/d1");
-			this.drizzleDb = drizzle$3(this.d1);
-			await this.migrate();
-			this.log.info("Using Cloudflare D1 database");
+	/**
+	* 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 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;
 		}
-	});
-	async executeMigrations(migrationsFolder) {
-		const { migrate: migrate$3 } = await import("drizzle-orm/d1/migrator");
-		await migrate$3(this.db, { migrationsFolder });
 	}
 	/**
-	* Override development migration to skip sync (not supported on D1).
-	* D1 requires proper migrations to be applied.
+	* Find an entity by ID and update it.
 	*/
-	async runDevelopmentMigration(migrationsFolder) {
-		await this.executeMigrations(migrationsFolder);
+	async updateById(id, data, opts = {}) {
+		return await this.updateOne(this.getWhereId(id), data, opts);
 	}
 	/**
-	* Override test migration to run migrations instead of sync.
-	* D1 doesn't support schema synchronization.
+	* Find many entities and update all of them.
 	*/
-	async runTestMigration() {
-		const migrationsFolder = this.getMigrationsFolder();
+	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 {
-			await this.executeMigrations(migrationsFolder);
-		} catch {
-			this.log.warn("D1 migrations failed in test environment - ensure migrations exist");
+			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");
 		}
 	}
-};
-
-//#endregion
-//#region ../../src/orm/providers/drivers/NodePostgresProvider.ts
-const envSchema$2 = t.object({
-	DATABASE_URL: t.optional(t.text()),
-	POSTGRES_SCHEMA: t.optional(t.text())
-});
-var NodePostgresProvider = class NodePostgresProvider extends DatabaseProvider {
-	static SSL_MODES = [
-		"require",
-		"allow",
-		"prefer",
-		"verify-full"
-	];
-	log = $logger();
-	env = $env(envSchema$2);
-	kit = $inject(DrizzleKitProvider);
-	builder = $inject(PostgresModelBuilder);
-	client;
-	pg;
-	dialect = "postgresql";
-	get name() {
-		return "postgres";
+	/**
+	* 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);
+		}
 	}
 	/**
-	* In testing mode, the schema name will be generated and deleted after the test.
+	* Delete all entities.
+	* @returns Array of deleted entity IDs
 	*/
-	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 AlephaError("DATABASE_URL is not defined in the environment");
-		return this.env.DATABASE_URL;
+	clear(opts = {}) {
+		return this.deleteMany({}, opts);
 	}
 	/**
-	* Execute a SQL statement.
+	* Delete the given entity.
+	*
+	* You must fetch the entity first in order to delete it.
+	* @returns Array containing the deleted entity ID
 	*/
-	execute(statement) {
-		try {
-			return this.db.execute(statement);
-		} catch (error) {
-			throw new DbError("Error executing statement", error);
+	async destroy(entity, opts = {}) {
+		const id = entity[this.id.key];
+		if (id == null) throw new 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);
 	}
 	/**
-	* Get Postgres schema used by this provider.
+	* Find an entity and delete it.
+	* @returns Array of deleted entity IDs (should contain at most one ID)
 	*/
-	get schema() {
-		if (this.schemaForTesting) return this.schemaForTesting;
-		if (this.env.POSTGRES_SCHEMA) return this.env.POSTGRES_SCHEMA;
-		return "public";
+	async deleteOne(where = {}, opts = {}) {
+		return await this.deleteMany(where, opts);
 	}
 	/**
-	* Get the Drizzle Postgres database instance.
+	* Find an entity by ID and delete it.
+	* @returns Array containing the deleted entity ID
+	* @throws DbEntityNotFoundError if the entity is not found
 	*/
-	get db() {
-		if (!this.pg) throw new AlephaError("Database not initialized");
-		return this.pg;
+	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;
 	}
-	async executeMigrations(migrationsFolder) {
-		await migrate(this.db, { migrationsFolder });
+	/**
+	* Count entities.
+	*/
+	async count(where = {}, opts = {}) {
+		where = this.withDeletedAt(where, opts);
+		return (opts.tx ?? this.db).$count(this.table, this.toSQL(where));
 	}
-	onStart = $hook({
-		on: "start",
-		handler: async () => {
-			await this.connect();
-			if (!this.alepha.isServerless()) try {
-				await this.migrateLock.run();
-			} catch (error) {
-				throw new DbMigrationError(error);
-			}
-		}
-	});
-	onStop = $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 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(sql$1`DROP SCHEMA IF EXISTS ${sql$1.raw(this.schemaForTesting)} CASCADE`);
-				this.log.info(`Test schema '${this.schemaForTesting}' deleted`);
-			}
-			await this.close();
-		}
-	});
-	async connect() {
-		this.log.debug("Connect ..");
-		const client = postgres(this.getClientOptions());
-		await client`SELECT 1`;
-		this.client = client;
-		this.pg = drizzle$1(client, { logger: { logQuery: (query, params) => {
-			this.log.trace(query, { params });
-		} } });
-		this.log.info("Connection OK");
+	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);
 	}
-	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");
-		}
+	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];
 	}
-	migrateLock = $lock({ handler: async () => {
-		await this.migrate();
-	} });
 	/**
-	* Map the DATABASE_URL to postgres client options.
+	* Convert something to valid Pg Insert Value.
 	*/
-	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;
-	}
-};
-
-//#endregion
-//#region ../../src/orm/providers/drivers/NodeSqliteProvider.ts
-const envSchema$1 = t.object({ DATABASE_URL: t.optional(t.text()) });
-/**
-* Configuration options for the Node.js SQLite database provider.
-*/
-const nodeSqliteOptions = $atom({
-	name: "alepha.postgres.node-sqlite.options",
-	schema: t.object({ path: t.optional(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 = $inject(DrizzleKitProvider);
-	log = $logger();
-	env = $env(envSchema$1);
-	builder = $inject(SqliteModelBuilder);
-	options = $use(nodeSqliteOptions);
-	sqlite;
-	get name() {
-		return "sqlite";
+	cast(data, insert) {
+		const schema$1 = insert ? this.entity.insertSchema : t.partial(this.entity.updateSchema);
+		return this.alepha.codec.encode(schema$1, data);
 	}
-	dialect = "sqlite";
-	get url() {
-		const path = this.options.path ?? this.env.DATABASE_URL;
-		if (path) {
-			if (path.startsWith("postgres://")) throw new AlephaError("Postgres URL is not supported for SQLite provider.");
-			return path;
+	/**
+	* 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 (t.schema.isDateTime(value)) row[key] = this.dateTimeProvider.of(row[key]).toISOString();
+				else if (t.schema.isDate(value)) row[key] = this.dateTimeProvider.of(`${row[key]}T00:00:00Z`).toISOString().split("T")[0];
+			}
+			if (typeof row[key] === "bigint" && t.schema.isBigInt(value)) row[key] = row[key].toString();
 		}
-		if (this.alepha.isTest() || this.alepha.isServerless()) return ":memory:";
-		else return "node_modules/.alepha/sqlite.db";
+		return this.alepha.codec.decode(schema$1, row);
 	}
-	async execute(query) {
-		const { sql: sql$2, params, method } = this.db.all(query).getQuery();
-		this.log.trace(`${sql$2}`, params);
-		const statement = this.sqlite.prepare(sql$2);
-		if (method === "run") {
-			statement.run(...params);
-			return [];
+	/**
+	* 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];
 		}
-		if (method === "get") {
-			const data = statement.get(...params);
-			return data ? [{ ...data }] : [];
+		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 statement.all(...params);
+		return entity;
 	}
-	db = drizzle$2(async (sql$2, params, method) => {
-		const statement = this.sqlite.prepare(sql$2);
-		this.log.trace(`${sql$2}`, { 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 AlephaError(`Unsupported method: ${method}`);
-	});
-	onStart = $hook({
-		on: "start",
-		handler: async () => {
-			const { DatabaseSync } = await import("node:sqlite");
-			const filepath = this.url.replace("sqlite://", "").replace("sqlite:", "");
-			if (filepath !== ":memory:" && filepath !== "") {
-				const dirname = filepath.split("/").slice(0, -1).join("/");
-				if (dirname) await mkdir(dirname, { recursive: true }).catch(() => null);
-			}
-			this.sqlite = new DatabaseSync(filepath);
-			await this.migrate();
-			this.log.info(`Using SQLite database at ${filepath}`);
-		}
-	});
-	async executeMigrations(migrationsFolder) {
-		await migrate$1(this.db, async (migrationQueries) => {
-			this.log.debug("Executing migration queries", { migrationQueries });
-			for (const query of migrationQueries) this.sqlite.prepare(query).run();
-		}, { migrationsFolder });
+	/**
+	* 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: 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 AlephaError("Primary key not found in schema");
+		if (primaryKeys.length > 1) throw new 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/drivers/PglitePostgresProvider.ts
-const envSchema = t.object({ DATABASE_URL: t.optional(t.text()) });
-var PglitePostgresProvider = class PglitePostgresProvider extends DatabaseProvider {
-	static importPglite() {
-		try {
-			return createRequire(import.meta.url)("@electric-sql/pglite");
-		} catch {}
-	}
-	env = $env(envSchema);
-	log = $logger();
-	kit = $inject(DrizzleKitProvider);
-	builder = $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/.alepha/pglite";
-		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 AlephaError("Database not initialized");
-		return this.pglite;
+//#region ../../src/orm/providers/RepositoryProvider.ts
+var RepositoryProvider = class {
+	alepha = $inject(Alepha);
+	registry = /* @__PURE__ */ new Map();
+	getRepositories(provider) {
+		const repositories = this.alepha.services(Repository);
+		if (provider) return repositories.filter((it) => it.provider === provider);
+		return repositories;
 	}
-	async execute(statement) {
-		const { rows } = await this.db.execute(statement);
-		return rows;
+	getRepository(entity) {
+		const RepositoryClass = this.createClassRepository(entity);
+		return this.alepha.inject(RepositoryClass);
 	}
-	onStart = $hook({
-		on: "start",
-		handler: async () => {
-			if (Object.keys(this.kit.getModels(this)).length === 0) return;
-			const module = PglitePostgresProvider.importPglite();
-			if (!module) throw new AlephaError("@electric-sql/pglite is not installed. Please install it to use the pglite driver.");
-			const { drizzle: drizzle$3 } = createRequire(import.meta.url)("drizzle-orm/pglite");
-			const path = this.url;
-			if (path !== ":memory:") {
-				await mkdir(path, { recursive: true }).catch(() => null);
-				this.client = new module.PGlite(path);
-			} else this.client = new module.PGlite();
-			this.pglite = drizzle$3({ client: this.client });
-			await this.migrate();
-			this.log.info(`Using PGlite database at ${path}`);
-		}
-	});
-	onStop = $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");
+	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);
 			}
 		}
-	});
-	async executeMigrations(migrationsFolder) {
-		await migrate$2(this.db, { migrationsFolder });
+		Object.defineProperty(GenericRepository, "name", { value: name });
+		this.registry.set(entity, GenericRepository);
+		return GenericRepository;
 	}
 };
 
@@ -2734,32 +2739,6 @@ function buildQueryString(where) {
 	return parts.join("&");
 }
 
-//#endregion
-//#region ../../src/orm/primitives/$transaction.ts
-/**
-* Creates a transaction primitive for database operations requiring atomicity and consistency.
-*
-* This primitive 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 } = $context();
-	const provider = alepha.inject(DatabaseProvider);
-	return $retry({
-		when: (err) => err instanceof DbVersionMismatchError,
-		handler: (...args) => provider.db.transaction(async (tx) => opts.handler(tx, ...args), opts.config)
-	});
-};
-
 //#endregion
 //#region ../../src/orm/providers/DatabaseTypeProvider.ts
 var DatabaseTypeProvider = class {
@@ -2881,11 +2860,101 @@ const pg = db;
 */
 const legacyIdSchema = pgAttr(pgAttr(pgAttr(t.integer(), PG_PRIMARY_KEY), PG_SERIAL), PG_DEFAULT);
 
+//#endregion
+//#region ../../src/orm/primitives/$repository.ts
+/**
+* Get the repository for the given entity.
+*/
+const $repository = (entity) => {
+	const { alepha } = $context();
+	return $inject(alepha.inject(RepositoryProvider).createClassRepository(entity));
+};
+
+//#endregion
+//#region ../../src/orm/primitives/$transaction.ts
+/**
+* Creates a transaction primitive for database operations requiring atomicity and consistency.
+*
+* This primitive 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 } = $context();
+	const provider = alepha.inject(DatabaseProvider);
+	return $retry({
+		when: (err) => err instanceof DbVersionMismatchError,
+		handler: (...args) => provider.db.transaction(async (tx) => opts.handler(tx, ...args), opts.config)
+	});
+};
+
 //#endregion
 //#region ../../src/orm/index.ts
+var orm_exports = /* @__PURE__ */ __exportAll({
+	$entity: () => $entity,
+	$repository: () => $repository,
+	$sequence: () => $sequence,
+	$transaction: () => $transaction,
+	AlephaPostgres: () => AlephaPostgres,
+	BunPostgresProvider: () => BunPostgresProvider,
+	BunSqliteProvider: () => BunSqliteProvider,
+	CloudflareD1Provider: () => CloudflareD1Provider,
+	DatabaseProvider: () => DatabaseProvider,
+	DatabaseTypeProvider: () => DatabaseTypeProvider,
+	DbConflictError: () => DbConflictError,
+	DbEntityNotFoundError: () => DbEntityNotFoundError,
+	DbError: () => DbError,
+	DbMigrationError: () => DbMigrationError,
+	DbVersionMismatchError: () => DbVersionMismatchError,
+	DrizzleKitProvider: () => DrizzleKitProvider,
+	EntityPrimitive: () => EntityPrimitive,
+	NodePostgresProvider: () => NodePostgresProvider,
+	NodeSqliteProvider: () => NodeSqliteProvider,
+	PG_CREATED_AT: () => PG_CREATED_AT,
+	PG_DEFAULT: () => PG_DEFAULT,
+	PG_DELETED_AT: () => PG_DELETED_AT,
+	PG_ENUM: () => PG_ENUM,
+	PG_IDENTITY: () => PG_IDENTITY,
+	PG_PRIMARY_KEY: () => PG_PRIMARY_KEY,
+	PG_REF: () => PG_REF,
+	PG_SERIAL: () => PG_SERIAL,
+	PG_UPDATED_AT: () => PG_UPDATED_AT,
+	PG_VERSION: () => PG_VERSION,
+	Repository: () => Repository,
+	RepositoryProvider: () => RepositoryProvider,
+	SequencePrimitive: () => SequencePrimitive,
+	buildQueryString: () => buildQueryString,
+	bunSqliteOptions: () => bunSqliteOptions,
+	db: () => db,
+	drizzle: () => drizzle,
+	getAttrFields: () => getAttrFields,
+	insertSchema: () => insertSchema,
+	legacyIdSchema: () => legacyIdSchema,
+	nodeSqliteOptions: () => nodeSqliteOptions,
+	pageQuerySchema: () => pageQuerySchema,
+	pageSchema: () => pageSchema,
+	parseQueryString: () => parseQueryString,
+	pg: () => pg,
+	pgAttr: () => pgAttr,
+	schema: () => schema,
+	sql: () => sql,
+	updateSchema: () => updateSchema
+});
 /**
 * Postgres client based on Drizzle ORM, Alepha type-safe friendly.
 *
+* Automatically selects the appropriate provider based on runtime:
+* - Bun: Uses `BunPostgresProvider` or `BunSqliteProvider`
+* - Node.js: Uses `NodePostgresProvider` or `NodeSqliteProvider`
+*
 * ```ts
 * import { t } from "alepha";
 * import { $entity, $repository, db } from "alepha/postgres";
@@ -2924,6 +2993,10 @@ const legacyIdSchema = pgAttr(pgAttr(pgAttr(t.integer(), PG_PRIMARY_KEY), PG_SER
 * @see {@link $sequence}
 * @see {@link $repository}
 * @see {@link $transaction}
+* @see {@link NodePostgresProvider} - Node.js Postgres implementation
+* @see {@link NodeSqliteProvider} - Node.js SQLite implementation
+* @see {@link BunPostgresProvider} - Bun Postgres implementation
+* @see {@link BunSqliteProvider} - Bun SQLite implementation
 * @module alepha.postgres
 */
 const AlephaPostgres = $module({
@@ -2933,10 +3006,10 @@ const AlephaPostgres = $module({
 		AlephaDateTime,
 		DatabaseProvider,
 		NodePostgresProvider,
-		PglitePostgresProvider,
 		NodeSqliteProvider,
 		BunPostgresProvider,
 		BunSqliteProvider,
+		PglitePostgresProvider,
 		CloudflareD1Provider,
 		SqliteModelBuilder,
 		PostgresModelBuilder,
@@ -2956,6 +3029,7 @@ const AlephaPostgres = $module({
 		const isSqlite = url?.startsWith("sqlite:");
 		const isMemory = url?.includes(":memory:");
 		const isFile = !!url && !isPostgres && !isMemory;
+		const isBun = alepha.isBun();
 		if (url?.startsWith("cloudflare-d1:")) {
 			alepha.with({
 				optional: true,
@@ -2976,14 +3050,14 @@ const AlephaPostgres = $module({
 			alepha.with({
 				optional: true,
 				provide: DatabaseProvider,
-				use: alepha.isBun() ? BunPostgresProvider : NodePostgresProvider
+				use: isBun ? BunPostgresProvider : NodePostgresProvider
 			});
 			return;
 		}
 		alepha.with({
 			optional: true,
 			provide: DatabaseProvider,
-			use: alepha.isBun() ? BunSqliteProvider : NodeSqliteProvider
+			use: isBun ? BunSqliteProvider : NodeSqliteProvider
 		});
 	}
 });