alepha 0.15.0 → 0.15.1

package/dist/orm/index.bun.js

@@ -35,14 +35,14 @@ var __exportAll = (all, symbols) => {
 	}
 	return target;
 };
-var __copyProps = (to, from, except, desc$1) => {
+var __copyProps = (to, from, except, desc) => {
 	if (from && typeof from === "object" || typeof from === "function") {
 		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
 			key = keys[i];
 			if (!__hasOwnProp.call(to, key) && key !== except) {
 				__defProp(to, key, {
 					get: ((k) => from[k]).bind(null, key),
-					enumerable: !(desc$1 = __getOwnPropDesc(from, key)) || desc$1.enumerable
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
 				});
 			}
 		}
@@ -92,14 +92,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
@@ -130,10 +130,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);
 		} });
 	}
@@ -199,8 +199,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
@@ -323,7 +323,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.
@@ -333,16 +333,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),
@@ -629,8 +629,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();
@@ -645,7 +645,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
@@ -684,7 +684,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);
@@ -812,8 +812,8 @@ var BunPostgresProvider = class extends DatabaseProvider {
 		return this.bunDb;
 	}
 	async executeMigrations(migrationsFolder) {
-		const { migrate: migrate$1 } = await import("drizzle-orm/bun-sql/migrator");
-		await migrate$1(this.bunDb, { migrationsFolder });
+		const { migrate } = await import("drizzle-orm/bun-sql/migrator");
+		await migrate(this.bunDb, { migrationsFolder });
 	}
 	onStart = $hook({
 		on: "start",
@@ -841,10 +841,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$1 } = 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$1({
+		this.bunDb = drizzle({
 			client: this.client,
 			logger: { logQuery: (query, params) => {
 				this.log.trace(query, { params });
@@ -897,8 +897,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();
@@ -913,7 +913,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
@@ -1062,14 +1062,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$1 } = 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$1({
+			this.bunDb = drizzle({
 				client: this.sqlite,
 				logger: { logQuery: (query, params) => {
 					this.log.trace(query, { params });
@@ -1092,8 +1092,8 @@ var BunSqliteProvider = class extends DatabaseProvider {
 		}
 	});
 	async executeMigrations(migrationsFolder) {
-		const { migrate: migrate$1 } = await import("drizzle-orm/bun-sqlite/migrator");
-		await migrate$1(this.bunDb, { migrationsFolder });
+		const { migrate } = await import("drizzle-orm/bun-sqlite/migrator");
+		await migrate(this.bunDb, { migrationsFolder });
 	}
 };
 
@@ -1145,15 +1145,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$1 } = await import("drizzle-orm/d1");
-			this.drizzleDb = drizzle$1(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$1 } = await import("drizzle-orm/d1/migrator");
-		await migrate$1(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).
@@ -1220,13 +1220,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$1 } = 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$1({ client: this.client });
+			this.pglite = drizzle({ client: this.client });
 			await this.migrate();
 			this.log.info(`Using PGlite database at ${path}`);
 		}
@@ -1303,10 +1303,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,
@@ -1342,13 +1342,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;
@@ -1365,16 +1365,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;
 	}
 };
 
@@ -1386,7 +1386,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 {
@@ -1408,13 +1408,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;
 					}
 				}
@@ -1422,7 +1422,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
@@ -1433,7 +1433,7 @@ var QueryManager = class {
 				}
 				if (key === "not") {
 					const where = this.toSQL(operator, {
-						schema: schema$1,
+						schema,
 						col,
 						joins,
 						dialect: options.dialect
@@ -1442,8 +1442,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);
 				}
 			}
 		}
@@ -1612,7 +1612,7 @@ var QueryManager = class {
 
 //#endregion
 //#region ../../src/orm/services/Repository.ts
-var Repository = class {
+var Repository = class Repository {
 	entity;
 	provider;
 	log = $logger();
@@ -1620,6 +1620,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);
@@ -1674,11 +1681,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);
 		});
 	}
 	/**
@@ -1724,11 +1731,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.
@@ -1780,21 +1787,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,
@@ -2140,27 +2147,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 = {};
@@ -2168,7 +2175,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) {
@@ -2204,8 +2211,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 {
@@ -2523,8 +2530,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 = [];