alepha 0.14.4 → 0.15.0

package/dist/orm/index.bun.js

@@ -0,0 +1,2814 @@
+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 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 { $lock } from "alepha/lock";
+import { randomUUID } from "node:crypto";
+import * as pg$1 from "drizzle-orm/sqlite-core";
+import { check as check$1, foreignKey as foreignKey$1, index as index$1, sqliteTable, unique as unique$1, uniqueIndex as uniqueIndex$1 } from "drizzle-orm/sqlite-core";
+import { migrate } 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"
+
+//#region rolldown:runtime
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __exportAll = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc$1) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc$1 = __getOwnPropDesc(from, key)) || desc$1.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+
+//#endregion
+//#region ../../src/orm/constants/PG_SYMBOLS.ts
+const PG_DEFAULT = Symbol.for("Alepha.Postgres.Default");
+const PG_PRIMARY_KEY = Symbol.for("Alepha.Postgres.PrimaryKey");
+const PG_CREATED_AT = Symbol.for("Alepha.Postgres.CreatedAt");
+const PG_UPDATED_AT = Symbol.for("Alepha.Postgres.UpdatedAt");
+const PG_DELETED_AT = Symbol.for("Alepha.Postgres.DeletedAt");
+const PG_VERSION = Symbol.for("Alepha.Postgres.Version");
+const PG_IDENTITY = Symbol.for("Alepha.Postgres.Identity");
+const PG_ENUM = Symbol.for("Alepha.Postgres.Enum");
+const PG_REF = Symbol.for("Alepha.Postgres.Ref");
+/**
+* @deprecated Use `PG_IDENTITY` instead.
+*/
+const PG_SERIAL = Symbol.for("Alepha.Postgres.Serial");
+
+//#endregion
+//#region ../../src/orm/types/schema.ts
+/**
+* Postgres schema type.
+*/
+const schema = (name, document) => customType({
+	dataType: () => "jsonb",
+	toDriver: (value) => JSON.stringify(value),
+	fromDriver: (value) => value && typeof value === "string" ? JSON.parse(value) : value
+})(name, { document }).$type();
+
+//#endregion
+//#region ../../src/orm/schemas/insertSchema.ts
+const insertSchema = (obj) => {
+	const newProperties = {};
+	for (const key in obj.properties) {
+		const prop = obj.properties[key];
+		if (PG_DEFAULT in prop) newProperties[key] = t.optional(prop);
+		else newProperties[key] = prop;
+	}
+	return t.object(newProperties, "options" in schema && typeof schema.options === "object" ? { ...schema.options } : {});
+};
+
+//#endregion
+//#region ../../src/orm/schemas/updateSchema.ts
+const updateSchema = (schema$1) => {
+	const newProperties = {};
+	for (const key in schema$1.properties) {
+		const prop = schema$1.properties[key];
+		if (t.schema.isOptional(prop)) newProperties[key] = t.optional(t.union([prop, t.raw.Null()]));
+		else newProperties[key] = prop;
+	}
+	return t.object(newProperties, "options" in schema$1 && typeof schema$1.options === "object" ? { ...schema$1.options } : {});
+};
+
+//#endregion
+//#region ../../src/orm/primitives/$entity.ts
+/**
+* Creates a database entity primitive that defines table structure using TypeBox schemas.
+*
+* @example
+* ```ts
+* import { t } from "alepha";
+* import { $entity } from "alepha/orm";
+*
+* const userEntity = $entity({
+*   name: "users",
+*   schema: t.object({
+*     id: pg.primaryKey(),
+*     name: t.text(),
+*     email: t.email(),
+*   }),
+* });
+* ```
+*/
+const $entity = (options) => {
+	return new EntityPrimitive(options);
+};
+var EntityPrimitive = class EntityPrimitive {
+	options;
+	constructor(options) {
+		this.options = options;
+	}
+	alias(alias$1) {
+		const aliased = new EntityPrimitive(this.options);
+		return new Proxy(aliased, { get(target, prop, receiver) {
+			if (prop === "$alias") return alias$1;
+			return Reflect.get(target, prop, receiver);
+		} });
+	}
+	get cols() {
+		const cols = {};
+		for (const key of Object.keys(this.schema.properties)) cols[key] = {
+			name: key,
+			entity: this
+		};
+		return cols;
+	}
+	get name() {
+		return this.options.name;
+	}
+	get schema() {
+		return this.options.schema;
+	}
+	get insertSchema() {
+		return insertSchema(this.options.schema);
+	}
+	get updateSchema() {
+		return updateSchema(this.options.schema);
+	}
+};
+$entity[KIND] = EntityPrimitive;
+
+//#endregion
+//#region ../../src/orm/errors/DbError.ts
+var DbError = class extends AlephaError {
+	name = "DbError";
+	constructor(message, cause) {
+		super(message, { cause });
+	}
+};
+
+//#endregion
+//#region ../../src/orm/providers/drivers/DatabaseProvider.ts
+var DatabaseProvider = class {
+	alepha = $inject(Alepha);
+	log = $logger();
+	enums = /* @__PURE__ */ new Map();
+	tables = /* @__PURE__ */ new Map();
+	sequences = /* @__PURE__ */ new Map();
+	get name() {
+		return "default";
+	}
+	get driver() {
+		return this.dialect;
+	}
+	get schema() {
+		return "public";
+	}
+	table(entity) {
+		const table = this.tables.get(entity.name);
+		if (!table) throw new AlephaError(`Table '${entity.name}' is not registered`);
+		const hasAlias = entity.$alias;
+		if (hasAlias) return alias(table, hasAlias);
+		return table;
+	}
+	registerEntity(entity) {
+		this.builder.buildTable(entity, this);
+	}
+	registerSequence(sequence) {
+		this.builder.buildSequence(sequence, this);
+	}
+	async run(statement, schema$1) {
+		return (await this.execute(statement)).map((row) => this.alepha.codec.decode(schema$1, row));
+	}
+	/**
+	* Get migrations folder path - can be overridden
+	*/
+	getMigrationsFolder() {
+		return `migrations/${this.name}`;
+	}
+	/**
+	* Base migration orchestration - handles environment logic
+	*/
+	async migrate() {
+		const migrationsFolder = this.getMigrationsFolder();
+		if (this.alepha.isProduction()) await this.runProductionMigration(migrationsFolder);
+		else if (this.alepha.isTest()) await this.runTestMigration();
+		else await this.runDevelopmentMigration(migrationsFolder);
+	}
+	/**
+	* Production: run migrations from folder
+	*/
+	async runProductionMigration(migrationsFolder) {
+		if (!await stat(migrationsFolder).catch(() => false)) {
+			this.log.warn("Migration SKIPPED - no migrations found");
+			return;
+		}
+		this.log.debug(`Migrate from '${migrationsFolder}' directory ...`);
+		await this.executeMigrations(migrationsFolder);
+		this.log.info("Migration OK");
+	}
+	/**
+	* Test: always synchronize
+	*/
+	async runTestMigration() {
+		await this.synchronizeSchema();
+	}
+	/**
+	* Development: default to synchronize (can be overridden)
+	*/
+	async runDevelopmentMigration(migrationsFolder) {
+		try {
+			if (!this.url.includes(":memory:")) await this.executeMigrations(migrationsFolder);
+		} catch {}
+		await this.synchronizeSchema();
+	}
+	/**
+	* Common synchronization with error handling
+	*/
+	async synchronizeSchema() {
+		try {
+			await this.kit.synchronize(this);
+		} catch (error) {
+			throw new DbError(`Failed to synchronize ${this.dialect} database schema`, error);
+		}
+	}
+	/**
+	* For testing purposes, generate a unique schema name.
+	* The schema name will be generated based on the current date and time.
+	* It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
+	*/
+	generateTestSchemaName() {
+		const pad = (n) => n.toString().padStart(2, "0");
+		const now = /* @__PURE__ */ new Date();
+		return `test_${`${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}_${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`}_${Math.random().toString(36).slice(2, 6)}`;
+	}
+};
+
+//#endregion
+//#region ../../src/orm/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);
+	/**
+	* Synchronize database with current schema definitions.
+	*
+	* In development mode, it will generate and execute migrations based on the current state.
+	* In testing mode, it will generate migrations from scratch without applying them.
+	*
+	* Does nothing in production mode, you must handle migrations manually.
+	*/
+	async synchronize(provider) {
+		if (this.alepha.isProduction()) {
+			this.log.warn("Synchronization skipped in production mode.");
+			return;
+		}
+		if (provider.schema !== "public") await this.createSchemaIfNotExists(provider, provider.schema);
+		const now = Date.now();
+		if (this.alepha.isTest()) {
+			const { statements } = await this.generateMigration(provider);
+			await this.executeStatements(statements, provider);
+		} else {
+			const entry = await this.loadDevMigrations(provider);
+			const { statements, snapshot } = await this.generateMigration(provider, entry?.snapshot ? JSON.parse(entry.snapshot) : void 0);
+			await this.executeStatements(statements, provider, true);
+			await this.saveDevMigrations(provider, snapshot, entry);
+		}
+		this.log.info(`Db '${provider.name}' synchronization OK [${Date.now() - now}ms]`);
+	}
+	/**
+	* Mostly used for testing purposes. You can generate SQL migration statements without executing them.
+	*/
+	async generateMigration(provider, prevSnapshot) {
+		const kit = this.importDrizzleKit();
+		const models = this.getModels(provider);
+		if (Object.keys(models).length > 0) {
+			if (provider.dialect === "sqlite") {
+				const prev$1 = prevSnapshot ?? await kit.generateSQLiteDrizzleJson({});
+				const curr$1 = await kit.generateSQLiteDrizzleJson(models);
+				return {
+					models,
+					statements: await kit.generateSQLiteMigration(prev$1, curr$1),
+					snapshot: curr$1
+				};
+			}
+			const prev = prevSnapshot ?? await kit.generateDrizzleJson({});
+			const curr = await kit.generateDrizzleJson(models);
+			return {
+				models,
+				statements: await kit.generateMigration(prev, curr),
+				snapshot: curr
+			};
+		}
+		return {
+			models,
+			statements: [],
+			snapshot: {}
+		};
+	}
+	/**
+	* Load all tables, enums, sequences, etc. from the provider's repositories.
+	*/
+	getModels(provider) {
+		const models = {};
+		for (const [key, value] of provider.tables.entries()) {
+			if (models[key]) throw new 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;
+	}
+	/**
+	* Load the migration snapshot from the database.
+	*/
+	async loadDevMigrations(provider) {
+		const name = `${this.alepha.env.APP_NAME ?? "APP"}-${provider.constructor.name}`.toLowerCase();
+		if (provider.url.includes(":memory:")) {
+			this.log.trace(`In-memory database detected for '${name}', skipping migration snapshot load.`);
+			return;
+		}
+		if (provider.dialect === "sqlite") {
+			try {
+				const text = await 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]);
+	}
+	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 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 (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}`);
+	}
+	/**
+	* Try to load the official Drizzle Kit API.
+	* If not available, fallback to the local kit import.
+	*/
+	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`.");
+		}
+	}
+};
+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 {
+	/**
+	* Convert camelCase to snake_case for column names.
+	*/
+	toColumnName(str) {
+		return str[0].toLowerCase() + str.slice(1).replace(/[A-Z]/g, (letter) => `_${letter.toLowerCase()}`);
+	}
+	/**
+	* Build the table configuration function for any database.
+	* This includes indexes, foreign keys, constraints, and custom config.
+	*
+	* @param entity - The entity primitive
+	* @param builders - Database-specific builder functions
+	* @param tableResolver - Function to resolve entity references to table columns
+	* @param customConfigHandler - Optional handler for custom config
+	*/
+	buildTableConfig(entity, builders, tableResolver, customConfigHandler) {
+		if (!entity.options.indexes && !entity.options.foreignKeys && !entity.options.constraints && !entity.options.config) return;
+		return (self) => {
+			const configs = [];
+			if (entity.options.indexes) {
+				for (const indexDef of entity.options.indexes) if (typeof indexDef === "string") {
+					const columnName = this.toColumnName(indexDef);
+					const indexName = `${entity.name}_${columnName}_idx`;
+					if (self[indexDef]) configs.push(builders.index(indexName).on(self[indexDef]));
+				} else if (typeof indexDef === "object" && indexDef !== null) {
+					if ("column" in indexDef) {
+						const columnName = this.toColumnName(indexDef.column);
+						const indexName = indexDef.name || `${entity.name}_${columnName}_idx`;
+						if (self[indexDef.column]) if (indexDef.unique) configs.push(builders.uniqueIndex(indexName).on(self[indexDef.column]));
+						else configs.push(builders.index(indexName).on(self[indexDef.column]));
+					} else if ("columns" in indexDef) {
+						const columnNames = indexDef.columns.map((col) => this.toColumnName(col));
+						const indexName = indexDef.name || `${entity.name}_${columnNames.join("_")}_idx`;
+						const cols = indexDef.columns.map((col) => self[col]).filter(Boolean);
+						if (cols.length === indexDef.columns.length) if (indexDef.unique) configs.push(builders.uniqueIndex(indexName).on(...cols));
+						else configs.push(builders.index(indexName).on(...cols));
+					}
+				}
+			}
+			if (entity.options.foreignKeys) for (const fkDef of entity.options.foreignKeys) {
+				const columnNames = fkDef.columns.map((col) => this.toColumnName(col));
+				const cols = fkDef.columns.map((col) => self[col]).filter(Boolean);
+				if (cols.length === fkDef.columns.length) {
+					const fkName = fkDef.name || `${entity.name}_${columnNames.join("_")}_fk`;
+					const foreignColumns = fkDef.foreignColumns.map((colRef) => {
+						const entityCol = colRef();
+						if (!entityCol || !entityCol.entity || !entityCol.name) throw new Error(`Invalid foreign column reference in ${entity.name}`);
+						if (tableResolver) {
+							const foreignTable = tableResolver(entityCol.entity.name);
+							if (!foreignTable) throw new Error(`Foreign table ${entityCol.entity.name} not found for ${entity.name}`);
+							return foreignTable[entityCol.name];
+						}
+						return entityCol;
+					});
+					configs.push(builders.foreignKey({
+						name: fkName,
+						columns: cols,
+						foreignColumns
+					}));
+				}
+			}
+			if (entity.options.constraints) for (const constraintDef of entity.options.constraints) {
+				const columnNames = constraintDef.columns.map((col) => this.toColumnName(col));
+				const cols = constraintDef.columns.map((col) => self[col]).filter(Boolean);
+				if (cols.length === constraintDef.columns.length) {
+					if (constraintDef.unique) {
+						const constraintName = constraintDef.name || `${entity.name}_${columnNames.join("_")}_unique`;
+						configs.push(builders.unique(constraintName).on(...cols));
+					}
+					if (constraintDef.check) {
+						const constraintName = constraintDef.name || `${entity.name}_${columnNames.join("_")}_check`;
+						configs.push(builders.check(constraintName, constraintDef.check));
+					}
+				}
+			}
+			if (entity.options.config && customConfigHandler) configs.push(...customConfigHandler(entity.options.config, self));
+			else if (entity.options.config) {
+				const customConfigs = entity.options.config(self);
+				if (Array.isArray(customConfigs)) configs.push(...customConfigs);
+			}
+			return configs;
+		};
+	}
+};
+
+//#endregion
+//#region ../../src/orm/services/PostgresModelBuilder.ts
+var PostgresModelBuilder = class extends ModelBuilder {
+	schemas = /* @__PURE__ */ new Map();
+	getPgSchema(name) {
+		if (!this.schemas.has(name) && name !== "public") this.schemas.set(name, 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);
+	}
+	buildSequence(sequence, options) {
+		const sequenceName = sequence.name;
+		if (options.sequences.has(sequenceName)) return;
+		const nsp = this.getPgSchema(options.schema);
+		options.sequences.set(sequenceName, nsp.sequence(sequenceName, sequence.options));
+	}
+	/**
+	* Get PostgreSQL-specific config builder for the table.
+	*/
+	getTableConfig(entity, tables) {
+		const pgBuilders = {
+			index,
+			uniqueIndex,
+			unique,
+			check,
+			foreignKey
+		};
+		const tableResolver = (entityName) => {
+			return tables.get(entityName);
+		};
+		return this.buildTableConfig(entity, pgBuilders, tableResolver);
+	}
+	schemaToPgColumns = (tableName, schema$1, nsp, enums, tables) => {
+		return Object.entries(schema$1.properties).reduce((columns, [key, value]) => {
+			let col = this.mapFieldToColumn(tableName, key, value, nsp, enums);
+			if ("default" in value && value.default != null) col = col.default(value.default);
+			if (PG_PRIMARY_KEY in value) col = col.primaryKey();
+			if (PG_REF in value) {
+				const config = value[PG_REF];
+				col = col.references(() => {
+					const ref = config.ref();
+					const table = tables.get(ref.entity.name);
+					if (!table) throw new 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 (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)}`);
+	};
+	/**
+	* Map a string to a PG column.
+	*
+	* @param key The key of the field.
+	* @param value The value of the field.
+	*/
+	mapStringToColumn = (key, value) => {
+		if ("format" in value) {
+			if (value.format === "uuid") {
+				if (PG_PRIMARY_KEY in value) return 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$2 = 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$2);
+	kit = $inject(DrizzleKitProvider);
+	builder = $inject(PostgresModelBuilder);
+	client;
+	bunDb;
+	dialect = "postgresql";
+	get name() {
+		return "postgres";
+	}
+	/**
+	* In testing mode, the schema name will be generated and deleted after the test.
+	*/
+	schemaForTesting = this.alepha.isTest() ? this.env.POSTGRES_SCHEMA?.startsWith("test_") ? this.env.POSTGRES_SCHEMA : this.generateTestSchemaName() : void 0;
+	get url() {
+		if (!this.env.DATABASE_URL) throw new AlephaError("DATABASE_URL is not defined in the environment");
+		return this.env.DATABASE_URL;
+	}
+	/**
+	* Execute a SQL statement.
+	*/
+	execute(statement) {
+		try {
+			return this.db.execute(statement);
+		} catch (error) {
+			throw new DbError("Error executing statement", error);
+		}
+	}
+	/**
+	* Get Postgres schema used by this provider.
+	*/
+	get schema() {
+		if (this.schemaForTesting) return this.schemaForTesting;
+		if (this.env.POSTGRES_SCHEMA) return this.env.POSTGRES_SCHEMA;
+		return "public";
+	}
+	/**
+	* Get the Drizzle Postgres database instance.
+	*/
+	get db() {
+		if (!this.bunDb) throw new AlephaError("Database not initialized");
+		return this.bunDb;
+	}
+	async executeMigrations(migrationsFolder) {
+		const { migrate: migrate$1 } = await import("drizzle-orm/bun-sql/migrator");
+		await migrate$1(this.bunDb, { 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);
+			}
+		}
+	});
+	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$1 } = await import("drizzle-orm/bun-sql");
+		this.client = new Bun.SQL(this.url);
+		await this.client.unsafe("SELECT 1");
+		this.bunDb = drizzle$1({
+			client: this.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.close();
+			this.client = void 0;
+			this.bunDb = void 0;
+			this.log.info("Connection closed");
+		}
+	}
+	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);
+	}
+	buildSequence(sequence, options) {
+		throw new AlephaError("SQLite does not support sequences");
+	}
+	/**
+	* Get SQLite-specific config builder for the table.
+	*/
+	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 : [];
+		});
+	}
+	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, {});
+		}
+		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;
+		}
+	})(name, { document }).$type();
+	sqliteDateTime = pg$1.customType({
+		dataType: () => "integer",
+		toDriver: (value) => new Date(value).getTime(),
+		fromDriver: (value) => {
+			return new Date(value).toISOString();
+		}
+	});
+	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];
+		}
+	});
+};
+
+//#endregion
+//#region ../../src/orm/providers/drivers/BunSqliteProvider.ts
+const envSchema$1 = 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$1);
+	builder = $inject(SqliteModelBuilder);
+	options = $use(bunSqliteOptions);
+	sqlite;
+	bunDb;
+	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 (this.alepha.isTest() || this.alepha.isServerless()) return ":memory:";
+		else return "node_modules/.alepha/bun-sqlite.db";
+	}
+	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$1 } = 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$1({
+				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");
+			}
+		}
+	});
+	async executeMigrations(migrationsFolder) {
+		const { migrate: migrate$1 } = await import("drizzle-orm/bun-sqlite/migrator");
+		await migrate$1(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 "sqlite";
+	}
+	get driver() {
+		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;
+	}
+	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$1 } = await import("drizzle-orm/d1");
+			this.drizzleDb = drizzle$1(this.d1);
+			await this.migrate();
+			this.log.info("Using Cloudflare D1 database");
+		}
+	});
+	async executeMigrations(migrationsFolder) {
+		const { migrate: migrate$1 } = await import("drizzle-orm/d1/migrator");
+		await migrate$1(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");
+		}
+	}
+};
+
+//#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 "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$1 } = 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$1({ 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(this.db, { migrationsFolder });
+	}
+};
+
+//#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/services/PgRelationManager.ts
+var PgRelationManager = class {
+	/**
+	* Recursively build joins for the query builder based on the relations map
+	*/
+	buildJoins(provider, builder, joins, withRelations, table, parentKey) {
+		for (const [key, join] of Object.entries(withRelations)) {
+			const from = provider.table(join.join);
+			const on = 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);
+		}
+	}
+	/**
+	* Map a row with its joined relations based on the joins definition
+	*/
+	mapRowWithJoins(record, row, schema$1, joins, parentKey) {
+		for (const join of joins) if (join.parent === parentKey) {
+			const joinedData = row[join.table];
+			if (this.isAllNull(joinedData)) record[join.key] = void 0;
+			else {
+				record[join.key] = joinedData;
+				this.mapRowWithJoins(record[join.key], row, schema$1, joins, parentKey ? `${parentKey}.${join.key}` : join.key);
+			}
+		}
+		return record;
+	}
+	/**
+	* Check if all values in an object are null (indicates a left join with no match)
+	*/
+	isAllNull(obj) {
+		if (obj === null || obj === void 0) return true;
+		if (typeof obj !== "object") return false;
+		return Object.values(obj).every((val) => val === null);
+	}
+	/**
+	* Build a schema that includes all join properties recursively
+	*/
+	buildSchemaWithJoins(baseSchema, joins, parentPath) {
+		const schema$1 = 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 (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);
+				}
+			}
+		}
+		if (conditions.length === 1) return conditions[0];
+		return and(...conditions);
+	}
+	/**
+	* Check if an object has any filter operator properties.
+	*/
+	hasFilterOperatorProperties(obj) {
+		if (!obj || typeof obj !== "object") return false;
+		return [
+			"eq",
+			"ne",
+			"gt",
+			"gte",
+			"lt",
+			"lte",
+			"inArray",
+			"notInArray",
+			"isNull",
+			"isNotNull",
+			"like",
+			"notLike",
+			"ilike",
+			"notIlike",
+			"contains",
+			"startsWith",
+			"endsWith",
+			"between",
+			"notBetween",
+			"arrayContains",
+			"arrayContained",
+			"arrayOverlaps"
+		].some((key) => key in obj);
+	}
+	/**
+	* Map a filter operator to a SQL query.
+	*/
+	mapOperatorToSql(operator, column, columnSchema, columnName, dialect = "postgresql") {
+		const encodeValue = (value) => {
+			if (value == null) return value;
+			if (columnSchema && columnName) try {
+				const fieldSchema = columnSchema.properties[columnName];
+				if (fieldSchema) return this.alepha.codec.encode(fieldSchema, value, { encoder: "drizzle" });
+			} catch (error) {}
+			return value;
+		};
+		const encodeArray = (values) => {
+			return values.map((v) => encodeValue(v));
+		};
+		if (typeof operator !== "object" || operator == null || !this.hasFilterOperatorProperties(operator)) return 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])));
+		}
+		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 [];
+	}
+	/**
+	* Create a pagination object.
+	*
+	* @deprecated Use `createPagination` from alepha instead.
+	* This method now delegates to the framework-level helper.
+	*
+	* @param entities The entities to paginate.
+	* @param limit The limit of the pagination.
+	* @param offset The offset of the pagination.
+	* @param sort Optional sort metadata to include in response.
+	*/
+	createPagination(entities, limit = 10, offset = 0, sort) {
+		return createPagination(entities, limit, offset, sort);
+	}
+};
+
+//#endregion
+//#region ../../src/orm/services/Repository.ts
+var Repository = class {
+	entity;
+	provider;
+	log = $logger();
+	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);
+	}
+	/**
+	* Get SQL table name. (from Drizzle table object)
+	*/
+	get tableName() {
+		return this.entity.name;
+	}
+	/**
+	* Getter for the database connection from the database provider.
+	*/
+	get db() {
+		return this.provider.db;
+	}
+	/**
+	* Execute a SQL query.
+	*
+	* This method allows executing raw SQL queries against the database.
+	* This is by far the easiest way to run custom queries that are not covered by the repository's built-in methods!
+	*
+	* You must use the `sql` tagged template function from Drizzle ORM to create the query. https://orm.drizzle.team/docs/sql
+	*
+	* @example
+	* ```ts
+	* class App {
+	*   repository = $repository({ ... });
+	*   async getAdults() {
+	*     const users = repository.table; // Drizzle table object
+	*     await repository.query(sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
+	*     // or better
+	*     await repository.query((users) => sql`SELECT * FROM ${users} WHERE ${users.age} > ${18}`);
+	*   }
+	* }
+	* ```
+	*/
+	async query(query, schema$1) {
+		const raw = typeof query === "function" ? query(this.table, this.db) : query;
+		if (typeof raw === "string" && raw.includes("[object Object]")) throw new AlephaError("Invalid SQL query. Did you forget to call the 'sql' function?");
+		return (await this.provider.execute(raw)).map((it) => {
+			return this.clean(this.mapRawFieldsToEntity(it), schema$1 ?? this.entity.schema);
+		});
+	}
+	/**
+	* Map raw database fields to entity fields. (handles column name differences)
+	*/
+	mapRawFieldsToEntity(row) {
+		const entity = {};
+		for (const key of Object.keys(row)) {
+			entity[key] = row[key];
+			for (const colKey of Object.keys(this.table)) if (this.table[colKey].name === key) {
+				entity[colKey] = row[key];
+				break;
+			}
+		}
+		return entity;
+	}
+	/**
+	* Get a Drizzle column from the table by his name.
+	*/
+	col(name) {
+		const column = this.table[name];
+		if (!column) throw new 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);
+	}
+	/**
+	* 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);
+	}
+	/**
+	* Start a DELETE query on the table.
+	*/
+	rawDelete(opts = {}) {
+		return (opts.tx ?? this.db).delete(this.table);
+	}
+	/**
+	* Create a Drizzle `select` query based on a JSON query object.
+	*
+	* > This method is the base for `find`, `findOne`, `findById`, and `paginate`.
+	*/
+	async findMany(query = {}, opts = {}) {
+		await this.alepha.events.emit("repository:read:before", {
+			tableName: this.tableName,
+			query
+		});
+		const columns = query.columns ?? query.distinct;
+		const builder = query.distinct ? this.rawSelectDistinct(opts, query.distinct) : this.rawSelect(opts);
+		const joins = [];
+		if (query.with) this.relationManager.buildJoins(this.provider, builder, joins, query.with, this.table);
+		const where = this.withDeletedAt(query.where ?? {}, opts);
+		builder.where(() => this.toSQL(where, joins));
+		if (query.offset) {
+			builder.offset(query.offset);
+			if (this.provider.dialect === "sqlite" && !query.limit) query.limit = 1e3;
+		}
+		if (query.limit) builder.limit(query.limit);
+		if (query.orderBy) {
+			const orderByClauses = this.queryManager.normalizeOrderBy(query.orderBy);
+			builder.orderBy(...orderByClauses.map((clause) => clause.direction === "desc" ? 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);
+		}
+		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);
+		}
+	}
+	/**
+	* 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;
+			}));
+		}
+		const [entities, countResult] = await Promise.all(tasks);
+		let sortMetadata;
+		if (orderBy) sortMetadata = this.queryManager.normalizeOrderBy(orderBy);
+		const response = this.queryManager.createPagination(entities, limit, offset, sortMetadata);
+		response.page.totalElements = countResult;
+		if (countResult != null) response.page.totalPages = Math.ceil(countResult / limit);
+		return response;
+	}
+	/**
+	* Find an entity by ID.
+	*
+	* This is a convenience method for `findOne` with a where clause on the primary key.
+	* If you need more complex queries, use `findOne` instead.
+	*/
+	async findById(id, opts = {}) {
+		return await this.findOne({ where: this.getWhereId(id) }, opts);
+	}
+	/**
+	* Helper to create a type-safe query object.
+	*/
+	createQuery() {
+		return {};
+	}
+	/**
+	* Helper to create a type-safe where clause.
+	*/
+	createQueryWhere() {
+		return {};
+	}
+	/**
+	* Create an entity.
+	*
+	* @param data The entity to create.
+	* @param opts The options for creating the entity.
+	* @returns The ID of the created entity.
+	*/
+	async create(data, opts = {}) {
+		await this.alepha.events.emit("repository:create:before", {
+			tableName: this.tableName,
+			data
+		});
+		try {
+			const entity = await this.rawInsert(opts).values(this.cast(data ?? {}, true)).returning(this.table).then(([it]) => this.clean(it, this.entity.schema));
+			await this.alepha.events.emit("repository:create:after", {
+				tableName: this.tableName,
+				data,
+				entity
+			});
+			return entity;
+		} catch (error) {
+			throw this.handleError(error, "Insert query has failed");
+		}
+	}
+	/**
+	* Create many entities.
+	*
+	* 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");
+		}
+	}
+	/**
+	* Find an entity and update it.
+	*/
+	async updateOne(where, data, opts = {}) {
+		await this.alepha.events.emit("repository:update:before", {
+			tableName: this.tableName,
+			where,
+			data
+		});
+		let row = data;
+		const updatedAtField = getAttrFields(this.entity.schema, PG_UPDATED_AT)?.[0];
+		if (updatedAtField) row[updatedAtField.key] = this.dateTimeProvider.of(opts.now).toISOString();
+		where = this.withDeletedAt(where, opts);
+		row = this.cast(row, false);
+		delete row[this.id.key];
+		const response = await this.rawUpdate(opts).set(row).where(this.toSQL(where)).returning(this.table).catch((error) => {
+			throw this.handleError(error, "Update query has failed");
+		});
+		if (!response[0]) throw new DbEntityNotFoundError(this.tableName);
+		try {
+			const entity = this.clean(response[0], this.entity.schema);
+			await this.alepha.events.emit("repository:update:after", {
+				tableName: this.tableName,
+				where,
+				data,
+				entities: [entity]
+			});
+			return entity;
+		} catch (error) {
+			throw this.handleError(error, "Update query has failed");
+		}
+	}
+	/**
+	* Save a given entity.
+	*
+	* @example
+	* ```ts
+	* const entity = await repository.findById(1);
+	* entity.name = "New Name"; // update a field
+	* delete entity.description; // delete a field
+	* await repository.save(entity);
+	* ```
+	*
+	* Difference with `updateById/updateOne`:
+	*
+	* - requires the entity to be fetched first (whole object is expected)
+	* - check pg.version() if present -> optimistic locking
+	* - validate entity against schema
+	* - undefined values will be set to null, not ignored!
+	*
+	* @see {@link DbVersionMismatchError}
+	*/
+	async save(entity, opts = {}) {
+		const row = entity;
+		const id = row[this.id.key];
+		if (id == null) throw new AlephaError("Cannot save entity without ID - missing primary key in value");
+		for (const key of Object.keys(this.entity.schema.properties)) if (row[key] === void 0) row[key] = null;
+		let where = this.createQueryWhere();
+		where.id = { eq: id };
+		const versionField = getAttrFields(this.entity.schema, PG_VERSION)?.[0];
+		if (versionField && typeof row[versionField.key] === "number") {
+			where = { and: [where, { [versionField.key]: { eq: row[versionField.key] } }] };
+			row[versionField.key] += 1;
+		}
+		try {
+			const newValue = await this.updateOne(where, row, opts);
+			for (const key of Object.keys(this.entity.schema.properties)) row[key] = void 0;
+			Object.assign(row, newValue);
+		} catch (error) {
+			if (error instanceof DbEntityNotFoundError && versionField) try {
+				await this.findById(id);
+				throw new DbVersionMismatchError(this.tableName, id);
+			} catch (lookupError) {
+				if (lookupError instanceof DbEntityNotFoundError) throw error;
+				if (lookupError instanceof DbVersionMismatchError) throw lookupError;
+				throw lookupError;
+			}
+			throw error;
+		}
+	}
+	/**
+	* Find an entity by ID and update it.
+	*/
+	async updateById(id, data, opts = {}) {
+		return await this.updateOne(this.getWhereId(id), data, opts);
+	}
+	/**
+	* Find many entities and update all of them.
+	*/
+	async updateMany(where, data, opts = {}) {
+		await this.alepha.events.emit("repository:update:before", {
+			tableName: this.tableName,
+			where,
+			data
+		});
+		const updatedAtField = getAttrFields(this.entity.schema, PG_UPDATED_AT)?.[0];
+		if (updatedAtField) data[updatedAtField.key] = this.dateTimeProvider.of(opts.now).toISOString();
+		where = this.withDeletedAt(where, opts);
+		data = this.cast(data, false);
+		try {
+			const entities = await this.rawUpdate(opts).set(data).where(this.toSQL(where)).returning();
+			await this.alepha.events.emit("repository:update:after", {
+				tableName: this.tableName,
+				where,
+				data,
+				entities
+			});
+			return entities.map((it) => it[this.id.key]);
+		} catch (error) {
+			throw this.handleError(error, "Update query has failed");
+		}
+	}
+	/**
+	* Find many and delete all of them.
+	* @returns Array of deleted entity IDs
+	*/
+	async deleteMany(where = {}, opts = {}) {
+		const deletedAt = this.deletedAt();
+		if (deletedAt && !opts.force) return await this.updateMany(where, { [deletedAt.key]: opts.now ?? this.dateTimeProvider.nowISOString() }, opts);
+		await this.alepha.events.emit("repository:delete:before", {
+			tableName: this.tableName,
+			where
+		});
+		try {
+			const ids = (await this.rawDelete(opts).where(this.toSQL(where)).returning({ id: this.table[this.id.key] })).map((row) => row.id);
+			await this.alepha.events.emit("repository:delete:after", {
+				tableName: this.tableName,
+				where,
+				ids
+			});
+			return ids;
+		} catch (error) {
+			throw new DbError("Delete query has failed", error);
+		}
+	}
+	/**
+	* Delete all entities.
+	* @returns Array of deleted entity IDs
+	*/
+	clear(opts = {}) {
+		return this.deleteMany({}, opts);
+	}
+	/**
+	* Delete the given entity.
+	*
+	* You must fetch the entity first in order to delete it.
+	* @returns Array containing the deleted entity ID
+	*/
+	async destroy(entity, opts = {}) {
+		const id = entity[this.id.key];
+		if (id == null) throw new AlephaError("Cannot destroy entity without ID");
+		const deletedAt = this.deletedAt();
+		if (deletedAt && !opts.force) {
+			opts.now ??= this.dateTimeProvider.nowISOString();
+			entity[deletedAt.key] = opts.now;
+		}
+		return await this.deleteById(id, opts);
+	}
+	/**
+	* Find an entity and delete it.
+	* @returns Array of deleted entity IDs (should contain at most one ID)
+	*/
+	async deleteOne(where = {}, opts = {}) {
+		return await this.deleteMany(where, opts);
+	}
+	/**
+	* Find an entity by ID and delete it.
+	* @returns Array containing the deleted entity ID
+	* @throws DbEntityNotFoundError if the entity is not found
+	*/
+	async deleteById(id, opts = {}) {
+		const result = await this.deleteMany(this.getWhereId(id), opts);
+		if (result.length === 0) throw new DbEntityNotFoundError(`Entity with ID ${id} not found in ${this.tableName}`);
+		return result;
+	}
+	/**
+	* Count entities.
+	*/
+	async count(where = {}, opts = {}) {
+		where = this.withDeletedAt(where, opts);
+		return (opts.tx ?? this.db).$count(this.table, this.toSQL(where));
+	}
+	conflictMessagePattern = "duplicate key value violates unique constraint";
+	handleError(error, message) {
+		if (!(error instanceof Error)) return new DbError(message);
+		if (error.cause?.message.includes(this.conflictMessagePattern) || error.message.includes(this.conflictMessagePattern)) return new DbConflictError(message, error);
+		return new DbError(message, error);
+	}
+	withDeletedAt(where, opts = {}) {
+		if (opts.force) return where;
+		const deletedAt = this.deletedAt();
+		if (!deletedAt) return where;
+		return { and: [where, { [deletedAt.key]: { isNull: true } }] };
+	}
+	deletedAt() {
+		const deletedAtFields = getAttrFields(this.entity.schema, PG_DELETED_AT);
+		if (deletedAtFields.length > 0) return deletedAtFields[0];
+	}
+	/**
+	* Convert something to valid Pg Insert Value.
+	*/
+	cast(data, insert) {
+		const schema$1 = insert ? this.entity.insertSchema : 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();
+		}
+		return this.alepha.codec.decode(schema$1, row);
+	}
+	/**
+	* Clean a row with joins recursively
+	*/
+	cleanWithJoins(row, schema$1, joins, parentPath) {
+		const joinsAtThisLevel = joins.filter((j) => j.parent === parentPath);
+		const cleanRow = { ...row };
+		const joinedData = {};
+		for (const join of joinsAtThisLevel) {
+			joinedData[join.key] = cleanRow[join.key];
+			delete cleanRow[join.key];
+		}
+		const entity = this.clean(cleanRow, schema$1);
+		for (const join of joinsAtThisLevel) {
+			const joinedValue = joinedData[join.key];
+			if (joinedValue != null) {
+				const joinPath = parentPath ? `${parentPath}.${join.key}` : join.key;
+				if (joins.filter((j) => j.parent === joinPath).length > 0) entity[join.key] = this.cleanWithJoins(joinedValue, join.schema, joins, joinPath);
+				else entity[join.key] = this.clean(joinedValue, join.schema);
+			} else entity[join.key] = void 0;
+		}
+		return entity;
+	}
+	/**
+	* Convert a where clause to SQL.
+	*/
+	toSQL(where, joins) {
+		return this.queryManager.toSQL(where, {
+			schema: this.entity.schema,
+			col: (name) => {
+				return this.col(name);
+			},
+			joins,
+			dialect: this.provider.dialect
+		});
+	}
+	/**
+	* Get the where clause for an ID.
+	*
+	* @param id The ID to get the where clause for.
+	* @returns The where clause for the ID.
+	*/
+	getWhereId(id) {
+		return { [this.id.key]: { eq: 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;
+	}
+	getRepository(entity) {
+		const RepositoryClass = this.createClassRepository(entity);
+		return this.alepha.inject(RepositoryClass);
+	}
+	createClassRepository(entity) {
+		let name = entity.name.charAt(0).toUpperCase() + entity.name.slice(1);
+		if (name.endsWith("s")) name = name.slice(0, -1);
+		name = `${name}Repository`;
+		if (this.registry.has(entity)) return this.registry.get(entity);
+		class GenericRepository extends Repository {
+			constructor() {
+				super(entity);
+			}
+		}
+		Object.defineProperty(GenericRepository, "name", { value: name });
+		this.registry.set(entity, GenericRepository);
+		return GenericRepository;
+	}
+};
+
+//#endregion
+//#region ../../src/orm/helpers/parseQueryString.ts
+/**
+* Parse a string query into a PgQueryWhere object.
+*
+* Supported syntax:
+* - Simple equality: "name=John"
+* - Wildcard patterns: "name=John*" (startsWith), "name=*John" (endsWith), "name=*John*" (contains)
+* - Operators: "age>18", "age>=18", "age<65", "age<=65", "status!=active"
+* - NULL checks: "deletedAt=null", "email!=null"
+* - IN arrays: "status=[pending,active]"
+* - AND conditions: "name=John&age>18"
+* - OR conditions: "name=John|email=john@example.com"
+* - Nested AND/OR: "(name=John|name=Jane)&age>18"
+* - JSONB nested: "profile.city=Paris"
+*
+* @example
+* ```ts
+* // Simple equality
+* parseQueryString("name=John")
+* // => { name: { eq: "John" } }
+*
+* // Wildcard patterns
+* parseQueryString("name=John*")  // startsWith
+* // => { name: { startsWith: "John" } }
+* parseQueryString("name=*Smith")  // endsWith
+* // => { name: { endsWith: "Smith" } }
+* parseQueryString("name=*oh*")  // contains
+* // => { name: { contains: "oh" } }
+*
+* // Multiple conditions
+* parseQueryString("name=John&age>18")
+* // => { and: [{ name: { eq: "John" } }, { age: { gt: 18 } }] }
+*
+* // OR conditions
+* parseQueryString("status=active|status=pending")
+* // => { or: [{ status: { eq: "active" } }, { status: { eq: "pending" } }] }
+*
+* // Complex nested
+* parseQueryString("(name=John|name=Jane)&age>18&status!=archived")
+* // => { and: [
+* //      { or: [{ name: { eq: "John" } }, { name: { eq: "Jane" } }] },
+* //      { age: { gt: 18 } },
+* //      { status: { ne: "archived" } }
+* //    ] }
+*
+* // JSONB nested query
+* parseQueryString("profile.city=Paris&profile.age>25")
+* // => { profile: { city: { eq: "Paris" }, age: { gt: 25 } } }
+* ```
+*/
+function parseQueryString(query) {
+	if (!query || query.trim() === "") return {};
+	return new QueryStringParser(query).parse();
+}
+var QueryStringParser = class {
+	pos = 0;
+	query;
+	constructor(query) {
+		this.query = query.trim();
+	}
+	parse() {
+		return this.parseExpression();
+	}
+	parseExpression() {
+		return this.parseOr();
+	}
+	parseOr() {
+		const left = this.parseAnd();
+		if (this.peek() === "|") {
+			const conditions = [left];
+			while (this.peek() === "|") {
+				this.consume("|");
+				conditions.push(this.parseAnd());
+			}
+			return { or: conditions };
+		}
+		return left;
+	}
+	parseAnd() {
+		const left = this.parsePrimary();
+		if (this.peek() === "&") {
+			const conditions = [left];
+			while (this.peek() === "&") {
+				this.consume("&");
+				conditions.push(this.parsePrimary());
+			}
+			return { and: conditions };
+		}
+		return left;
+	}
+	parsePrimary() {
+		this.skipWhitespace();
+		if (this.peek() === "(") {
+			this.consume("(");
+			const expr = this.parseExpression();
+			this.consume(")");
+			return expr;
+		}
+		return this.parseCondition();
+	}
+	parseCondition() {
+		const field = this.parseFieldPath();
+		this.skipWhitespace();
+		const operator = this.parseOperator();
+		this.skipWhitespace();
+		const value = this.parseValue();
+		if (value === "") throw new AlephaError(`Expected value for field '${field.join(".")}'`);
+		return this.buildCondition(field, operator, value);
+	}
+	parseFieldPath() {
+		const path = [];
+		let current = "";
+		while (this.pos < this.query.length) {
+			const ch = this.query[this.pos];
+			if (ch === "." && current) {
+				path.push(current);
+				current = "";
+				this.pos++;
+				continue;
+			}
+			if (ch === "=" || ch === "!" || ch === ">" || ch === "<" || ch === " ") break;
+			current += ch;
+			this.pos++;
+		}
+		if (current) path.push(current);
+		return path;
+	}
+	parseOperator() {
+		this.skipWhitespace();
+		const remaining = this.query.slice(this.pos);
+		if (remaining.startsWith(">=")) {
+			this.pos += 2;
+			return ">=";
+		}
+		if (remaining.startsWith("<=")) {
+			this.pos += 2;
+			return "<=";
+		}
+		if (remaining.startsWith("!=")) {
+			this.pos += 2;
+			return "!=";
+		}
+		const ch = this.query[this.pos];
+		if (ch === "=" || ch === ">" || ch === "<") {
+			this.pos++;
+			return ch;
+		}
+		throw new Error(`Expected operator at position ${this.pos}`);
+	}
+	parseValue() {
+		this.skipWhitespace();
+		if (this.query.slice(this.pos, this.pos + 4).toLowerCase() === "null") {
+			this.pos += 4;
+			return null;
+		}
+		if (this.query[this.pos] === "[") return this.parseArray();
+		if (this.query[this.pos] === "\"" || this.query[this.pos] === "'") return this.parseQuotedString();
+		let value = "";
+		while (this.pos < this.query.length) {
+			const ch = this.query[this.pos];
+			if (ch === "&" || ch === "|" || ch === ")") break;
+			value += ch;
+			this.pos++;
+		}
+		return this.coerceValue(value.trim());
+	}
+	parseArray() {
+		this.consume("[");
+		const values = [];
+		while (this.pos < this.query.length && this.query[this.pos] !== "]") {
+			this.skipWhitespace();
+			if (this.query[this.pos] === "\"" || this.query[this.pos] === "'") values.push(this.parseQuotedString());
+			else {
+				let value = "";
+				while (this.pos < this.query.length && this.query[this.pos] !== "," && this.query[this.pos] !== "]") {
+					value += this.query[this.pos];
+					this.pos++;
+				}
+				values.push(this.coerceValue(value.trim()));
+			}
+			this.skipWhitespace();
+			if (this.query[this.pos] === ",") this.pos++;
+		}
+		this.consume("]");
+		return values;
+	}
+	parseQuotedString() {
+		const quote = this.query[this.pos];
+		this.pos++;
+		let value = "";
+		let escaped = false;
+		while (this.pos < this.query.length) {
+			const ch = this.query[this.pos];
+			if (escaped) {
+				value += ch;
+				escaped = false;
+				this.pos++;
+				continue;
+			}
+			if (ch === "\\") {
+				escaped = true;
+				this.pos++;
+				continue;
+			}
+			if (ch === quote) {
+				this.pos++;
+				break;
+			}
+			value += ch;
+			this.pos++;
+		}
+		return value;
+	}
+	coerceValue(value) {
+		if (/^-?\d+$/.test(value)) return parseInt(value, 10);
+		if (/^-?\d+\.\d+$/.test(value)) return parseFloat(value);
+		if (value.toLowerCase() === "true") return true;
+		if (value.toLowerCase() === "false") return false;
+		return value;
+	}
+	buildCondition(path, operator, value) {
+		let filterOp;
+		if (operator === "=") if (value === null) filterOp = { isNull: true };
+		else if (Array.isArray(value)) filterOp = { inArray: value };
+		else if (typeof value === "string" && value.includes("*")) {
+			const startsWithAsterisk = value.startsWith("*");
+			const endsWithAsterisk = value.endsWith("*");
+			const cleanValue = value.replace(/^\*|\*$/g, "");
+			if (startsWithAsterisk && endsWithAsterisk) filterOp = { contains: cleanValue };
+			else if (startsWithAsterisk) filterOp = { endsWith: cleanValue };
+			else if (endsWithAsterisk) filterOp = { startsWith: cleanValue };
+			else filterOp = { eq: value };
+		} else filterOp = { eq: value };
+		else if (operator === "!=") if (value === null) filterOp = { isNotNull: true };
+		else filterOp = { ne: value };
+		else if (operator === ">") filterOp = { gt: value };
+		else if (operator === ">=") filterOp = { gte: value };
+		else if (operator === "<") filterOp = { lt: value };
+		else if (operator === "<=") filterOp = { lte: value };
+		else throw new Error(`Unsupported operator: ${operator}`);
+		if (path.length === 1) return { [path[0]]: filterOp };
+		let result = filterOp;
+		for (let i = path.length - 1; i >= 0; i--) result = { [path[i]]: result };
+		return result;
+	}
+	peek() {
+		this.skipWhitespace();
+		return this.query[this.pos] || "";
+	}
+	consume(expected) {
+		this.skipWhitespace();
+		if (this.query[this.pos] !== expected) throw new Error(`Expected '${expected}' at position ${this.pos}, got '${this.query[this.pos]}'`);
+		this.pos++;
+	}
+	skipWhitespace() {
+		while (this.pos < this.query.length && /\s/.test(this.query[this.pos])) this.pos++;
+	}
+};
+/**
+* Helper function to build query strings programmatically
+*
+* @example
+* ```ts
+* buildQueryString({
+*   and: [
+*     { name: "eq:John" },
+*     { age: "gt:18" }
+*   ]
+* })
+* // => "name=John&age>18"
+* ```
+*/
+function buildQueryString(where) {
+	if (!where || typeof where !== "object") return "";
+	if ("and" in where && Array.isArray(where.and)) return where.and.map((w) => buildQueryString(w)).join("&");
+	if ("or" in where && Array.isArray(where.or)) {
+		const parts$1 = where.or.map((w) => buildQueryString(w));
+		return parts$1.length > 1 ? `(${parts$1.join("|")})` : parts$1[0];
+	}
+	if ("not" in where) return "";
+	const parts = [];
+	for (const [field, condition] of Object.entries(where)) {
+		if (typeof condition !== "object" || condition === null) {
+			parts.push(`${field}=${condition}`);
+			continue;
+		}
+		if ("eq" in condition) parts.push(`${field}=${condition.eq}`);
+		else if ("ne" in condition) parts.push(`${field}!=${condition.ne}`);
+		else if ("gt" in condition) parts.push(`${field}>${condition.gt}`);
+		else if ("gte" in condition) parts.push(`${field}>=${condition.gte}`);
+		else if ("lt" in condition) parts.push(`${field}<${condition.lt}`);
+		else if ("lte" in condition) parts.push(`${field}<=${condition.lte}`);
+		else if ("contains" in condition) parts.push(`${field}=*${condition.contains}*`);
+		else if ("startsWith" in condition) parts.push(`${field}=${condition.startsWith}*`);
+		else if ("endsWith" in condition) parts.push(`${field}=*${condition.endsWith}`);
+		else if ("isNull" in condition && condition.isNull) parts.push(`${field}=null`);
+		else if ("isNotNull" in condition && condition.isNotNull) parts.push(`${field}!=null`);
+		else if ("inArray" in condition && Array.isArray(condition.inArray)) {
+			const values = condition.inArray.map((v) => typeof v === "string" ? `"${v}"` : v);
+			parts.push(`${field}=[${values.join(",")}]`);
+		} else {
+			const nested = buildQueryString(condition);
+			if (nested) parts.push(`${field}.${nested}`);
+		}
+	}
+	return parts.join("&");
+}
+
+//#endregion
+//#region ../../src/orm/providers/DatabaseTypeProvider.ts
+var DatabaseTypeProvider = class {
+	attr = pgAttr;
+	/**
+	* Creates a primary key with an identity column.
+	*/
+	identityPrimaryKey = (identity, options) => pgAttr(pgAttr(pgAttr(t.integer(options), PG_PRIMARY_KEY), PG_IDENTITY, identity), PG_DEFAULT);
+	/**
+	* Creates a primary key with a big identity column. (default)
+	*/
+	bigIdentityPrimaryKey = (identity, options) => pgAttr(pgAttr(pgAttr(t.int64(options), PG_PRIMARY_KEY), PG_IDENTITY, identity), PG_DEFAULT);
+	/**
+	* Creates a primary key with a UUID column.
+	*/
+	uuidPrimaryKey = () => pgAttr(pgAttr(t.uuid(), PG_PRIMARY_KEY), PG_DEFAULT);
+	primaryKey(type, options, identity) {
+		if (!type || t.schema.isInteger(type)) return pgAttr(pgAttr(pgAttr(t.integer(options), PG_PRIMARY_KEY), PG_IDENTITY, identity), PG_DEFAULT);
+		if (t.schema.isString(type) && type.format === "uuid") return pgAttr(pgAttr(t.uuid(), PG_PRIMARY_KEY), PG_DEFAULT);
+		if (t.schema.isNumber(type) && type.format === "int64") return pgAttr(pgAttr(pgAttr(t.number(options), PG_PRIMARY_KEY), PG_IDENTITY, identity), PG_DEFAULT);
+		if (t.schema.isBigInt(type)) return pgAttr(pgAttr(pgAttr(t.bigint(options), PG_PRIMARY_KEY), PG_IDENTITY, identity), PG_DEFAULT);
+		throw new AlephaError(`Unsupported type for primary key: ${type}`);
+	}
+	/**
+	* Wrap a schema with "default" attribute.
+	* This is used to set a default value for a column in the database.
+	*/
+	default = (type, value) => {
+		if (value != null) Object.assign(type, { default: value });
+		return this.attr(type, PG_DEFAULT);
+	};
+	/**
+	* Creates a column 'version'.
+	*
+	* This is used to track the version of a row in the database.
+	*
+	* You can use it for optimistic concurrency control (OCC) with {@link RepositoryPrimitive#save}.
+	*
+	* @see {@link RepositoryPrimitive#save}
+	* @see {@link PgVersionMismatchError}
+	*/
+	version = (options = {}) => this.default(pgAttr(t.integer(options), PG_VERSION), 0);
+	/**
+	* Creates a column Created At. So just a datetime column with a default value of the current timestamp.
+	*/
+	createdAt = (options) => pgAttr(pgAttr(t.datetime(options), PG_CREATED_AT), PG_DEFAULT);
+	/**
+	* Creates a column Updated At. Like createdAt, but it is updated on every update of the row.
+	*/
+	updatedAt = (options) => pgAttr(pgAttr(t.datetime(options), PG_UPDATED_AT), PG_DEFAULT);
+	/**
+	* Creates a column Deleted At for soft delete functionality.
+	* This is used to mark rows as deleted without actually removing them from the database.
+	* The column is nullable - NULL means not deleted, timestamp means deleted.
+	*/
+	deletedAt = (options) => pgAttr(t.optional(t.datetime(options)), PG_DELETED_AT);
+	/**
+	* Creates a Postgres ENUM type.
+	*
+	* > By default, `t.enum()` is mapped to a TEXT column in Postgres.
+	* > Using this method, you can create a real ENUM type in the database.
+	*
+	* @example
+	* ```ts
+	* const statusEnum = pg.enum(["pending", "active", "archived"], { name: "status_enum" });
+	* ```
+	*/
+	enum = (values, pgEnumOptions, typeOptions) => {
+		return pgAttr(t.enum(values, {
+			description: pgEnumOptions?.description,
+			...typeOptions
+		}), PG_ENUM, pgEnumOptions);
+	};
+	/**
+	* Creates a reference to another table or schema. Basically a foreign key.
+	*/
+	ref = (type, ref, actions) => {
+		const finalActions = actions ?? { onDelete: t.schema.isOptional(type) ? "set null" : "cascade" };
+		return this.attr(type, PG_REF, {
+			ref,
+			actions: finalActions
+		});
+	};
+	/**
+	* Creates a page schema for a given object schema.
+	* It's used by {@link Repository#paginate} method.
+	*/
+	page = (resource, options) => {
+		return pageSchema$1(resource, options);
+	};
+};
+/**
+* Wrapper of TypeProvider (`t`) for database types.
+*
+* Use `db` for improve TypeBox schema definitions with database-specific attributes.
+*
+* @example
+* ```ts
+* import { t } from "alepha";
+* import { db } from "alepha/orm";
+*
+* const userSchema = t.object({
+*   id: db.primaryKey(t.uuid()),
+*   email: t.email(),
+*   createdAt: db.createdAt(),
+* });
+* ```
+*/
+const db = new DatabaseTypeProvider();
+/**
+* @deprecated Use `db` instead.
+*/
+const pg = db;
+
+//#endregion
+//#region ../../src/orm/schemas/legacyIdSchema.ts
+/**
+* @deprecated Use `pg.primaryKey()` instead.
+*/
+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.bun.ts
+var index_bun_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,
+	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,
+	pageQuerySchema: () => pageQuerySchema,
+	pageSchema: () => pageSchema,
+	parseQueryString: () => parseQueryString,
+	pg: () => pg,
+	pgAttr: () => pgAttr,
+	schema: () => schema,
+	sql: () => sql,
+	updateSchema: () => updateSchema
+});
+const AlephaPostgres = $module({
+	name: "alepha.postgres",
+	primitives: [$sequence, $entity],
+	services: [
+		AlephaDateTime,
+		DatabaseProvider,
+		BunPostgresProvider,
+		BunSqliteProvider,
+		PglitePostgresProvider,
+		CloudflareD1Provider,
+		SqliteModelBuilder,
+		PostgresModelBuilder,
+		DrizzleKitProvider,
+		RepositoryProvider,
+		Repository,
+		PgRelationManager,
+		QueryManager
+	],
+	register: (alepha) => {
+		const env = alepha.parseEnv(t.object({ DATABASE_URL: t.optional(t.text()) }));
+		alepha.with(DrizzleKitProvider);
+		alepha.with(RepositoryProvider);
+		const url = env.DATABASE_URL;
+		const isPostgres = url?.startsWith("postgres:");
+		if (url?.startsWith("cloudflare-d1:")) {
+			alepha.with({
+				optional: true,
+				provide: DatabaseProvider,
+				use: CloudflareD1Provider
+			});
+			return;
+		}
+		if (isPostgres) {
+			alepha.with({
+				optional: true,
+				provide: DatabaseProvider,
+				use: BunPostgresProvider
+			});
+			return;
+		}
+		alepha.with({
+			optional: true,
+			provide: DatabaseProvider,
+			use: BunSqliteProvider
+		});
+	}
+});
+
+//#endregion
+export { $entity, $repository, $sequence, $transaction, AlephaPostgres, BunPostgresProvider, BunSqliteProvider, CloudflareD1Provider, DatabaseProvider, DatabaseTypeProvider, DbConflictError, DbEntityNotFoundError, DbError, DbMigrationError, DbVersionMismatchError, DrizzleKitProvider, EntityPrimitive, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, Repository, RepositoryProvider, SequencePrimitive, buildQueryString, bunSqliteOptions, db, drizzle, getAttrFields, insertSchema, legacyIdSchema, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
+//# sourceMappingURL=index.bun.js.map