alepha 0.13.8 → 0.14.0

package/dist/orm/index.js

@@ -3,20 +3,20 @@ 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$2 from "drizzle-orm/pg-core";
+import * as pg$1 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 { randomUUID } from "node:crypto";
+import * as pg$2 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";
 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";
 
@@ -1690,22 +1690,6 @@ 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
 /**
@@ -1798,6 +1782,226 @@ var ModelBuilder = class {
 	}
 };
 
+//#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$2.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
+			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 (t.schema.isNumber(value)) {
+			if (PG_IDENTITY in value) return pg$2.integer(key, { mode: "number" }).primaryKey({ autoIncrement: true });
+			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.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$2.text(key).primaryKey().$defaultFn(() => randomUUID());
+			return pg$2.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$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
+/**
+* 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/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/PostgresModelBuilder.ts
 var PostgresModelBuilder = class extends ModelBuilder {
@@ -1869,43 +2073,43 @@ var PostgresModelBuilder = class extends ModelBuilder {
 		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_SERIAL in value) return pg$1.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);
+				if (options.mode === "byDefault") return pg$1.integer().generatedByDefaultAsIdentity(options);
+				return pg$1.integer().generatedAlwaysAsIdentity(options);
 			}
-			return pg$2.integer(key);
+			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$2.bigint({ mode: "bigint" }).generatedByDefaultAsIdentity(options);
-				return pg$2.bigint({ mode: "bigint" }).generatedAlwaysAsIdentity(options);
+				if (options.mode === "byDefault") return pg$1.bigint({ mode: "bigint" }).generatedByDefaultAsIdentity(options);
+				return pg$1.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 (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$2.bigint(key, { mode: "number" });
-			return pg$2.numeric(key);
+			if (value.format === "int64") return pg$1.bigint(key, { mode: "number" });
+			return pg$1.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.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.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 (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 (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)}`);
@@ -1932,27 +2136,27 @@ var PostgresModelBuilder = class extends ModelBuilder {
 	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 (PG_PRIMARY_KEY in value) return pg$1.uuid(key).defaultRandom();
+				return pg$1.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, {
+				if (PG_CREATED_AT in value) return pg$1.timestamp(key, {
 					mode: "string",
 					withTimezone: true
 				}).defaultNow();
-				if (PG_UPDATED_AT in value) return pg$2.timestamp(key, {
+				if (PG_UPDATED_AT in value) return pg$1.timestamp(key, {
 					mode: "string",
 					withTimezone: true
 				}).defaultNow();
-				return pg$2.timestamp(key, {
+				return pg$1.timestamp(key, {
 					mode: "string",
 					withTimezone: true
 				});
 			}
-			if (value.format === "date") return pg$2.date(key, { mode: "string" });
+			if (value.format === "date") return pg$1.date(key, { mode: "string" });
 		}
-		return pg$2.text(key);
+		return pg$1.text(key);
 	};
 };
 
@@ -2091,134 +2295,6 @@ var NodePostgresProvider = class NodePostgresProvider extends DatabaseProvider {
 	}
 };
 
-//#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/NodeSqliteProvider.ts
 const envSchema$1 = t.object({ DATABASE_URL: t.optional(t.text()) });
@@ -2289,7 +2365,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,6 +2937,7 @@ const AlephaPostgres = $module({
 		NodePostgresProvider,
 		PglitePostgresProvider,
 		NodeSqliteProvider,
+		CloudflareD1Provider,
 		SqliteModelBuilder,
 		PostgresModelBuilder,
 		DrizzleKitProvider,
@@ -2879,7 +2956,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,
@@ -2904,5 +2990,5 @@ const AlephaPostgres = $module({
 });
 
 //#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, 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 };
 //# sourceMappingURL=index.js.map