alepha 0.15.0 → 0.15.2

package/dist/orm/index.js

@@ -1,4 +1,4 @@
-import { n as __reExport, t as __exportAll } from "./chunk-DtkW-qnP.js";
+import { n as __reExport, t as __exportAll } from "./chunk-DH6iiROE.js";
 import { createRequire } from "node:module";
 import { $atom, $context, $env, $hook, $inject, $module, $use, Alepha, AlephaError, KIND, Primitive, Value, createPagination, createPrimitive, pageQuerySchema, pageSchema, pageSchema as pageSchema$1, t } from "alepha";
 import { AlephaDateTime, DateTimeProvider } from "alepha/datetime";
@@ -63,14 +63,14 @@ const insertSchema = (obj) => {
 
 //#endregion
 //#region ../../src/orm/schemas/updateSchema.ts
-const updateSchema = (schema$1) => {
+const updateSchema = (schema) => {
 	const newProperties = {};
-	for (const key in schema$1.properties) {
-		const prop = schema$1.properties[key];
+	for (const key in schema.properties) {
+		const prop = schema.properties[key];
 		if (t.schema.isOptional(prop)) newProperties[key] = t.optional(t.union([prop, t.raw.Null()]));
 		else newProperties[key] = prop;
 	}
-	return t.object(newProperties, "options" in schema$1 && typeof schema$1.options === "object" ? { ...schema$1.options } : {});
+	return t.object(newProperties, "options" in schema && typeof schema.options === "object" ? { ...schema.options } : {});
 };
 
 //#endregion
@@ -101,10 +101,10 @@ var EntityPrimitive = class EntityPrimitive {
 	constructor(options) {
 		this.options = options;
 	}
-	alias(alias$1) {
+	alias(alias) {
 		const aliased = new EntityPrimitive(this.options);
 		return new Proxy(aliased, { get(target, prop, receiver) {
-			if (prop === "$alias") return alias$1;
+			if (prop === "$alias") return alias;
 			return Reflect.get(target, prop, receiver);
 		} });
 	}
@@ -170,8 +170,8 @@ var DatabaseProvider = class {
 	registerSequence(sequence) {
 		this.builder.buildSequence(sequence, this);
 	}
-	async run(statement, schema$1) {
-		return (await this.execute(statement)).map((row) => this.alepha.codec.decode(schema$1, row));
+	async run(statement, schema) {
+		return (await this.execute(statement)).map((row) => this.alepha.codec.decode(schema, row));
 	}
 	/**
 	* Get migrations folder path - can be overridden
@@ -294,7 +294,7 @@ var DrizzleKitProvider = class {
 			await this.executeStatements(statements, provider, true);
 			await this.saveDevMigrations(provider, snapshot, entry);
 		}
-		this.log.info(`Db '${provider.name}' synchronization OK [${Date.now() - now}ms]`);
+		this.log.info(`Sync with '${provider.name}' OK [${Date.now() - now}ms]`);
 	}
 	/**
 	* Mostly used for testing purposes. You can generate SQL migration statements without executing them.
@@ -304,16 +304,16 @@ var DrizzleKitProvider = class {
 		const models = this.getModels(provider);
 		if (Object.keys(models).length > 0) {
 			if (provider.dialect === "sqlite") {
-				const prev$1 = prevSnapshot ?? await kit.generateSQLiteDrizzleJson({});
-				const curr$1 = await kit.generateSQLiteDrizzleJson(models);
+				const prev = prevSnapshot ?? await kit.generateSQLiteDrizzleJson({});
+				const curr = await kit.generateSQLiteDrizzleJson(models);
 				return {
 					models,
-					statements: await kit.generateSQLiteMigration(prev$1, curr$1),
-					snapshot: curr$1
+					statements: await kit.generateSQLiteMigration(prev, curr),
+					snapshot: curr
 				};
 			}
-			const prev = prevSnapshot ?? await kit.generateDrizzleJson({});
-			const curr = await kit.generateDrizzleJson(models);
+			const prev = prevSnapshot ?? kit.generateDrizzleJson({});
+			const curr = kit.generateDrizzleJson(models);
 			return {
 				models,
 				statements: await kit.generateMigration(prev, curr),
@@ -600,8 +600,8 @@ var PostgresModelBuilder = class extends ModelBuilder {
 		};
 		return this.buildTableConfig(entity, pgBuilders, tableResolver);
 	}
-	schemaToPgColumns = (tableName, schema$1, nsp, enums, tables) => {
-		return Object.entries(schema$1.properties).reduce((columns, [key, value]) => {
+	schemaToPgColumns = (tableName, schema, nsp, enums, tables) => {
+		return Object.entries(schema.properties).reduce((columns, [key, value]) => {
 			let col = this.mapFieldToColumn(tableName, key, value, nsp, enums);
 			if ("default" in value && value.default != null) col = col.default(value.default);
 			if (PG_PRIMARY_KEY in value) col = col.primaryKey();
@@ -616,7 +616,7 @@ var PostgresModelBuilder = class extends ModelBuilder {
 					return target;
 				}, config.actions);
 			}
-			if (schema$1.required?.includes(key)) col = col.notNull();
+			if (schema.required?.includes(key)) col = col.notNull();
 			return {
 				...columns,
 				[key]: col
@@ -655,7 +655,7 @@ var PostgresModelBuilder = class extends ModelBuilder {
 		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);
+		const isTypeEnum = (value) => t.schema.isUnsafe(value) && "type" in value && value.type === "string" && "enum" in value && Array.isArray(value.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);
@@ -783,8 +783,8 @@ var BunPostgresProvider = class extends DatabaseProvider {
 		return this.bunDb;
 	}
 	async executeMigrations(migrationsFolder) {
-		const { migrate: migrate$3 } = await import("drizzle-orm/bun-sql/migrator");
-		await migrate$3(this.bunDb, { migrationsFolder });
+		const { migrate } = await import("drizzle-orm/bun-sql/migrator");
+		await migrate(this.bunDb, { migrationsFolder });
 	}
 	onStart = $hook({
 		on: "start",
@@ -812,10 +812,10 @@ var BunPostgresProvider = class extends DatabaseProvider {
 	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 { drizzle } = await import("drizzle-orm/bun-sql");
 		this.client = new Bun.SQL(this.url);
 		await this.client.unsafe("SELECT 1");
-		this.bunDb = drizzle$3({
+		this.bunDb = drizzle({
 			client: this.client,
 			logger: { logQuery: (query, params) => {
 				this.log.trace(query, { params });
@@ -868,8 +868,8 @@ var SqliteModelBuilder = class extends ModelBuilder {
 			return Array.isArray(customConfigs) ? customConfigs : [];
 		});
 	}
-	schemaToSqliteColumns = (tableName, schema$1, enums, tables) => {
-		return Object.entries(schema$1.properties).reduce((columns, [key, value]) => {
+	schemaToSqliteColumns = (tableName, schema, enums, tables) => {
+		return Object.entries(schema.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();
@@ -884,7 +884,7 @@ var SqliteModelBuilder = class extends ModelBuilder {
 					return target;
 				}, config.actions);
 			}
-			if (schema$1.required?.includes(key)) col = col.notNull();
+			if (schema.required?.includes(key)) col = col.notNull();
 			return {
 				...columns,
 				[key]: col
@@ -1033,14 +1033,14 @@ var BunSqliteProvider = class extends DatabaseProvider {
 		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 { drizzle } = 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({
+			this.bunDb = drizzle({
 				client: this.sqlite,
 				logger: { logQuery: (query, params) => {
 					this.log.trace(query, { params });
@@ -1052,6 +1052,7 @@ var BunSqliteProvider = class extends DatabaseProvider {
 	});
 	onStop = $hook({
 		on: "stop",
+		priority: "last",
 		handler: async () => {
 			if (this.sqlite) {
 				this.log.debug("Closing Bun SQLite connection...");
@@ -1063,8 +1064,8 @@ var BunSqliteProvider = class extends DatabaseProvider {
 		}
 	});
 	async executeMigrations(migrationsFolder) {
-		const { migrate: migrate$3 } = await import("drizzle-orm/bun-sqlite/migrator");
-		await migrate$3(this.bunDb, { migrationsFolder });
+		const { migrate } = await import("drizzle-orm/bun-sqlite/migrator");
+		await migrate(this.bunDb, { migrationsFolder });
 	}
 };
 
@@ -1116,15 +1117,15 @@ var CloudflareD1Provider = class extends DatabaseProvider {
 			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);
+			const { drizzle } = await import("drizzle-orm/d1");
+			this.drizzleDb = drizzle(this.d1);
 			await this.migrate();
 			this.log.info("Using Cloudflare D1 database");
 		}
 	});
 	async executeMigrations(migrationsFolder) {
-		const { migrate: migrate$3 } = await import("drizzle-orm/d1/migrator");
-		await migrate$3(this.db, { migrationsFolder });
+		const { migrate } = await import("drizzle-orm/d1/migrator");
+		await migrate(this.db, { migrationsFolder });
 	}
 	/**
 	* Override development migration to skip sync (not supported on D1).
@@ -1310,9 +1311,9 @@ var NodeSqliteProvider = class extends DatabaseProvider {
 		else return "node_modules/.alepha/sqlite.db";
 	}
 	async execute(query) {
-		const { sql: sql$2, params, method } = this.db.all(query).getQuery();
-		this.log.trace(`${sql$2}`, params);
-		const statement = this.sqlite.prepare(sql$2);
+		const { sql, params, method } = this.db.all(query).getQuery();
+		this.log.trace(`${sql}`, params);
+		const statement = this.sqlite.prepare(sql);
 		if (method === "run") {
 			statement.run(...params);
 			return [];
@@ -1323,9 +1324,9 @@ var NodeSqliteProvider = class extends DatabaseProvider {
 		}
 		return statement.all(...params);
 	}
-	db = drizzle$2(async (sql$2, params, method) => {
-		const statement = this.sqlite.prepare(sql$2);
-		this.log.trace(`${sql$2}`, { params });
+	db = drizzle$2(async (sql, params, method) => {
+		const statement = this.sqlite.prepare(sql);
+		this.log.trace(`${sql}`, { params });
 		if (method === "get") {
 			const data = statement.get(...params);
 			return { rows: data ? [{ ...data }] : [] };
@@ -1404,13 +1405,13 @@ var PglitePostgresProvider = class PglitePostgresProvider extends DatabaseProvid
 			if (Object.keys(this.kit.getModels(this)).length === 0) return;
 			const module = PglitePostgresProvider.importPglite();
 			if (!module) throw new AlephaError("@electric-sql/pglite is not installed. Please install it to use the pglite driver.");
-			const { drizzle: drizzle$3 } = createRequire(import.meta.url)("drizzle-orm/pglite");
+			const { drizzle } = createRequire(import.meta.url)("drizzle-orm/pglite");
 			const path = this.url;
 			if (path !== ":memory:") {
 				await mkdir(path, { recursive: true }).catch(() => null);
 				this.client = new module.PGlite(path);
 			} else this.client = new module.PGlite();
-			this.pglite = drizzle$3({ client: this.client });
+			this.pglite = drizzle({ client: this.client });
 			await this.migrate();
 			this.log.info(`Using PGlite database at ${path}`);
 		}
@@ -1487,10 +1488,10 @@ const pgAttr = (type, attr, value) => {
 /**
 * Retrieves the fields of a schema that have a specific attribute.
 */
-const getAttrFields = (schema$1, name) => {
+const getAttrFields = (schema, name) => {
 	const fields = [];
-	for (const key of Object.keys(schema$1.properties)) {
-		const value = schema$1.properties[key];
+	for (const key of Object.keys(schema.properties)) {
+		const value = schema.properties[key];
 		if (name in value) fields.push({
 			type: value,
 			key,
@@ -1526,13 +1527,13 @@ var PgRelationManager = class {
 	/**
 	* Map a row with its joined relations based on the joins definition
 	*/
-	mapRowWithJoins(record, row, schema$1, joins, parentKey) {
+	mapRowWithJoins(record, row, schema, joins, parentKey) {
 		for (const join of joins) if (join.parent === parentKey) {
 			const joinedData = row[join.table];
 			if (this.isAllNull(joinedData)) record[join.key] = void 0;
 			else {
 				record[join.key] = joinedData;
-				this.mapRowWithJoins(record[join.key], row, schema$1, joins, parentKey ? `${parentKey}.${join.key}` : join.key);
+				this.mapRowWithJoins(record[join.key], row, schema, joins, parentKey ? `${parentKey}.${join.key}` : join.key);
 			}
 		}
 		return record;
@@ -1549,16 +1550,16 @@ var PgRelationManager = class {
 	* Build a schema that includes all join properties recursively
 	*/
 	buildSchemaWithJoins(baseSchema, joins, parentPath) {
-		const schema$1 = Value.Clone(baseSchema);
+		const schema = Value.Clone(baseSchema);
 		const joinsAtThisLevel = joins.filter((j) => j.parent === parentPath);
 		for (const join of joinsAtThisLevel) {
 			const joinPath = parentPath ? `${parentPath}.${join.key}` : join.key;
 			const childJoins = joins.filter((j) => j.parent === joinPath);
 			let joinSchema = join.schema;
 			if (childJoins.length > 0) joinSchema = this.buildSchemaWithJoins(join.schema, joins, joinPath);
-			schema$1.properties[join.key] = t.optional(joinSchema);
+			schema.properties[join.key] = t.optional(joinSchema);
 		}
-		return schema$1;
+		return schema;
 	}
 };
 
@@ -1570,7 +1571,7 @@ var QueryManager = class {
 	* Convert a query object to a SQL query.
 	*/
 	toSQL(query, options) {
-		const { schema: schema$1, col, joins } = options;
+		const { schema, col, joins } = options;
 		const conditions = [];
 		if (isSQLWrapper(query)) conditions.push(query);
 		else {
@@ -1592,13 +1593,13 @@ var QueryManager = class {
 								parent: newParent
 							};
 						});
-						const sql$2 = this.toSQL(query[key], {
+						const sql = this.toSQL(query[key], {
 							schema: join.schema,
 							col: join.col,
 							joins: recursiveJoins.length > 0 ? recursiveJoins : void 0,
 							dialect: options.dialect
 						});
-						if (sql$2) conditions.push(sql$2);
+						if (sql) conditions.push(sql);
 						continue;
 					}
 				}
@@ -1606,7 +1607,7 @@ var QueryManager = class {
 					const operations = operator.map((it) => {
 						if (isSQLWrapper(it)) return it;
 						return this.toSQL(it, {
-							schema: schema$1,
+							schema,
 							col,
 							joins,
 							dialect: options.dialect
@@ -1617,7 +1618,7 @@ var QueryManager = class {
 				}
 				if (key === "not") {
 					const where = this.toSQL(operator, {
-						schema: schema$1,
+						schema,
 						col,
 						joins,
 						dialect: options.dialect
@@ -1626,8 +1627,8 @@ var QueryManager = class {
 				}
 				if (operator) {
 					const column = col(key);
-					const sql$2 = this.mapOperatorToSql(operator, column, schema$1, key, options.dialect);
-					if (sql$2) conditions.push(sql$2);
+					const sql = this.mapOperatorToSql(operator, column, schema, key, options.dialect);
+					if (sql) conditions.push(sql);
 				}
 			}
 		}
@@ -1796,7 +1797,7 @@ var QueryManager = class {
 
 //#endregion
 //#region ../../src/orm/services/Repository.ts
-var Repository = class {
+var Repository = class Repository {
 	entity;
 	provider;
 	log = $logger();
@@ -1804,6 +1805,13 @@ var Repository = class {
 	queryManager = $inject(QueryManager);
 	dateTimeProvider = $inject(DateTimeProvider);
 	alepha = $inject(Alepha);
+	static of(entity, provider = DatabaseProvider) {
+		return class InlineRepository extends Repository {
+			constructor() {
+				super(entity, provider);
+			}
+		};
+	}
 	constructor(entity, provider = DatabaseProvider) {
 		this.entity = entity;
 		this.provider = this.alepha.inject(provider);
@@ -1858,11 +1866,11 @@ var Repository = class {
 	* }
 	* ```
 	*/
-	async query(query, schema$1) {
+	async query(query, schema) {
 		const raw = typeof query === "function" ? query(this.table, this.db) : query;
 		if (typeof raw === "string" && raw.includes("[object Object]")) throw new AlephaError("Invalid SQL query. Did you forget to call the 'sql' function?");
 		return (await this.provider.execute(raw)).map((it) => {
-			return this.clean(this.mapRawFieldsToEntity(it), schema$1 ?? this.entity.schema);
+			return this.clean(this.mapRawFieldsToEntity(it), schema ?? this.entity.schema);
 		});
 	}
 	/**
@@ -1908,11 +1916,11 @@ var Repository = class {
 	* Start a SELECT DISTINCT query on the table.
 	*/
 	rawSelectDistinct(opts = {}, columns = []) {
-		const db$1 = opts.tx ?? this.db;
+		const db = opts.tx ?? this.db;
 		const table = this.table;
 		const fields = {};
 		for (const column of columns) if (typeof column === "string") fields[column] = this.col(column);
-		return db$1.selectDistinct(fields).from(table);
+		return db.selectDistinct(fields).from(table);
 	}
 	/**
 	* Start an INSERT query on the table.
@@ -1964,21 +1972,21 @@ var Repository = class {
 		}
 		try {
 			let rows = await builder.execute();
-			let schema$1 = this.entity.schema;
-			if (columns) schema$1 = t.pick(schema$1, columns);
+			let schema = this.entity.schema;
+			if (columns) schema = t.pick(schema, columns);
 			if (joins.length) rows = rows.map((row) => {
 				const rowSchema = {
-					...schema$1,
-					properties: { ...schema$1.properties }
+					...schema,
+					properties: { ...schema.properties }
 				};
 				return this.relationManager.mapRowWithJoins(row[this.tableName], row, rowSchema, joins);
 			});
 			rows = rows.map((row) => {
 				if (joins.length) {
-					const joinedSchema = this.relationManager.buildSchemaWithJoins(schema$1, joins);
+					const joinedSchema = this.relationManager.buildSchemaWithJoins(schema, joins);
 					return this.cleanWithJoins(row, joinedSchema, joins);
 				}
-				return this.clean(row, schema$1);
+				return this.clean(row, schema);
 			});
 			await this.alepha.events.emit("repository:read:after", {
 				tableName: this.tableName,
@@ -2324,27 +2332,27 @@ var Repository = class {
 	* Convert something to valid Pg Insert Value.
 	*/
 	cast(data, insert) {
-		const schema$1 = insert ? this.entity.insertSchema : t.partial(this.entity.updateSchema);
-		return this.alepha.codec.encode(schema$1, data);
+		const schema = insert ? this.entity.insertSchema : t.partial(this.entity.updateSchema);
+		return this.alepha.codec.encode(schema, data);
 	}
 	/**
 	* Transform a row from the database into a clean entity.
 	*/
-	clean(row, schema$1) {
-		for (const key of Object.keys(schema$1.properties)) {
-			const value = schema$1.properties[key];
+	clean(row, schema) {
+		for (const key of Object.keys(schema.properties)) {
+			const value = schema.properties[key];
 			if (typeof row[key] === "string") {
 				if (t.schema.isDateTime(value)) row[key] = this.dateTimeProvider.of(row[key]).toISOString();
 				else if (t.schema.isDate(value)) row[key] = this.dateTimeProvider.of(`${row[key]}T00:00:00Z`).toISOString().split("T")[0];
 			}
 			if (typeof row[key] === "bigint" && t.schema.isBigInt(value)) row[key] = row[key].toString();
 		}
-		return this.alepha.codec.decode(schema$1, row);
+		return this.alepha.codec.decode(schema, row);
 	}
 	/**
 	* Clean a row with joins recursively
 	*/
-	cleanWithJoins(row, schema$1, joins, parentPath) {
+	cleanWithJoins(row, schema, joins, parentPath) {
 		const joinsAtThisLevel = joins.filter((j) => j.parent === parentPath);
 		const cleanRow = { ...row };
 		const joinedData = {};
@@ -2352,7 +2360,7 @@ var Repository = class {
 			joinedData[join.key] = cleanRow[join.key];
 			delete cleanRow[join.key];
 		}
-		const entity = this.clean(cleanRow, schema$1);
+		const entity = this.clean(cleanRow, schema);
 		for (const join of joinsAtThisLevel) {
 			const joinedValue = joinedData[join.key];
 			if (joinedValue != null) {
@@ -2388,8 +2396,8 @@ var Repository = class {
 	/**
 	* Find a primary key in the schema.
 	*/
-	getPrimaryKey(schema$1) {
-		const primaryKeys = getAttrFields(schema$1, PG_PRIMARY_KEY);
+	getPrimaryKey(schema) {
+		const primaryKeys = getAttrFields(schema, PG_PRIMARY_KEY);
 		if (primaryKeys.length === 0) throw new AlephaError("Primary key not found in schema");
 		if (primaryKeys.length > 1) throw new AlephaError(`Multiple primary keys (${primaryKeys.length}) are not supported`);
 		return {
@@ -2707,8 +2715,8 @@ function buildQueryString(where) {
 	if (!where || typeof where !== "object") return "";
 	if ("and" in where && Array.isArray(where.and)) return where.and.map((w) => buildQueryString(w)).join("&");
 	if ("or" in where && Array.isArray(where.or)) {
-		const parts$1 = where.or.map((w) => buildQueryString(w));
-		return parts$1.length > 1 ? `(${parts$1.join("|")})` : parts$1[0];
+		const parts = where.or.map((w) => buildQueryString(w));
+		return parts.length > 1 ? `(${parts.join("|")})` : parts[0];
 	}
 	if ("not" in where) return "";
 	const parts = [];
@@ -2903,7 +2911,7 @@ var orm_exports = /* @__PURE__ */ __exportAll({
 	$repository: () => $repository,
 	$sequence: () => $sequence,
 	$transaction: () => $transaction,
-	AlephaPostgres: () => AlephaPostgres,
+	AlephaOrm: () => AlephaOrm,
 	BunPostgresProvider: () => BunPostgresProvider,
 	BunSqliteProvider: () => BunSqliteProvider,
 	CloudflareD1Provider: () => CloudflareD1Provider,
@@ -2931,6 +2939,7 @@ var orm_exports = /* @__PURE__ */ __exportAll({
 	Repository: () => Repository,
 	RepositoryProvider: () => RepositoryProvider,
 	SequencePrimitive: () => SequencePrimitive,
+	SqliteProvider: () => SqliteProvider,
 	buildQueryString: () => buildQueryString,
 	bunSqliteOptions: () => bunSqliteOptions,
 	db: () => db,
@@ -2948,59 +2957,32 @@ var orm_exports = /* @__PURE__ */ __exportAll({
 	sql: () => sql,
 	updateSchema: () => updateSchema
 });
+const SqliteProvider = NodeSqliteProvider;
 /**
-* Postgres client based on Drizzle ORM, Alepha type-safe friendly.
-*
-* Automatically selects the appropriate provider based on runtime:
-* - Bun: Uses `BunPostgresProvider` or `BunSqliteProvider`
-* - Node.js: Uses `NodePostgresProvider` or `NodeSqliteProvider`
-*
-* ```ts
-* import { t } from "alepha";
-* import { $entity, $repository, db } from "alepha/postgres";
-*
-* const users = $entity({
-*   name: "users",
-*   schema: t.object({
-*     id: db.primaryKey(),
-*     name: t.text(),
-*     email: t.text(),
-*   }),
-* });
-*
-* class App {
-*   users = $repository(users);
-*
-*   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.
+* | type | quality | stability |
+* |------|---------|-----------|
+* | backend | epic | stable |
 *
-* It provides:
-* - A type-safe way to define entities and repositories. (via `$entity` and `$repository`)
-* - Custom query builders and filters.
-* - Built-in special columns like `createdAt`, `updatedAt`, `deletedAt`, `version`.
-* - Automatic JSONB support.
-* - Automatic synchronization of entities with the database schema (for testing and development).
-* - Fallback to raw SQL via Drizzle ORM `sql` function.
+* Full-featured database abstraction built on Drizzle ORM with complete type safety.
 *
-* Migrations are supported via Drizzle ORM, you need to use the `drizzle-kit` CLI tool to generate and run migrations.
+* **Features:**
+* - Define database entities with TypeBox schemas
+* - Automatic timestamps, soft deletes, and versioning columns
+* - Type-safe CRUD operations with filtering, pagination, sorting, and relationships
+* - Database transaction support with automatic rollback
+* - Auto-incrementing sequences for IDs
+* - PostgreSQL support (Node.js, Bun, Cloudflare Workers via pglite)
+* - SQLite support (Node.js, Bun, Cloudflare D1)
+* - Automatic schema sync for development/testing
+* - Drizzle Kit migrations for production
+* - Type-safe filters: `eq`, `ne`, `gt`, `gte`, `lt`, `lte`, `in`, `nin`, `like`, `between`
+* - JSONB column support
+* - Relationship joins
 *
-* @see {@link $entity}
-* @see {@link $sequence}
-* @see {@link $repository}
-* @see {@link $transaction}
-* @see {@link NodePostgresProvider} - Node.js Postgres implementation
-* @see {@link NodeSqliteProvider} - Node.js SQLite implementation
-* @see {@link BunPostgresProvider} - Bun Postgres implementation
-* @see {@link BunSqliteProvider} - Bun SQLite implementation
 * @module alepha.postgres
 */
-const AlephaPostgres = $module({
-	name: "alepha.postgres",
+const AlephaOrm = $module({
+	name: "alepha.orm",
 	primitives: [$sequence, $entity],
 	services: [
 		AlephaDateTime,
@@ -3063,5 +3045,5 @@ const AlephaPostgres = $module({
 });
 
 //#endregion
-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 };
+export { $entity, $repository, $sequence, $transaction, AlephaOrm, 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, SqliteProvider, buildQueryString, bunSqliteOptions, db, drizzle, getAttrFields, insertSchema, legacyIdSchema, nodeSqliteOptions, pageQuerySchema, pageSchema, parseQueryString, pg, pgAttr, schema, sql, updateSchema };
 //# sourceMappingURL=index.js.map