peta-orm 0.4.1 → 0.6.0

package/dist/model-helpers-BBpD3qdv.mjs

@@ -0,0 +1,14 @@
+import { o as ModelNotRegisteredError } from "./errors-i-gCZnlW.mjs";
+//#region src/lib/model-helpers.ts
+function getPrimaryKeyColumn(def) {
+	const cols = def.columns;
+	for (const [name, col] of Object.entries(cols)) if (col.isPrimaryKey) return name;
+	return "id";
+}
+function getDb(def) {
+	if (!def._orm) throw new ModelNotRegisteredError(def.name);
+	if (def._orm._trx) return def._orm._trx;
+	return def._orm.kysely;
+}
+//#endregion
+export { getPrimaryKeyColumn as n, getDb as t };

package/package.json

@@ -2,14 +2,14 @@
   "name": "peta-orm",
   "type": "module",
   "private": false,
-  "version": "0.4.1",
+  "version": "0.6.0",
   "description": "ORM for Bun, built on Kysely",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/zfadhli/peta-stack.git"
   },
-  "module": "src/index.ts",
+  "module": "./dist/index.mjs",
   "main": "./dist/index.mjs",
   "types": "./dist/index.d.mts",
   "exports": {
@@ -25,8 +25,6 @@
   ],
   "dependencies": {
     "arktype": "^2.2.0",
-    "cac": "^7.0.0",
-    "ora": "^9.4.0",
     "ulid": "^3.0.2"
   },
   "peerDependencies": {
@@ -48,13 +46,11 @@
   },
   "scripts": {
     "test": "bun test",
-    "test:all": "for f in test/*.ts; do echo === $f ===; bun test $f || exit 1; done",
     "test:integration": "bun test test/integration/",
-    "test:all:integration": "for f in test/integration/*.ts; do echo === $f ===; bun test $f || exit 1; done",
     "typecheck": "bun x tsc --noEmit",
     "build": "tsdown",
     "lint": "bunx biome check src test examples",
     "lint:fix": "bunx biome check --write --unsafe src test examples",
-    "prepublish": "bun run build"
+    "prepublishOnly": "bun run build"
   }
 }

package/dist/save-D5UKXvqC.mjs

@@ -1,331 +0,0 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { n as normalizeError, r as DatabaseError } from "./errors-sfFJolfu.mjs";
-import { t as getHooksFor } from "./hooks-BD0xy7uw.mjs";
-import { i as applyCastsToData, o as prepareForDb, t as createInstance } from "./factory-BBvIMQuc.mjs";
-import { d as setExists, f as syncOriginal, i as getExists, o as getState } from "./state-LtlHp6XV.mjs";
-//#region src/model/save.ts
-var save_exports = /* @__PURE__ */ __exportAll({
-	getConfig: () => getConfig,
-	insertManyModel: () => insertManyModel,
-	insertModel: () => insertModel,
-	reloadModel: () => reloadModel,
-	saveModel: () => saveModel,
-	setConfig: () => setConfig,
-	updateModel: () => updateModel
-});
-function getPrimaryKeyColumn(def) {
-	const cols = def.columns;
-	for (const [name, col] of Object.entries(cols)) if (col.isPrimaryKey) return name;
-	return "id";
-}
-function getTable(def) {
-	return def.table;
-}
-function getDb(def) {
-	if (!def._orm) throw new Error("Model not registered");
-	return def._orm.kysely;
-}
-async function saveModel(def, model) {
-	const hm = getHooksFor(def);
-	const exists = getExists(model);
-	const pk = getPrimaryKeyColumn(def);
-	const db = getDb(def);
-	const config = getConfig(def);
-	if (exists) {
-		const dirty = getState(model).attributes;
-		const original = getState(model).original;
-		const changed = {};
-		for (const key of Object.keys(dirty)) if (dirty[key] !== original[key]) changed[key] = config?.casts?.[key] ? prepareForDb(dirty[key], config.casts[key]) : dirty[key];
-		if (Object.keys(changed).length === 0) return model;
-		await hm.trigger("beforeUpdate", model);
-		await hm.trigger("beforeSave", model);
-		const pkValue = model.get(pk);
-		try {
-			await db.updateTable(getTable(def)).set(changed).where(pk, "=", pkValue).execute();
-		} catch (e) {
-			throw normalizeError(e, getTable(def));
-		}
-		syncOriginal(model);
-		await hm.trigger("afterUpdate", model);
-		await hm.trigger("afterSave", model);
-	} else {
-		await hm.trigger("beforeCreate", model);
-		await hm.trigger("beforeSave", model);
-		const data = {};
-		const attrs = getState(model).attributes;
-		for (const [key, value] of Object.entries(attrs)) if (key !== pk || value !== void 0) data[key] = config?.casts?.[key] ? prepareForDb(value, config.casts[key]) : value;
-		try {
-			const result = await db.insertInto(getTable(def)).values(data).returningAll().executeTakeFirst();
-			if (result) {
-				const applied = config?.casts ? applyCastsToData(config, result, "get") : result;
-				for (const [key, value] of Object.entries(applied)) getState(model).attributes[key] = value;
-			}
-		} catch (e) {
-			throw normalizeError(e, getTable(def));
-		}
-		setExists(model, true);
-		syncOriginal(model);
-		await hm.trigger("afterCreate", model);
-		await hm.trigger("afterSave", model);
-	}
-	return model;
-}
-async function insertModel(def, data) {
-	const config = getConfig(def) ?? { columns: def.columns };
-	if (!Object.keys(data).some((key) => key in def.relations)) {
-		const model = createInstance(def, config, data, false);
-		await saveModel(def, model);
-		return model;
-	}
-	const { extractRelationData, processCreateRelations } = await import("./crud-BCWvg5MI.mjs");
-	const { columnData, relationOps } = extractRelationData(def, data);
-	for (const [relName, op] of Object.entries(relationOps)) {
-		const relation = def.relations[relName];
-		if (relation?.type === "belongsTo") {
-			const bop = op;
-			const relatedDef = relation.relatedModelClass;
-			if (bop.create) {
-				const related = await relatedDef.insert(bop.create);
-				columnData[relation.foreignKey] = related.get(relation.localKey);
-			} else if (bop.connect) {
-				const cond = bop.connect;
-				const condKey = Object.keys(cond)[0];
-				const found = await relatedDef.query().where(condKey, "=", cond[condKey]).executeTakeFirst();
-				if (found) columnData[relation.foreignKey] = found.get(relation.localKey);
-			} else if (bop.connectOrCreate) {
-				const { where, create } = bop.connectOrCreate;
-				const whereKey = Object.keys(where)[0];
-				const found = await relatedDef.query().where(whereKey, "=", where[whereKey]).executeTakeFirst();
-				if (found) columnData[relation.foreignKey] = found.get(relation.localKey);
-				else {
-					const created = await relatedDef.insert(create);
-					columnData[relation.foreignKey] = created.get(relation.localKey);
-				}
-			}
-		}
-	}
-	const model = createInstance(def, config, columnData, false);
-	await saveModel(def, model);
-	const postOps = {};
-	for (const [relName, op] of Object.entries(relationOps)) {
-		const relation = def.relations[relName];
-		if (relation && relation.type !== "belongsTo") postOps[relName] = op;
-	}
-	if (Object.keys(postOps).length > 0) await processCreateRelations(def, model, postOps);
-	return model;
-}
-async function insertManyModel(def, dataArray) {
-	const db = getDb(def);
-	const pk = getPrimaryKeyColumn(def);
-	const config = getConfig(def);
-	const hm = getHooksFor(def);
-	const instances = [];
-	for (const data of dataArray) {
-		const instance = createInstance(def, config ?? { columns: def.columns }, {}, false);
-		const fillData = {};
-		for (const [key, value] of Object.entries(data)) if (key !== pk) fillData[key] = value;
-		instance.fill(fillData);
-		await hm.trigger("beforeCreate", instance);
-		instances.push(instance);
-	}
-	const prepared = instances.map((inst) => {
-		const attrs = inst.attributes ?? {};
-		const row = {};
-		for (const [key, value] of Object.entries(attrs)) row[key] = config?.casts?.[key] ? prepareForDb(value, config.casts[key]) : value;
-		return row;
-	});
-	let results;
-	try {
-		results = await db.insertInto(getTable(def)).values(prepared).returningAll().execute();
-	} catch (e) {
-		throw normalizeError(e, getTable(def));
-	}
-	const models = results.map((row) => {
-		const applied = config?.casts ? applyCastsToData(config, row, "get") : row;
-		return createInstance(def, config ?? { columns: def.columns }, applied, true);
-	});
-	for (const model of models) await hm.trigger("afterCreate", model);
-	return models;
-}
-async function updateModel(def, id, data) {
-	const model = await def.findOrFail(id);
-	if (!Object.keys(data).some((key) => key in def.relations)) {
-		model.fill(data);
-		await saveModel(def, model);
-		return model;
-	}
-	const { extractRelationData } = await import("./crud-BCWvg5MI.mjs");
-	const { columnData, relationOps } = extractRelationData(def, data);
-	model.fill(columnData);
-	await saveModel(def, model);
-	const pkValue = model.get("id");
-	if (pkValue == null) return model;
-	for (const [relName, op] of Object.entries(relationOps)) {
-		const relation = def.relations[relName];
-		if (!relation) continue;
-		const relatedDef = relation.relatedModelClass;
-		const db = relatedDef._orm?.kysely;
-		if (!db) continue;
-		if (relation.type === "belongsTo") {
-			const bop = op;
-			if (bop.update) {
-				const fkValue = model.get(relation.foreignKey);
-				if (fkValue != null) {
-					const related = await relatedDef.find(fkValue);
-					if (related) {
-						related.fill(bop.update);
-						const { saveModel: saveRel } = await Promise.resolve().then(() => save_exports);
-						await saveRel(relatedDef, related);
-					}
-				}
-			} else if (bop.upsert) {
-				const { update, create } = bop.upsert;
-				const fkValue = model.get(relation.foreignKey);
-				if (fkValue != null) {
-					const related = await relatedDef.find(fkValue);
-					if (related) {
-						related.fill(update);
-						const { saveModel: saveRel } = await Promise.resolve().then(() => save_exports);
-						await saveRel(relatedDef, related);
-					}
-				} else {
-					const created = await relatedDef.insert(create);
-					await db.updateTable(def.table).set({ [relation.foreignKey]: created.get(relation.localKey) }).where("id", "=", pkValue).execute();
-					model.set(relation.foreignKey, created.get(relation.localKey));
-				}
-			} else if (bop.disconnect) {
-				await db.updateTable(def.table).set({ [relation.foreignKey]: null }).where("id", "=", pkValue).execute();
-				model.set(relation.foreignKey, null);
-			} else if (bop.delete) {
-				const fkValue = model.get(relation.foreignKey);
-				if (fkValue != null) {
-					const related = await relatedDef.find(fkValue);
-					if (related) {
-						const { deleteModel: delRel } = await import("./index.mjs").then((n) => n.r);
-						await delRel(relatedDef, related);
-					}
-				}
-			}
-		} else if (relation.type === "hasMany" || relation.type === "hasOne") {
-			const hop = op;
-			if (hop.create) for (const childData of hop.create) await relatedDef.insert({
-				...childData,
-				[relation.foreignKey]: pkValue
-			});
-			if (hop.update) {
-				const queries = Array.isArray(hop.update?.where) ? hop.update.where : [hop.update?.where];
-				for (const where of queries) {
-					const whereKey = Object.keys(where)[0];
-					await relatedDef.query().where(whereKey, "=", where[whereKey]).all().updateMany(hop.update.data);
-				}
-			}
-			if (hop.delete) {
-				const queries = Array.isArray(hop.delete) ? hop.delete : [hop.delete];
-				for (const where of queries) {
-					const whereKey = Object.keys(where)[0];
-					await relatedDef.query().where(whereKey, "=", where[whereKey]).all().deleteMany();
-				}
-			}
-		} else if (relation.type === "manyToMany") {
-			const mop = op;
-			if (mop.create) {
-				const throughTable = relation.throughTable;
-				const fpk = relation.foreignPivotKey;
-				const rpk = relation.relatedPivotKey;
-				for (const childData of mop.create) {
-					const child = await relatedDef.insert(childData);
-					try {
-						await db.insertInto(throughTable).values({
-							[fpk]: pkValue,
-							[rpk]: child.get(relation.localKey ?? "id")
-						}).execute();
-					} catch {}
-				}
-			}
-			if (mop.connect) {
-				const throughTable = relation.throughTable;
-				const fpk = relation.foreignPivotKey;
-				const rpk = relation.relatedPivotKey;
-				for (const target of mop.connect) {
-					let targetId = target;
-					if (typeof target !== "number" && typeof target !== "string") {
-						const t = target;
-						const key = Object.keys(t)[0];
-						targetId = (await relatedDef.query().where(key, "=", t[key]).executeTakeFirst())?.get("id");
-					}
-					if (targetId != null) try {
-						await db.insertInto(throughTable).values({
-							[fpk]: pkValue,
-							[rpk]: targetId
-						}).execute();
-					} catch {}
-				}
-			}
-			if (mop.disconnect) {
-				const throughTable = relation.throughTable;
-				const fpk = relation.foreignPivotKey;
-				const rpk = relation.relatedPivotKey;
-				const queries = Array.isArray(mop.disconnect) ? mop.disconnect : [mop.disconnect];
-				for (const where of queries) if (typeof where === "object" && Object.keys(where).length > 0) {
-					const key = Object.keys(where)[0];
-					const val = Object.values(where)[0];
-					if (key === "id") await db.deleteFrom(throughTable).where(fpk, "=", pkValue).where(rpk, "=", val).execute();
-				}
-			}
-			if (mop.set) {
-				const throughTable = relation.throughTable;
-				const fpk = relation.foreignPivotKey;
-				const rpk = relation.relatedPivotKey;
-				const current = await db.selectFrom(throughTable).select(rpk).where(fpk, "=", pkValue).execute();
-				const currentIds = new Set(current.map((r) => r[rpk]));
-				const desiredIds = /* @__PURE__ */ new Set();
-				for (const target of mop.set) {
-					let targetId = target;
-					if (typeof target !== "number" && typeof target !== "string") {
-						const t = target;
-						const key = Object.keys(t)[0];
-						targetId = (await relatedDef.query().where(key, "=", t[key]).executeTakeFirst())?.get("id");
-					}
-					if (targetId != null) {
-						desiredIds.add(targetId);
-						if (!currentIds.has(targetId)) try {
-							await db.insertInto(throughTable).values({
-								[fpk]: pkValue,
-								[rpk]: targetId
-							}).execute();
-						} catch {}
-					}
-				}
-				for (const id of currentIds) if (!desiredIds.has(id)) await db.deleteFrom(throughTable).where(fpk, "=", pkValue).where(rpk, "=", id).execute();
-			}
-		}
-	}
-	return model;
-}
-async function reloadModel(def, model) {
-	const pk = getPrimaryKeyColumn(def);
-	const pkValue = model.get(pk);
-	if (pkValue == null) throw new DatabaseError("Cannot reload model without primary key", "MISSING_ID");
-	const db = getDb(def);
-	try {
-		const row = await db.selectFrom(getTable(def)).selectAll().where(pk, "=", pkValue).executeTakeFirst();
-		if (row) {
-			const config = getConfig(def);
-			const applied = config?.casts ? applyCastsToData(config, row, "get") : row;
-			const state = getState(model);
-			state.attributes = { ...applied };
-			state.original = { ...applied };
-		}
-	} catch (e) {
-		throw normalizeError(e, getTable(def));
-	}
-}
-const configMap = /* @__PURE__ */ new WeakMap();
-function setConfig(def, config) {
-	configMap.set(def, config);
-}
-function getConfig(def) {
-	return configMap.get(def);
-}
-//#endregion
-export { setConfig as a, save_exports as i, reloadModel as n, saveModel as r, getConfig as t };