alepha 0.14.0 → 0.14.2

package/dist/orm/index.js

@@ -3,15 +3,15 @@ import { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaErr
 import { AlephaDateTime, DateTimeProvider } from "alepha/datetime";
 import * as drizzle from "drizzle-orm";
 import { and, arrayContained, arrayContains, arrayOverlaps, asc, between, desc, eq, getTableName, gt, gte, ilike, inArray, isNotNull, isNull, isSQLWrapper, like, lt, lte, ne, not, notBetween, notIlike, notInArray, notLike, or, sql, sql as sql$1 } from "drizzle-orm";
-import * as pg$1 from "drizzle-orm/pg-core";
+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 { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { $logger } from "alepha/logger";
 import { isSQLWrapper as isSQLWrapper$1 } from "drizzle-orm/sql/sql";
+import { $lock } from "alepha/lock";
 import { randomUUID } from "node:crypto";
-import * as pg$2 from "drizzle-orm/sqlite-core";
+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 { $lock } from "alepha/lock";
 import { drizzle as drizzle$1 } from "drizzle-orm/postgres-js";
 import { migrate } from "drizzle-orm/postgres-js/migrator";
 import postgres from "postgres";
@@ -289,6 +289,16 @@ var DatabaseProvider = class {
 			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
@@ -353,233 +363,9 @@ var PgRelationManager = class {
 	}
 };
 
-//#endregion
-//#region ../../src/orm/services/PgJsonQueryManager.ts
-/**
-* Manages JSONB query generation for nested object and array queries in PostgreSQL.
-* This class handles complex nested queries using PostgreSQL's JSONB operators.
-*/
-var PgJsonQueryManager = class {
-	/**
-	* Check if a query contains nested JSONB queries.
-	* A nested query is when the value is an object with operator keys.
-	*/
-	hasNestedQuery(where) {
-		for (const [key, value] of Object.entries(where)) {
-			if (key === "and" || key === "or" || key === "not") continue;
-			if (value && typeof value === "object" && !Array.isArray(value)) {
-				const keys = Object.keys(value);
-				if (!keys.some((k) => [
-					"eq",
-					"ne",
-					"gt",
-					"gte",
-					"lt",
-					"lte",
-					"like",
-					"ilike",
-					"isNull",
-					"isNotNull",
-					"inArray",
-					"notInArray"
-				].includes(k)) && keys.length > 0) return true;
-			}
-		}
-		return false;
-	}
-	/**
-	* Build a JSONB query condition for nested object queries.
-	* Supports deep nesting like: { profile: { contact: { email: { eq: "test@example.com" } } } }
-	*
-	* @param column The JSONB column
-	* @param path The path to the nested property (e.g., ['profile', 'contact', 'email'])
-	* @param operator The filter operator (e.g., { eq: "test@example.com" })
-	* @param dialect Database dialect (postgresql or sqlite)
-	* @param columnSchema Optional schema of the JSON column for type inference
-	* @returns SQL condition
-	*/
-	buildJsonbCondition(column, path, operator, dialect, columnSchema) {
-		if (path.length === 0) return;
-		const isArrayOperator = operator.arrayContains !== void 0 || operator.arrayContained !== void 0 || operator.arrayOverlaps !== void 0;
-		let jsonValue;
-		if (dialect === "sqlite") jsonValue = sql$1`json_extract(${column}, ${`$.${path.join(".")}`})`;
-		else {
-			let jsonPath = sql$1`${column}`;
-			for (let i = 0; i < path.length - 1; i++) jsonPath = sql$1`${jsonPath}->${path[i]}`;
-			const lastPath = path[path.length - 1];
-			if (isArrayOperator) jsonValue = sql$1`${jsonPath}->${lastPath}`;
-			else jsonValue = sql$1`${jsonPath}->>${lastPath}`;
-		}
-		const fieldType = columnSchema ? this.getFieldType(columnSchema, path) : void 0;
-		return this.applyOperatorToJsonValue(jsonValue, operator, dialect, fieldType);
-	}
-	/**
-	* Build JSONB array query conditions.
-	* Supports queries like: { addresses: { city: { eq: "Wonderland" } } }
-	* which translates to: EXISTS (SELECT 1 FROM jsonb_array_elements(addresses) elem WHERE elem->>'city' = 'Wonderland')
-	*
-	* @param dialect Database dialect (postgresql or sqlite)
-	* Note: SQLite array queries are not yet supported
-	*/
-	buildJsonbArrayCondition(column, path, arrayPath, operator, dialect) {
-		if (dialect === "sqlite") throw new Error("Array queries in JSON columns are not yet supported for SQLite. Please use PostgreSQL for complex JSON array queries, or restructure your data.");
-		if (path.length === 0) return;
-		let jsonPath = sql$1`${column}`;
-		if (arrayPath) jsonPath = sql$1`${jsonPath}->${arrayPath}`;
-		const elemCondition = sql$1`elem->>${path[0]}`;
-		const condition = this.applyOperatorToJsonValue(elemCondition, operator, dialect);
-		if (!condition) return;
-		return sql$1`EXISTS (SELECT 1 FROM jsonb_array_elements(${jsonPath}) AS elem WHERE ${condition})`;
-	}
-	/**
-	* Apply a filter operator to a JSONB value.
-	* @param dialect Database dialect for appropriate casting syntax
-	* @param fieldType Optional field type from schema for smart casting
-	*/
-	applyOperatorToJsonValue(jsonValue, operator, dialect, fieldType) {
-		const castForNumeric = (value) => {
-			if (dialect === "sqlite") {
-				if (fieldType === "integer" || fieldType === "int") return sql$1`CAST(${value} AS INTEGER)`;
-				return sql$1`CAST(${value} AS REAL)`;
-			}
-			return sql$1`(${value})::numeric`;
-		};
-		if (typeof operator !== "object") return sql$1`${jsonValue} = ${operator}`;
-		const conditions = [];
-		if (operator.eq !== void 0) conditions.push(sql$1`${jsonValue} = ${operator.eq}`);
-		if (operator.ne !== void 0) conditions.push(sql$1`${jsonValue} != ${operator.ne}`);
-		if (operator.gt !== void 0) conditions.push(sql$1`${castForNumeric(jsonValue)} > ${operator.gt}`);
-		if (operator.gte !== void 0) conditions.push(sql$1`${castForNumeric(jsonValue)} >= ${operator.gte}`);
-		if (operator.lt !== void 0) conditions.push(sql$1`${castForNumeric(jsonValue)} < ${operator.lt}`);
-		if (operator.lte !== void 0) conditions.push(sql$1`${castForNumeric(jsonValue)} <= ${operator.lte}`);
-		if (operator.like !== void 0) conditions.push(sql$1`${jsonValue} LIKE ${operator.like}`);
-		if (operator.ilike !== void 0) if (dialect === "sqlite") conditions.push(sql$1`${jsonValue} LIKE ${operator.ilike}`);
-		else conditions.push(sql$1`${jsonValue} ILIKE ${operator.ilike}`);
-		if (operator.notLike !== void 0) conditions.push(sql$1`${jsonValue} NOT LIKE ${operator.notLike}`);
-		if (operator.notIlike !== void 0) if (dialect === "sqlite") conditions.push(sql$1`${jsonValue} NOT LIKE ${operator.notIlike}`);
-		else conditions.push(sql$1`${jsonValue} NOT ILIKE ${operator.notIlike}`);
-		if (operator.isNull !== void 0) conditions.push(sql$1`${jsonValue} IS NULL`);
-		if (operator.isNotNull !== void 0) conditions.push(sql$1`${jsonValue} IS NOT NULL`);
-		if (operator.inArray !== void 0 && Array.isArray(operator.inArray)) conditions.push(sql$1`${jsonValue} IN (${sql$1.join(operator.inArray.map((v) => sql$1`${v}`), sql$1`, `)})`);
-		if (operator.notInArray !== void 0 && Array.isArray(operator.notInArray)) conditions.push(sql$1`${jsonValue} NOT IN (${sql$1.join(operator.notInArray.map((v) => sql$1`${v}`), sql$1`, `)})`);
-		if (operator.arrayContains !== void 0) {
-			if (dialect === "postgresql") {
-				const jsonArray = JSON.stringify(Array.isArray(operator.arrayContains) ? operator.arrayContains : [operator.arrayContains]);
-				conditions.push(sql$1`${jsonValue} @> ${jsonArray}::jsonb`);
-			}
-		}
-		if (operator.arrayContained !== void 0) {
-			if (dialect === "postgresql") {
-				const jsonArray = JSON.stringify(Array.isArray(operator.arrayContained) ? operator.arrayContained : [operator.arrayContained]);
-				conditions.push(sql$1`${jsonValue} <@ ${jsonArray}::jsonb`);
-			}
-		}
-		if (operator.arrayOverlaps !== void 0) {
-			if (dialect === "postgresql") {
-				const overlapConditions = (Array.isArray(operator.arrayOverlaps) ? operator.arrayOverlaps : [operator.arrayOverlaps]).map((val) => {
-					return sql$1`${jsonValue} @> ${JSON.stringify(val)}::jsonb`;
-				});
-				if (overlapConditions.length > 0) conditions.push(sql$1`(${sql$1.join(overlapConditions, sql$1` OR `)})`);
-			}
-		}
-		if (conditions.length === 0) return;
-		if (conditions.length === 1) return conditions[0];
-		return sql$1.join(conditions, sql$1` AND `);
-	}
-	/**
-	* Parse a nested query object and extract the path and operator.
-	* For example: { profile: { contact: { email: { eq: "test@example.com" } } } }
-	* Returns: { path: ['profile', 'contact', 'email'], operator: { eq: "test@example.com" } }
-	*/
-	parseNestedQuery(nestedQuery, currentPath = []) {
-		const results = [];
-		for (const [key, value] of Object.entries(nestedQuery)) if (value && typeof value === "object" && !Array.isArray(value)) if (Object.keys(value).some((k) => [
-			"eq",
-			"ne",
-			"gt",
-			"gte",
-			"lt",
-			"lte",
-			"like",
-			"ilike",
-			"notLike",
-			"notIlike",
-			"isNull",
-			"isNotNull",
-			"inArray",
-			"notInArray",
-			"arrayContains",
-			"arrayContained",
-			"arrayOverlaps"
-		].includes(k))) results.push({
-			path: [...currentPath, key],
-			operator: value
-		});
-		else {
-			const nestedResults = this.parseNestedQuery(value, [...currentPath, key]);
-			results.push(...nestedResults);
-		}
-		return results;
-	}
-	/**
-	* Determine if a property is a JSONB column based on the schema.
-	* A column is JSONB if it's defined as an object or array in the TypeBox schema.
-	*/
-	isJsonbColumn(schema$1, columnName) {
-		const property = schema$1.properties[columnName];
-		if (!property) return false;
-		return property.type === "object" || property.type === "array";
-	}
-	/**
-	* Check if an array property contains primitive types (string, number, boolean, etc.)
-	* rather than objects. Primitive arrays should use native Drizzle operators.
-	* @returns true if the array contains primitives, false if it contains objects
-	*/
-	isPrimitiveArray(schema$1, columnName) {
-		const property = schema$1.properties[columnName];
-		if (!property || property.type !== "array") return false;
-		const items = property.items;
-		if (!items) return false;
-		const itemType = items.type;
-		return itemType === "string" || itemType === "number" || itemType === "integer" || itemType === "boolean" || itemType === "null";
-	}
-	/**
-	* Get the type of a field by navigating through a schema path.
-	* Used for smart type casting in SQL queries.
-	*
-	* @param columnSchema The schema of the JSON column (e.g., t.object({ age: t.integer() }))
-	* @param path The path to navigate (e.g., ['contact', 'email'])
-	* @returns The type string (e.g., 'integer', 'number', 'string') or undefined if not found
-	*/
-	getFieldType(columnSchema, path) {
-		let current = columnSchema;
-		for (const segment of path) if (current.type === "object" && current.properties) {
-			current = current.properties[segment];
-			if (!current) return;
-		} else return;
-		return current.type;
-	}
-	/**
-	* Check if a nested path points to an array property.
-	*/
-	isArrayProperty(schema$1, path) {
-		if (path.length === 0) return false;
-		let currentSchema = schema$1.properties[path[0]];
-		if (!currentSchema) return false;
-		if (currentSchema.type === "array") return true;
-		for (let i = 1; i < path.length; i++) if (currentSchema.type === "object" && currentSchema.properties) {
-			currentSchema = currentSchema.properties[path[i]];
-			if (!currentSchema) return false;
-			if (currentSchema.type === "array") return true;
-		} else return false;
-		return false;
-	}
-};
-
 //#endregion
 //#region ../../src/orm/services/QueryManager.ts
 var QueryManager = class {
-	jsonQueryManager = $inject(PgJsonQueryManager);
 	alepha = $inject(Alepha);
 	/**
 	* Convert a query object to a SQL query.
@@ -639,11 +425,7 @@ var QueryManager = class {
 					});
 					if (where) return not(where);
 				}
-				if (operator) if (this.jsonQueryManager.isJsonbColumn(schema$1, key) && !this.jsonQueryManager.isPrimitiveArray(schema$1, key) && typeof operator === "object" && !Array.isArray(operator) && this.jsonQueryManager.hasNestedQuery({ [key]: operator })) {
-					const column = col(key);
-					const jsonbSql = this.buildJsonbQuery(column, operator, schema$1, key, options.dialect);
-					if (jsonbSql) conditions.push(jsonbSql);
-				} else {
+				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);
@@ -654,32 +436,6 @@ var QueryManager = class {
 		return and(...conditions);
 	}
 	/**
-	* Build a JSONB query for nested object/array queries.
-	*/
-	buildJsonbQuery(column, nestedQuery, schema$1, columnName, dialect) {
-		const queries = this.jsonQueryManager.parseNestedQuery(nestedQuery);
-		if (queries.length === 0) return;
-		const columnSchema = schema$1.properties[columnName];
-		const conditions = [];
-		for (const { path, operator } of queries) {
-			const isArrayOperator = operator.arrayContains !== void 0 || operator.arrayContained !== void 0 || operator.arrayOverlaps !== void 0;
-			const isArrayProp = this.jsonQueryManager.isArrayProperty(schema$1, [columnName, ...path]);
-			if (isArrayProp && isArrayOperator) {
-				const condition = this.jsonQueryManager.buildJsonbCondition(column, path, operator, dialect, columnSchema);
-				if (condition) conditions.push(condition);
-			} else if (isArrayProp && !isArrayOperator) {
-				const condition = this.jsonQueryManager.buildJsonbArrayCondition(column, path, "", operator, dialect);
-				if (condition) conditions.push(condition);
-			} else {
-				const condition = this.jsonQueryManager.buildJsonbCondition(column, path, operator, dialect, columnSchema);
-				if (condition) conditions.push(condition);
-			}
-		}
-		if (conditions.length === 0) return;
-		if (conditions.length === 1) return conditions[0];
-		return and(...conditions);
-	}
-	/**
 	* Check if an object has any filter operator properties.
 	*/
 	hasFilterOperatorProperties(obj) {
@@ -947,11 +703,11 @@ var Repository = class {
 	* Start a SELECT DISTINCT query on the table.
 	*/
 	rawSelectDistinct(opts = {}, columns = []) {
-		const db = opts.tx ?? this.db;
+		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.selectDistinct(fields).from(table);
+		return db$1.selectDistinct(fields).from(table);
 	}
 	/**
 	* Start an INSERT query on the table.
@@ -1690,6 +1446,22 @@ const devMigrationsSchema = t.object({
 	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
 /**
@@ -1783,39 +1555,52 @@ var ModelBuilder = class {
 };
 
 //#endregion
-//#region ../../src/orm/services/SqliteModelBuilder.ts
-var SqliteModelBuilder = class extends ModelBuilder {
+//#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 table = sqliteTable(tableName, this.schemaToSqliteColumns(tableName, entity.schema, options.enums, options.tables), this.getTableConfig(entity, options.tables));
+		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) {
-		throw new AlephaError("SQLite does not support sequences");
+		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 SQLite-specific config builder for the table.
+	* Get PostgreSQL-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 pgBuilders = {
+			index,
+			uniqueIndex,
+			unique,
+			check,
+			foreignKey
 		};
 		const tableResolver = (entityName) => {
 			return tables.get(entityName);
 		};
-		return this.buildTableConfig(entity, sqliteBuilders, tableResolver, (config, self) => {
-			const customConfigs = config(self);
-			return Array.isArray(customConfigs) ? customConfigs : [];
-		});
+		return this.buildTableConfig(entity, pgBuilders, tableResolver);
 	}
-	schemaToSqliteColumns = (tableName, schema$1, enums, tables) => {
+	schemaToPgColumns = (tableName, schema$1, nsp, enums, tables) => {
 		return Object.entries(schema$1.properties).reduce((columns, [key, value]) => {
-			let col = this.mapFieldToSqliteColumn(tableName, key, value, enums);
+			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) {
@@ -1836,219 +1621,255 @@ var SqliteModelBuilder = class extends ModelBuilder {
 			};
 		}, {});
 	};
-	mapFieldToSqliteColumn = (tableName, fieldName, value, enums) => {
+	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 || PG_IDENTITY in value) return pg$2.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
+			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_PRIMARY_KEY in value || PG_IDENTITY in value) return pg$2.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
-			return pg$2.integer(key, { mode: "number" });
+			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) return pg$2.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
+			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.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.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 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.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 (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$2.text(key).primaryKey().$defaultFn(() => randomUUID());
-			return pg$2.text(key);
+		if (isTypeEnum(value)) {
+			if (!value.enum.every((it) => typeof it === "string")) throw new AlephaError(`Enum for ${fieldName} must be an array of strings, got ${JSON.stringify(value.enum)}`);
+			if (PG_ENUM in value && value[PG_ENUM]) {
+				const enumName = value[PG_ENUM].name ?? `${tableName}_${key}_enum`;
+				if (enums.has(enumName)) {
+					const values = enums.get(enumName).enumValues.join(",");
+					const newValues = value.enum.join(",");
+					if (values !== newValues) throw new AlephaError(`Enum name conflict for ${enumName}: [${values}] vs [${newValues}]`);
+				}
+				enums.set(enumName, nsp.enum(enumName, value.enum));
+				return enums.get(enumName)(key);
+			}
+			return this.mapStringToColumn(key, value);
 		}
-		if (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, {});
+		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" });
 		}
-		if (value.format === "date") return this.sqliteDate(key, {});
 		return pg$2.text(key);
 	};
-	sqliteJson = (name, document) => pg$2.customType({
-		dataType: () => "text",
-		toDriver: (value) => JSON.stringify(value),
-		fromDriver: (value) => {
-			return value && typeof value === "string" ? JSON.parse(value) : value;
-		}
-	})(name, { document }).$type();
-	sqliteDateTime = pg$2.customType({
-		dataType: () => "integer",
-		toDriver: (value) => new Date(value).getTime(),
-		fromDriver: (value) => {
-			return new Date(value).toISOString();
-		}
-	});
-	sqliteBool = pg$2.customType({
-		dataType: () => "integer",
-		toDriver: (value) => value ? 1 : 0,
-		fromDriver: (value) => value === 1
-	});
-	sqliteDate = pg$2.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/CloudflareD1Provider.ts
+//#region ../../src/orm/providers/drivers/BunPostgresProvider.ts
+const envSchema$4 = t.object({
+	DATABASE_URL: t.optional(t.text()),
+	POSTGRES_SCHEMA: t.optional(t.text())
+});
 /**
-* Cloudflare D1 SQLite provider using Drizzle ORM.
+* Bun PostgreSQL provider using Drizzle ORM with Bun's native SQL client.
 *
-* This provider requires a D1 binding to be set via `cloudflareD1Options` before starting.
-* The binding is typically obtained from the Cloudflare Workers environment.
+* This provider uses Bun's built-in SQL class for PostgreSQL connections,
+* which provides excellent performance on the Bun runtime.
 *
 * @example
 * ```ts
-* // In your Cloudflare Worker
-* alepha.set(cloudflareD1Options, { binding: env.DB });
+* // Set DATABASE_URL environment variable
+* // DATABASE_URL=postgres://user:password@localhost:5432/database
+*
+* // Or configure programmatically
+* alepha.with({
+*   provide: DatabaseProvider,
+*   use: BunPostgresProvider,
+* });
 * ```
 */
-var CloudflareD1Provider = class extends DatabaseProvider {
-	kit = $inject(DrizzleKitProvider);
+var BunPostgresProvider = class extends DatabaseProvider {
 	log = $logger();
-	builder = $inject(SqliteModelBuilder);
-	env = $env(t.object({ DATABASE_URL: t.string({ description: "Expect to be 'cloudflare-d1://name:id'" }) }));
-	d1;
-	drizzleDb;
+	env = $env(envSchema$4);
+	kit = $inject(DrizzleKitProvider);
+	builder = $inject(PostgresModelBuilder);
+	client;
+	bunDb;
+	dialect = "postgresql";
 	get name() {
-		return "d1";
+		return "bun-postgres";
 	}
-	dialect = "sqlite";
+	/**
+	* 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.drizzleDb) throw new AlephaError("D1 database not initialized");
-		return this.drizzleDb;
+		if (!this.bunDb) throw new AlephaError("Database not initialized");
+		return this.bunDb;
 	}
-	async execute(query) {
-		const { rows } = await this.db.run(query);
-		return rows;
+	async executeMigrations(migrationsFolder) {
+		const { migrate: migrate$3 } = await import("drizzle-orm/bun-sql/migrator");
+		await migrate$3(this.bunDb, { migrationsFolder });
 	}
 	onStart = $hook({
 		on: "start",
 		handler: async () => {
-			const [bindingName] = this.env.DATABASE_URL.replace("cloudflare-d1://", "").split(":");
-			const cloudflareEnv = this.alepha.store.get("cloudflare.env");
-			if (!cloudflareEnv) throw new AlephaError("Cloudflare Workers environment not found in Alepha store under 'cloudflare.env'.");
-			const binding = cloudflareEnv[bindingName];
-			if (!binding) throw new AlephaError(`D1 binding '${bindingName}' not found in Cloudflare Workers environment.`);
-			this.d1 = binding;
-			const { drizzle: drizzle$3 } = await import("drizzle-orm/d1");
-			this.drizzleDb = drizzle$3(this.d1);
-			await this.migrateDatabase();
-			this.log.info("Using Cloudflare D1 database");
+			await this.connect();
+			if (!this.alepha.isServerless()) try {
+				await this.migrate.run();
+			} catch (error) {
+				throw new DbMigrationError(error);
+			}
 		}
 	});
-	async executeMigrations(migrationsFolder) {
-		const { migrate: migrate$3 } = await import("drizzle-orm/d1/migrator");
-		await migrate$3(this.db, { migrationsFolder });
-	}
-	/**
-	* Override development migration to skip sync (not supported on D1).
-	* D1 requires proper migrations to be applied.
-	*/
-	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");
+	onStop = $hook({
+		on: "stop",
+		handler: async () => {
+			if (this.alepha.isTest() && this.schemaForTesting && this.schemaForTesting.startsWith("test_")) {
+				if (!/^test_[a-z0-9_]+$/i.test(this.schemaForTesting)) throw new AlephaError(`Invalid test schema name: ${this.schemaForTesting}. Must match pattern: test_[a-z0-9_]+`);
+				this.log.warn(`Deleting test schema '${this.schemaForTesting}' ...`);
+				await this.execute(sql$1`DROP SCHEMA IF EXISTS ${sql$1.raw(this.schemaForTesting)} CASCADE`);
+				this.log.info(`Test schema '${this.schemaForTesting}' deleted`);
+			}
+			await this.close();
 		}
+	});
+	async connect() {
+		this.log.debug("Connect ..");
+		if (typeof Bun === "undefined") throw new AlephaError("BunPostgresProvider requires the Bun runtime. Use NodePostgresProvider for Node.js.");
+		const { drizzle: drizzle$3 } = await import("drizzle-orm/bun-sql");
+		const { SQL: SQL$1 } = await import("bun");
+		this.client = new SQL$1(this.url);
+		await this.client.unsafe("SELECT 1");
+		this.bunDb = drizzle$3({
+			client: this.client,
+			logger: { logQuery: (query, params) => {
+				this.log.trace(query, { params });
+			} }
+		});
+		this.log.info("Connection OK");
 	}
-};
-
-//#endregion
-//#region ../../src/orm/errors/DbMigrationError.ts
-var DbMigrationError = class extends DbError {
-	name = "DbMigrationError";
-	constructor(cause) {
-		super("Failed to migrate database", cause);
+	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");
+		}
 	}
+	migrate = $lock({ handler: async () => {
+		await this.migrateDatabase();
+	} });
 };
 
 //#endregion
-//#region ../../src/orm/types/byte.ts
-/**
-* Postgres bytea type.
-*/
-const byte = customType({ dataType: () => "bytea" });
-
-//#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;
-	}
+//#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 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);
+		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) {
-		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));
+		throw new AlephaError("SQLite does not support sequences");
 	}
 	/**
-	* Get PostgreSQL-specific config builder for the table.
+	* Get SQLite-specific config builder for the table.
 	*/
 	getTableConfig(entity, tables) {
-		const pgBuilders = {
-			index,
-			uniqueIndex,
-			unique,
-			check,
-			foreignKey
+		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, pgBuilders, tableResolver);
+		return this.buildTableConfig(entity, sqliteBuilders, tableResolver, (config, self) => {
+			const customConfigs = config(self);
+			return Array.isArray(customConfigs) ? customConfigs : [];
+		});
 	}
-	schemaToPgColumns = (tableName, schema$1, nsp, enums, tables) => {
+	schemaToSqliteColumns = (tableName, schema$1, enums, tables) => {
 		return Object.entries(schema$1.properties).reduce((columns, [key, value]) => {
-			let col = this.mapFieldToColumn(tableName, key, value, nsp, enums);
+			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) {
@@ -2069,95 +1890,257 @@ var PostgresModelBuilder = class extends ModelBuilder {
 			};
 		}, {});
 	};
-	mapFieldToColumn = (tableName, fieldName, value, nsp, enums) => {
+	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) return pg$1.serial(key);
-			if (PG_IDENTITY in value) {
-				const options = value[PG_IDENTITY];
-				if (options.mode === "byDefault") return pg$1.integer().generatedByDefaultAsIdentity(options);
-				return pg$1.integer().generatedAlwaysAsIdentity(options);
-			}
+			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_IDENTITY in value) {
-				const options = value[PG_IDENTITY];
-				if (options.mode === "byDefault") return pg$1.bigint({ mode: "bigint" }).generatedByDefaultAsIdentity(options);
-				return pg$1.bigint({ mode: "bigint" }).generatedAlwaysAsIdentity(options);
-			}
+			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) {
-				const options = value[PG_IDENTITY];
-				if (options.mode === "byDefault") return pg$1.bigint({ mode: "number" }).generatedByDefaultAsIdentity(options);
-				return pg$1.bigint({ mode: "number" }).generatedAlwaysAsIdentity(options);
-			}
-			if (value.format === "int64") return pg$1.bigint(key, { mode: "number" });
+			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.mapStringToColumn(key, value);
-		if (t.schema.isBoolean(value)) return pg$1.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.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 schema(key, value);
-			if (t.schema.isRecord(value.items)) return schema(key, value);
-			if (t.schema.isString(value.items)) return pg$1.text(key).array();
-			if (t.schema.isInteger(value.items)) return pg$1.integer(key).array();
-			if (t.schema.isNumber(value.items)) return pg$1.numeric(key).array();
-			if (t.schema.isBoolean(value.items)) return pg$1.boolean(key).array();
-			if (isTypeEnum(value.items)) return pg$1.text(key).array();
+			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 (isTypeEnum(value)) {
-			if (!value.enum.every((it) => typeof it === "string")) throw new AlephaError(`Enum for ${fieldName} must be an array of strings, got ${JSON.stringify(value.enum)}`);
-			if (PG_ENUM in value && value[PG_ENUM]) {
-				const enumName = value[PG_ENUM].name ?? `${tableName}_${key}_enum`;
-				if (enums.has(enumName)) {
-					const values = enums.get(enumName).enumValues.join(",");
-					const newValues = value.enum.join(",");
-					if (values !== newValues) throw new AlephaError(`Enum name conflict for ${enumName}: [${values}] vs [${newValues}]`);
-				}
-				enums.set(enumName, nsp.enum(enumName, value.enum));
-				return enums.get(enumName)(key);
-			}
-			return this.mapStringToColumn(key, value);
+		if (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);
 		}
-		throw new AlephaError(`Unsupported schema type for ${fieldName} as ${JSON.stringify(value)}`);
+		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);
 	};
-	/**
-	* 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$1.uuid(key).defaultRandom();
-				return pg$1.uuid(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$3 = t.object({ DATABASE_URL: t.optional(t.text()) });
+/**
+* Configuration options for the Bun SQLite database provider.
+*/
+const bunSqliteOptions = $atom({
+	name: "alepha.postgres.bun-sqlite.options",
+	schema: t.object({ path: t.optional(t.string({ description: "Filepath or :memory:. If empty, provider will use DATABASE_URL from env." })) }),
+	default: {}
+});
+/**
+* Bun SQLite provider using Drizzle ORM with Bun's native SQLite client.
+*
+* This provider uses Bun's built-in `bun:sqlite` for SQLite connections,
+* which provides excellent performance on the Bun runtime.
+*
+* @example
+* ```ts
+* // Set DATABASE_URL environment variable
+* // DATABASE_URL=sqlite://./my-database.db
+*
+* // Or configure programmatically
+* alepha.with({
+*   provide: DatabaseProvider,
+*   use: BunSqliteProvider,
+* });
+*
+* // Or use options atom
+* alepha.store.mut(bunSqliteOptions, (old) => ({
+*   ...old,
+*   path: ":memory:",
+* }));
+* ```
+*/
+var BunSqliteProvider = class extends DatabaseProvider {
+	kit = $inject(DrizzleKitProvider);
+	log = $logger();
+	env = $env(envSchema$3);
+	builder = $inject(SqliteModelBuilder);
+	options = $use(bunSqliteOptions);
+	sqlite;
+	bunDb;
+	get name() {
+		return "bun-sqlite";
+	}
+	dialect = "sqlite";
+	get url() {
+		const path = this.options.path ?? this.env.DATABASE_URL;
+		if (path) {
+			if (path.startsWith("postgres://")) throw new AlephaError("Postgres URL is not supported for SQLite provider.");
+			return path;
+		}
+		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$3 } = await import("drizzle-orm/bun-sqlite");
+			const filepath = this.url.replace("sqlite://", "").replace("sqlite:", "");
+			if (filepath !== ":memory:" && filepath !== "") {
+				const dirname = filepath.split("/").slice(0, -1).join("/");
+				if (dirname) await mkdir(dirname, { recursive: true }).catch(() => null);
 			}
-			if (value.format === "byte") return byte(key);
-			if (value.format === "date-time") {
-				if (PG_CREATED_AT in value) return pg$1.timestamp(key, {
-					mode: "string",
-					withTimezone: true
-				}).defaultNow();
-				if (PG_UPDATED_AT in value) return pg$1.timestamp(key, {
-					mode: "string",
-					withTimezone: true
-				}).defaultNow();
-				return pg$1.timestamp(key, {
-					mode: "string",
-					withTimezone: true
-				});
+			this.sqlite = new Database(filepath);
+			this.bunDb = drizzle$3({
+				client: this.sqlite,
+				logger: { logQuery: (query, params) => {
+					this.log.trace(query, { params });
+				} }
+			});
+			await this.migrateDatabase();
+			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");
 			}
-			if (value.format === "date") return pg$1.date(key, { mode: "string" });
 		}
-		return pg$1.text(key);
-	};
+	});
+	async executeMigrations(migrationsFolder) {
+		const { migrate: migrate$3 } = await import("drizzle-orm/bun-sqlite/migrator");
+		await migrate$3(this.bunDb, { migrationsFolder });
+	}
+};
+
+//#endregion
+//#region ../../src/orm/providers/drivers/CloudflareD1Provider.ts
+/**
+* Cloudflare D1 SQLite provider using Drizzle ORM.
+*
+* This provider requires a D1 binding to be set via `cloudflareD1Options` before starting.
+* The binding is typically obtained from the Cloudflare Workers environment.
+*
+* @example
+* ```ts
+* // In your Cloudflare Worker
+* alepha.set(cloudflareD1Options, { binding: env.DB });
+* ```
+*/
+var CloudflareD1Provider = class extends DatabaseProvider {
+	kit = $inject(DrizzleKitProvider);
+	log = $logger();
+	builder = $inject(SqliteModelBuilder);
+	env = $env(t.object({ DATABASE_URL: t.string({ description: "Expect to be 'cloudflare-d1://name:id'" }) }));
+	d1;
+	drizzleDb;
+	get name() {
+		return "d1";
+	}
+	dialect = "sqlite";
+	get url() {
+		return this.env.DATABASE_URL;
+	}
+	get db() {
+		if (!this.drizzleDb) throw new AlephaError("D1 database not initialized");
+		return this.drizzleDb;
+	}
+	async execute(query) {
+		const { rows } = await this.db.run(query);
+		return rows;
+	}
+	onStart = $hook({
+		on: "start",
+		handler: async () => {
+			const [bindingName] = this.env.DATABASE_URL.replace("cloudflare-d1://", "").split(":");
+			const cloudflareEnv = this.alepha.store.get("cloudflare.env");
+			if (!cloudflareEnv) throw new AlephaError("Cloudflare Workers environment not found in Alepha store under 'cloudflare.env'.");
+			const binding = cloudflareEnv[bindingName];
+			if (!binding) throw new AlephaError(`D1 binding '${bindingName}' not found in Cloudflare Workers environment.`);
+			this.d1 = binding;
+			const { drizzle: drizzle$3 } = await import("drizzle-orm/d1");
+			this.drizzleDb = drizzle$3(this.d1);
+			await this.migrateDatabase();
+			this.log.info("Using Cloudflare D1 database");
+		}
+	});
+	async executeMigrations(migrationsFolder) {
+		const { migrate: migrate$3 } = await import("drizzle-orm/d1/migrator");
+		await migrate$3(this.db, { migrationsFolder });
+	}
+	/**
+	* Override development migration to skip sync (not supported on D1).
+	* D1 requires proper migrations to be applied.
+	*/
+	async runDevelopmentMigration(migrationsFolder) {
+		await this.executeMigrations(migrationsFolder);
+	}
+	/**
+	* Override test migration to run migrations instead of sync.
+	* D1 doesn't support schema synchronization.
+	*/
+	async runTestMigration() {
+		const migrationsFolder = this.getMigrationsFolder();
+		try {
+			await this.executeMigrations(migrationsFolder);
+		} catch {
+			this.log.warn("D1 migrations failed in test environment - ensure migrations exist");
+		}
+	}
 };
 
 //#endregion
@@ -2283,16 +2266,6 @@ var NodePostgresProvider = class NodePostgresProvider extends DatabaseProvider {
 		const mode = url.searchParams.get("sslmode");
 		for (const it of NodePostgresProvider.SSL_MODES) if (mode === it) return it;
 	}
-	/**
-	* For testing purposes, generate a unique schema name.
-	* The schema name will be generated based on the current date and time.
-	* It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
-	*/
-	generateTestSchemaName() {
-		const pad = (n) => n.toString().padStart(2, "0");
-		const now = /* @__PURE__ */ new Date();
-		return `test_${`${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}_${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`}_${Math.random().toString(36).slice(2, 6)}`;
-	}
 };
 
 //#endregion
@@ -2788,8 +2761,8 @@ const $transaction = (opts) => {
 };
 
 //#endregion
-//#region ../../src/orm/providers/PostgresTypeProvider.ts
-var PostgresTypeProvider = class {
+//#region ../../src/orm/providers/DatabaseTypeProvider.ts
+var DatabaseTypeProvider = class {
 	attr = pgAttr;
 	/**
 	* Creates a primary key with an identity column.
@@ -2872,13 +2845,34 @@ var PostgresTypeProvider = class {
 	};
 	/**
 	* Creates a page schema for a given object schema.
-	* It's used by {@link RepositoryPrimitive#paginate} method.
+	* It's used by {@link Repository#paginate} method.
 	*/
 	page = (resource, options) => {
 		return pageSchema$1(resource, options);
 	};
 };
-const pg = new PostgresTypeProvider();
+/**
+* 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
@@ -2893,21 +2887,25 @@ const legacyIdSchema = pgAttr(pgAttr(pgAttr(t.integer(), PG_PRIMARY_KEY), PG_SER
 * Postgres client based on Drizzle ORM, Alepha type-safe friendly.
 *
 * ```ts
+* import { t } from "alepha";
+* import { $entity, $repository, db } from "alepha/postgres";
+*
 * const users = $entity({
 *   name: "users",
 *   schema: t.object({
-*     id: pg.primaryKey(),
+*     id: db.primaryKey(),
 *     name: t.text(),
 *     email: t.text(),
 *   }),
 * });
 *
-* class Db {
+* class App {
 *   users = $repository(users);
-* }
 *
-* const db = alepha.inject(Db);
-* const user = await db.users.one({ name: { eq: "John Doe" } });
+*   getUserByName(name: string) {
+*     return this.users.findOne({ name: { eq: name } });
+*   }
+* }
 * ```
 *
 * This is not a full ORM, but rather a set of tools to work with Postgres databases in a type-safe way.
@@ -2937,6 +2935,8 @@ const AlephaPostgres = $module({
 		NodePostgresProvider,
 		PglitePostgresProvider,
 		NodeSqliteProvider,
+		BunPostgresProvider,
+		BunSqliteProvider,
 		CloudflareD1Provider,
 		SqliteModelBuilder,
 		PostgresModelBuilder,
@@ -2944,7 +2944,6 @@ const AlephaPostgres = $module({
 		RepositoryProvider,
 		Repository,
 		PgRelationManager,
-		PgJsonQueryManager,
 		QueryManager
 	],
 	register: (alepha) => {
@@ -2977,18 +2976,18 @@ const AlephaPostgres = $module({
 			alepha.with({
 				optional: true,
 				provide: DatabaseProvider,
-				use: NodePostgresProvider
+				use: alepha.isBun() ? BunPostgresProvider : NodePostgresProvider
 			});
 			return;
 		}
 		alepha.with({
 			optional: true,
 			provide: DatabaseProvider,
-			use: NodeSqliteProvider
+			use: alepha.isBun() ? BunSqliteProvider : NodeSqliteProvider
 		});
 	}
 });
 
 //#endregion
-export { $entity, $repository, $sequence, $transaction, AlephaPostgres, CloudflareD1Provider, DatabaseProvider, DbConflictError, DbEntityNotFoundError, DbError, DbMigrationError, DbVersionMismatchError, DrizzleKitProvider, EntityPrimitive, NodePostgresProvider, NodeSqliteProvider, PG_CREATED_AT, PG_DEFAULT, PG_DELETED_AT, PG_ENUM, PG_IDENTITY, PG_PRIMARY_KEY, PG_REF, PG_SERIAL, PG_UPDATED_AT, PG_VERSION, PostgresTypeProvider, Repository, RepositoryProvider, SequencePrimitive, buildQueryString, drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
+export { $entity, $repository, $sequence, $transaction, AlephaPostgres, BunPostgresProvider, BunSqliteProvider, CloudflareD1Provider, DatabaseProvider, DatabaseTypeProvider, DbConflictError, DbEntityNotFoundError, DbError, DbMigrationError, DbVersionMismatchError, DrizzleKitProvider, EntityPrimitive, NodePostgresProvider, NodeSqliteProvider, 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, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
 //# sourceMappingURL=index.js.map