alepha 0.13.8 → 0.14.1

package/dist/orm/index.js

@@ -9,14 +9,14 @@ import { mkdir, readFile, stat, writeFile } from "node:fs/promises";
 import { $logger } from "alepha/logger";
 import { isSQLWrapper as isSQLWrapper$1 } from "drizzle-orm/sql/sql";
 import { $lock } from "alepha/lock";
+import { randomUUID } from "node:crypto";
+import * as pg$1 from "drizzle-orm/sqlite-core";
+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 { drizzle as drizzle$1 } from "drizzle-orm/postgres-js";
 import { migrate } from "drizzle-orm/postgres-js/migrator";
 import postgres from "postgres";
 import { drizzle as drizzle$2 } from "drizzle-orm/sqlite-proxy";
 import { migrate as migrate$1 } from "drizzle-orm/sqlite-proxy/migrator";
-import { 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 as migrate$2 } from "drizzle-orm/pglite/migrator";
 import { $retry } from "alepha/retry";
 
@@ -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) {
@@ -1957,27 +1713,39 @@ var PostgresModelBuilder = class extends ModelBuilder {
 };
 
 //#endregion
-//#region ../../src/orm/providers/drivers/NodePostgresProvider.ts
-const envSchema$2 = t.object({
+//#region ../../src/orm/providers/drivers/BunPostgresProvider.ts
+const envSchema$4 = t.object({
 	DATABASE_URL: t.optional(t.text()),
 	POSTGRES_SCHEMA: t.optional(t.text())
 });
-var NodePostgresProvider = class NodePostgresProvider extends DatabaseProvider {
-	static SSL_MODES = [
-		"require",
-		"allow",
-		"prefer",
-		"verify-full"
-	];
+/**
+* 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);
+	env = $env(envSchema$4);
 	kit = $inject(DrizzleKitProvider);
 	builder = $inject(PostgresModelBuilder);
 	client;
-	pg;
+	bunDb;
 	dialect = "postgresql";
 	get name() {
-		return "postgres";
+		return "bun-postgres";
 	}
 	/**
 	* In testing mode, the schema name will be generated and deleted after the test.
@@ -2009,11 +1777,12 @@ var NodePostgresProvider = class NodePostgresProvider extends DatabaseProvider {
 	* Get the Drizzle Postgres database instance.
 	*/
 	get db() {
-		if (!this.pg) throw new AlephaError("Database not initialized");
-		return this.pg;
+		if (!this.bunDb) throw new AlephaError("Database not initialized");
+		return this.bunDb;
 	}
 	async executeMigrations(migrationsFolder) {
-		await migrate(this.db, { migrationsFolder });
+		const { migrate: migrate$3 } = await import("drizzle-orm/bun-sql/migrator");
+		await migrate$3(this.bunDb, { migrationsFolder });
 	}
 	onStart = $hook({
 		on: "start",
@@ -2040,55 +1809,31 @@ var NodePostgresProvider = class NodePostgresProvider extends DatabaseProvider {
 	});
 	async connect() {
 		this.log.debug("Connect ..");
-		const client = postgres(this.getClientOptions());
-		await client`SELECT 1`;
-		this.client = client;
-		this.pg = drizzle$1(client, { logger: { logQuery: (query, params) => {
-			this.log.trace(query, { params });
-		} } });
+		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");
 	}
 	async close() {
 		if (this.client) {
 			this.log.debug("Close...");
-			await this.client.end();
+			await this.client.close();
 			this.client = void 0;
-			this.pg = void 0;
+			this.bunDb = void 0;
 			this.log.info("Connection closed");
 		}
 	}
 	migrate = $lock({ handler: async () => {
 		await this.migrateDatabase();
 	} });
-	/**
-	* Map the DATABASE_URL to postgres client options.
-	*/
-	getClientOptions() {
-		const url = new URL(this.url);
-		return {
-			host: url.hostname,
-			user: decodeURIComponent(url.username),
-			database: decodeURIComponent(url.pathname.replace("/", "")),
-			password: decodeURIComponent(url.password),
-			port: Number(url.port || 5432),
-			ssl: this.ssl(url),
-			onnotice: () => {}
-		};
-	}
-	ssl(url) {
-		const mode = url.searchParams.get("sslmode");
-		for (const it of NodePostgresProvider.SSL_MODES) if (mode === it) return it;
-	}
-	/**
-	* For testing purposes, generate a unique schema name.
-	* The schema name will be generated based on the current date and time.
-	* It will be in the format of `test_YYYYMMDD_HHMMSS_randomSuffix`.
-	*/
-	generateTestSchemaName() {
-		const pad = (n) => n.toString().padStart(2, "0");
-		const now = /* @__PURE__ */ new Date();
-		return `test_${`${now.getUTCFullYear()}${pad(now.getUTCMonth() + 1)}${pad(now.getUTCDate())}_${pad(now.getUTCHours())}${pad(now.getUTCMinutes())}${pad(now.getUTCSeconds())}`}_${Math.random().toString(36).slice(2, 6)}`;
-	}
 };
 
 //#endregion
@@ -2219,6 +1964,310 @@ var SqliteModelBuilder = class extends ModelBuilder {
 	});
 };
 
+//#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);
+			}
+			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");
+			}
+		}
+	});
+	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
+//#region ../../src/orm/providers/drivers/NodePostgresProvider.ts
+const envSchema$2 = t.object({
+	DATABASE_URL: t.optional(t.text()),
+	POSTGRES_SCHEMA: t.optional(t.text())
+});
+var NodePostgresProvider = class NodePostgresProvider extends DatabaseProvider {
+	static SSL_MODES = [
+		"require",
+		"allow",
+		"prefer",
+		"verify-full"
+	];
+	log = $logger();
+	env = $env(envSchema$2);
+	kit = $inject(DrizzleKitProvider);
+	builder = $inject(PostgresModelBuilder);
+	client;
+	pg;
+	dialect = "postgresql";
+	get name() {
+		return "postgres";
+	}
+	/**
+	* 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.pg) throw new AlephaError("Database not initialized");
+		return this.pg;
+	}
+	async executeMigrations(migrationsFolder) {
+		await migrate(this.db, { migrationsFolder });
+	}
+	onStart = $hook({
+		on: "start",
+		handler: async () => {
+			await this.connect();
+			if (!this.alepha.isServerless()) try {
+				await this.migrate.run();
+			} catch (error) {
+				throw new DbMigrationError(error);
+			}
+		}
+	});
+	onStop = $hook({
+		on: "stop",
+		handler: async () => {
+			if (this.alepha.isTest() && this.schemaForTesting && this.schemaForTesting.startsWith("test_")) {
+				if (!/^test_[a-z0-9_]+$/i.test(this.schemaForTesting)) throw new AlephaError(`Invalid test schema name: ${this.schemaForTesting}. Must match pattern: test_[a-z0-9_]+`);
+				this.log.warn(`Deleting test schema '${this.schemaForTesting}' ...`);
+				await this.execute(sql$1`DROP SCHEMA IF EXISTS ${sql$1.raw(this.schemaForTesting)} CASCADE`);
+				this.log.info(`Test schema '${this.schemaForTesting}' deleted`);
+			}
+			await this.close();
+		}
+	});
+	async connect() {
+		this.log.debug("Connect ..");
+		const client = postgres(this.getClientOptions());
+		await client`SELECT 1`;
+		this.client = client;
+		this.pg = drizzle$1(client, { logger: { logQuery: (query, params) => {
+			this.log.trace(query, { params });
+		} } });
+		this.log.info("Connection OK");
+	}
+	async close() {
+		if (this.client) {
+			this.log.debug("Close...");
+			await this.client.end();
+			this.client = void 0;
+			this.pg = void 0;
+			this.log.info("Connection closed");
+		}
+	}
+	migrate = $lock({ handler: async () => {
+		await this.migrateDatabase();
+	} });
+	/**
+	* Map the DATABASE_URL to postgres client options.
+	*/
+	getClientOptions() {
+		const url = new URL(this.url);
+		return {
+			host: url.hostname,
+			user: decodeURIComponent(url.username),
+			database: decodeURIComponent(url.pathname.replace("/", "")),
+			password: decodeURIComponent(url.password),
+			port: Number(url.port || 5432),
+			ssl: this.ssl(url),
+			onnotice: () => {}
+		};
+	}
+	ssl(url) {
+		const mode = url.searchParams.get("sslmode");
+		for (const it of NodePostgresProvider.SSL_MODES) if (mode === it) return it;
+	}
+};
+
 //#endregion
 //#region ../../src/orm/providers/drivers/NodeSqliteProvider.ts
 const envSchema$1 = t.object({ DATABASE_URL: t.optional(t.text()) });
@@ -2289,7 +2338,7 @@ var NodeSqliteProvider = class extends DatabaseProvider {
 		on: "start",
 		handler: async () => {
 			const { DatabaseSync } = await import("node:sqlite");
-			const filepath = this.url.replace("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);
@@ -2861,13 +2910,15 @@ const AlephaPostgres = $module({
 		NodePostgresProvider,
 		PglitePostgresProvider,
 		NodeSqliteProvider,
+		BunPostgresProvider,
+		BunSqliteProvider,
+		CloudflareD1Provider,
 		SqliteModelBuilder,
 		PostgresModelBuilder,
 		DrizzleKitProvider,
 		RepositoryProvider,
 		Repository,
 		PgRelationManager,
-		PgJsonQueryManager,
 		QueryManager
 	],
 	register: (alepha) => {
@@ -2879,7 +2930,16 @@ const AlephaPostgres = $module({
 		const isPostgres = url?.startsWith("postgres:");
 		const isSqlite = url?.startsWith("sqlite:");
 		const isMemory = url?.includes(":memory:");
-		if (hasPGlite && (isMemory || !!url && !isPostgres && !isMemory || !url) && !isSqlite) {
+		const isFile = !!url && !isPostgres && !isMemory;
+		if (url?.startsWith("cloudflare-d1:")) {
+			alepha.with({
+				optional: true,
+				provide: DatabaseProvider,
+				use: CloudflareD1Provider
+			});
+			return;
+		}
+		if (hasPGlite && (isMemory || isFile || !url) && !isSqlite) {
 			alepha.with({
 				optional: true,
 				provide: DatabaseProvider,
@@ -2891,18 +2951,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, 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, 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, bunSqliteOptions, drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
 //# sourceMappingURL=index.js.map