peta-orm 0.4.1 → 0.6.0

package/dist/index.mjs

@@ -1,21 +1,28 @@
 import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
-import { n as createCollection } from "./collection-PFmrQHyM.mjs";
-import { a as ModelNotRegisteredError, c as ValidationError, i as ModelNotFoundError, n as normalizeError, o as RelationNotAllowedError, r as DatabaseError, s as RelationNotFoundError } from "./errors-sfFJolfu.mjs";
-import { a as registerSoftDeletesFor, n as getSoftDeleteConfig, o as registerTimestampsFor, r as hasSoftDelete, s as createHookManager, t as getHooksFor } from "./hooks-BD0xy7uw.mjs";
-import { a as castValue, r as initRuntime, t as createInstance } from "./factory-BBvIMQuc.mjs";
-import { a as getRawRelations, d as setExists, o as getState } from "./state-LtlHp6XV.mjs";
-import { a as setConfig$1, n as reloadModel, r as saveModel, t as getConfig$1 } from "./save-D5UKXvqC.mjs";
+import { n as createCollection } from "./collection-D9YZn2mL.mjs";
+import { a as ModelNotFoundError, c as RelationNotFoundError, i as DatabaseError, l as ValidationError, n as isUniqueConstraintError, o as ModelNotRegisteredError, r as normalizeError, s as RelationNotAllowedError } from "./errors-i-gCZnlW.mjs";
+import { a as registerTimestampsFor, i as registerSoftDeletesFor, n as getSoftDeleteConfig, o as createHookManager, r as hasSoftDelete, t as getHooksFor } from "./hooks-D508wLQg.mjs";
+import { n as getPrimaryKeyColumn, t as getDb } from "./model-helpers-BBpD3qdv.mjs";
+import { a as castValue, i as applyCastsToData, o as prepareForDb, r as initRuntime, t as createInstance } from "./factory-_JPR5fVl.mjs";
+import { a as getRawRelations, d as setExists, f as syncOriginal, i as getExists, o as getState } from "./state-LtlHp6XV.mjs";
+import { a as resolveThunk, i as resolveTargetId, n as getPivotInfo, r as groupByArray, t as findRelated } from "./helpers-CcxHFhtz.mjs";
 import { type } from "arktype";
 import { Kysely, sql } from "kysely";
+import { pathToFileURL } from "node:url";
 import { ulid as ulid$1 } from "ulid";
 //#region src/columns/arktype.ts
 function createArkTypeSchemaConfig() {
 	function compile(dataType, args, constraints) {
 		return type(buildDef(dataType, args, constraints));
 	}
+	function formatProblems(result) {
+		const raw = result.flatProblemsByPath;
+		if (!raw) return "Validation failed";
+		return Object.entries(raw).map(([path, msgs]) => `${path}: ${msgs.join(", ")}`).join("; ");
+	}
 	function parse(schema, value) {
 		const result = schema(value);
-		if (result instanceof type.errors) throw new ValidationError([...extractProblems(result).entries()].map(([path, msgs]) => `${path}: ${msgs.join(", ")}`).join("; "));
+		if (result instanceof type.errors) throw new ValidationError(formatProblems(result));
 		return result;
 	}
 	function assert(schema, value) {
@@ -23,7 +30,7 @@ function createArkTypeSchemaConfig() {
 		try {
 			return t.assert(value);
 		} catch (e) {
-			if (isArkError(e)) throw new ValidationError([...extractProblems(e.arkErrors).entries()].map(([path, msgs]) => `${path}: ${msgs.join(", ")}`).join("; "));
+			if (isArkError(e)) throw new ValidationError(formatProblems(e.arkErrors));
 			throw e;
 		}
 	}
@@ -97,12 +104,6 @@ function subTypeModifier(dataType, hasEmail, hasUrl) {
 function isArkError(e) {
 	return typeof e === "object" && e !== null && "arkErrors" in e;
 }
-function extractProblems(result) {
-	const problems = /* @__PURE__ */ new Map();
-	const raw = result.flatProblemsByPath;
-	if (raw) for (const [path, msgs] of Object.entries(raw)) problems.set(path, msgs);
-	return problems;
-}
 //#endregion
 //#region src/columns/column.ts
 function createColumn(schema, dataType, args = [], constraints = []) {
@@ -139,8 +140,7 @@ function createColumn(schema, dataType, args = [], constraints = []) {
 		get defaultValue() {
 			const c = constraints.find((c) => c.type === "default");
 			if (!c) return void 0;
-			const val = c.args[0];
-			return typeof val === "function" ? val : val;
+			return c.args[0];
 		},
 		hasConstraint(type) {
 			return constraints.some((c) => c.type === type);
@@ -189,7 +189,27 @@ function createColumn(schema, dataType, args = [], constraints = []) {
 }
 //#endregion
 //#region src/columns/types.ts
-function t(config) {
+/**
+* Pre-configured column type factory backed by ArkType validation.
+*
+* The most common usage — just import and use:
+* ```ts
+* import { t } from "peta-orm"
+* const id = t.integer().primaryKey()
+* ```
+*
+* For a custom validation backend, use `createColumnTypes({ schema })` instead.
+*/
+const t = createColumnTypes({ schema: createArkTypeSchemaConfig() });
+/**
+* Create a column type factory with a custom validation schema backend.
+*
+* @example
+* ```ts
+* const t = createColumnTypes({ schema: myCustomSchemaConfig })
+* ```
+*/
+function createColumnTypes(config) {
 	const schema = config.schema;
 	function col(dataType, args) {
 		return createColumn(schema, dataType, args);
@@ -217,6 +237,62 @@ function t(config) {
 	};
 }
 //#endregion
+//#region src/init.ts
+/**
+* Create a lazy-initialized singleton factory.
+*
+* The factory function is called only once — on the first call to the returned
+* function. Subsequent calls return the same resolved promise. This avoids
+* module-level side effects: importing a model file won't trigger database
+* connection or schema initialization until the first explicit `await db()`.
+*
+* @example
+* ```ts
+* import { createClient } from "@libsql/client"
+* import { LibsqlDialect } from "@libsql/kysely-libsql"
+* import { createDb, createORM, defineModel, t } from "peta-orm"
+*
+* const User = defineModel("users", { columns: { ... } })
+*
+* async function setup() {
+*   const client = createClient({ url: "file:my-app.db" })
+*   await client.execute("CREATE TABLE IF NOT EXISTS users (...)") // schema init
+*   const orm = createORM({ dialect: new LibsqlDialect({ client }) })
+*   orm.registerAll(User)
+*   return orm
+* }
+*
+* export const db = createDb(setup)
+* // Usage: const orm = await db()
+* ```
+*/
+function createDb(factory) {
+	let promise = null;
+	return () => {
+		if (!promise) promise = factory();
+		return promise;
+	};
+}
+//#endregion
+//#region src/integrations/elysia.ts
+/**
+* Elysia.js plugin that attaches the ORM instance to the app context.
+*/
+function petaPlugin(options) {
+	return (app) => app.decorate("peta", options.peta);
+}
+//#endregion
+//#region src/integrations/hono.ts
+/**
+* Hono middleware that sets the ORM instance on the context.
+*/
+function petaMiddleware(options) {
+	return async (c, next) => {
+		c.set("peta", options.peta);
+		await next();
+	};
+}
+//#endregion
 //#region src/hooks/static.ts
 var static_exports = /* @__PURE__ */ __exportAll({
 	addStaticHook: () => addStaticHook,
@@ -248,11 +324,353 @@ function hasStaticHooks(def, event) {
 	return (staticHooks.get(def)?.get(event)?.length ?? 0) > 0;
 }
 //#endregion
+//#region src/model/save.ts
+var save_exports = /* @__PURE__ */ __exportAll({
+	getConfig: () => getConfig,
+	insertManyModel: () => insertManyModel,
+	insertModel: () => insertModel,
+	reloadModel: () => reloadModel,
+	saveModel: () => saveModel,
+	setConfig: () => setConfig,
+	updateModel: () => updateModel
+});
+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(def.table).set(changed).where(pk, "=", pkValue).execute();
+		} catch (e) {
+			throw normalizeError(e, def.table);
+		}
+		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(def.table).values(data).returningAll().executeTakeFirst();
+			if (result) {
+				const applied = config?.casts ? applyCastsToData(config, result) : result;
+				for (const [key, value] of Object.entries(applied)) getState(model).attributes[key] = value;
+			}
+		} catch (e) {
+			throw normalizeError(e, def.table);
+		}
+		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-Di2nvpjB.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(def.table).values(prepared).returningAll().execute();
+	} catch (e) {
+		throw normalizeError(e, def.table);
+	}
+	const models = results.map((row) => {
+		const applied = config?.casts ? applyCastsToData(config, row) : 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-Di2nvpjB.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 Promise.resolve().then(() => delete_exports);
+						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 (e) {
+						if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+					}
+				}
+			}
+			if (mop.connect) {
+				const throughTable = relation.throughTable;
+				const fpk = relation.foreignPivotKey;
+				const rpk = relation.relatedPivotKey;
+				const connectLookup = /* @__PURE__ */ new Map();
+				const connectObjects = mop.connect.filter((t) => typeof t !== "number" && typeof t !== "string");
+				if (connectObjects.length > 0) {
+					const byKey = /* @__PURE__ */ new Map();
+					for (const t of connectObjects) {
+						const k = Object.keys(t)[0];
+						if (!byKey.has(k)) byKey.set(k, []);
+						byKey.get(k).push(t[k]);
+					}
+					for (const [k, vals] of byKey) {
+						const records = await relatedDef.query().whereIn(k, vals).execute();
+						for (const r of records) connectLookup.set(r.get(k), r.get("id"));
+					}
+				}
+				for (const target of mop.connect) {
+					let targetId = target;
+					if (typeof target !== "number" && typeof target !== "string") {
+						const t = target;
+						targetId = connectLookup.get(t[Object.keys(t)[0]]);
+					}
+					if (targetId != null) try {
+						await db.insertInto(throughTable).values({
+							[fpk]: pkValue,
+							[rpk]: targetId
+						}).execute();
+					} catch (e) {
+						if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+					}
+				}
+			}
+			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();
+				const setLookup = /* @__PURE__ */ new Map();
+				const setObjects = mop.set.filter((t) => typeof t !== "number" && typeof t !== "string");
+				if (setObjects.length > 0) {
+					const byKey = /* @__PURE__ */ new Map();
+					for (const t of setObjects) {
+						const k = Object.keys(t)[0];
+						if (!byKey.has(k)) byKey.set(k, []);
+						byKey.get(k).push(t[k]);
+					}
+					for (const [k, vals] of byKey) {
+						const records = await relatedDef.query().whereIn(k, vals).execute();
+						for (const r of records) setLookup.set(r.get(k), r.get("id"));
+					}
+				}
+				for (const target of mop.set) {
+					let targetId = target;
+					if (typeof target !== "number" && typeof target !== "string") {
+						const t = target;
+						targetId = setLookup.get(t[Object.keys(t)[0]]);
+					}
+					if (targetId != null) {
+						desiredIds.add(targetId);
+						if (!currentIds.has(targetId)) try {
+							await db.insertInto(throughTable).values({
+								[fpk]: pkValue,
+								[rpk]: targetId
+							}).execute();
+						} catch (e) {
+							if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+						}
+					}
+				}
+				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(def.table).selectAll().where(pk, "=", pkValue).executeTakeFirst();
+		if (row) {
+			const config = getConfig(def);
+			const applied = config?.casts ? applyCastsToData(config, row) : row;
+			const state = getState(model);
+			state.attributes = { ...applied };
+			state.original = { ...applied };
+		}
+	} catch (e) {
+		throw normalizeError(e, def.table);
+	}
+}
+const configMap = /* @__PURE__ */ new WeakMap();
+function setConfig(def, config) {
+	configMap.set(def, config);
+}
+function getConfig(def) {
+	return configMap.get(def);
+}
+//#endregion
 //#region src/relations/eager.ts
 var eager_exports = /* @__PURE__ */ __exportAll({ EagerLoader: () => EagerLoader });
-function isMorphRelation(relation) {
-	return relation._morphMap !== void 0;
-}
 var EagerLoader = class {
 	async loadRelated(models, eagerLoad, def) {
 		const { name, constraints } = eagerLoad;
@@ -266,7 +684,7 @@ var EagerLoader = class {
 			const nestedName = name.slice(dotIdx + 1);
 			const relation = def.relations[baseName];
 			if (!relation) throw new Error(`Relation "${baseName}" not found on ${def.name}`);
-			if (isMorphRelation(relation)) throw new Error(`Cannot eagerly load nested relation "${nestedName}" through polymorphic relation "${baseName}" on ${def.name}. Nested eager loading through polymorphic belongsTo is not supported.`);
+			if (relation._morphMap !== void 0) throw new Error(`Cannot eagerly load nested relation "${nestedName}" through polymorphic relation "${baseName}" on ${def.name}. Nested eager loading through polymorphic belongsTo is not supported.`);
 			await relation.loadEager(models, baseName, null);
 			const relatedModels = [];
 			for (const model of models) {
@@ -288,64 +706,31 @@ var EagerLoader = class {
 	}
 };
 //#endregion
-//#region src/relations/graph/morph.ts
-/** Whether this relation is a MorphTo (polymorphic belongsTo) */
-function isMorphToRelation(relation) {
-	return relation._morphMap !== void 0;
-}
-/** Whether this relation is a MorphMany or MorphOne (polymorphic hasMany/hasOne) */
-function isMorphManyRelation(relation) {
-	return relation._morphType !== void 0 && !isMorphToRelation(relation);
-}
-/** Get the morph type column name (e.g. "commentableType") from a morph relation */
-function getMorphType(relation) {
-	return relation._morphType;
-}
-/** Get the morph type value (e.g. "morph_posts") from a MorphMany/MorphOne relation */
-function getMorphTypeValue(relation) {
-	return relation._morphTypeValue;
-}
-/** Get the morph id column name (e.g. "commentableId") from a morph relation */
-function getMorphId(relation) {
-	return relation._morphId;
-}
-const THUNK_CACHE$3 = /* @__PURE__ */ new WeakMap();
-function resolveThunk$3(thunk) {
-	let cls = THUNK_CACHE$3.get(thunk);
-	if (!cls) {
-		cls = thunk();
-		THUNK_CACHE$3.set(thunk, cls);
+//#region src/relations/graph/delete.ts
+async function deleteGraph(def, model, options = {}) {
+	const db = getDb(def);
+	const pk = getPrimaryKeyColumn(def);
+	const pkValue = model.get(pk);
+	if (pkValue == null) throw new Error("Cannot deleteGraph: model has no primary key");
+	for (const [relationName, relation] of Object.entries(def.relations)) {
+		if (options.allowedRelations && !options.allowedRelations.includes(relationName)) continue;
+		const relatedDef = relation.relatedModelClass;
+		if (relation.type === "hasMany") {
+			const children = await relatedDef.query().where(relation.foreignKey, "=", pkValue).execute();
+			for (const child of children) await child.$delete();
+		} else if (relation.type === "manyToMany") {
+			const throughTable = relation.throughTable;
+			const fpk = relation.foreignPivotKey;
+			await db.deleteFrom(throughTable).where(fpk, "=", pkValue).execute();
+		} else if (relation.type === "hasOne") {
+			const child = await relatedDef.query().where(relation.foreignKey, "=", pkValue).first();
+			if (child) await child.$delete();
+		}
 	}
-	return cls;
+	await model.$delete();
 }
 //#endregion
 //#region src/relations/graph/parser.ts
-function getPrimaryKeyColumn$2(def) {
-	const cols = def.columns;
-	for (const [name, col] of Object.entries(cols)) if (col.isPrimaryKey) return name;
-	return "id";
-}
-function getDb$1(def) {
-	if (!def._orm) throw new Error("Model not registered");
-	return def._orm.kysely;
-}
-function getPivotInfo(relation) {
-	if (relation.type !== "manyToMany" || !relation.throughTable) throw new Error("Not a many-to-many relation");
-	return {
-		throughTable: relation.throughTable,
-		foreignPivotKey: relation.foreignPivotKey ?? "",
-		relatedPivotKey: relation.relatedPivotKey ?? ""
-	};
-}
-async function findRelated(def, conditions) {
-	const key = Object.keys(conditions)[0];
-	return def.query().where(key, "=", conditions[key]).executeTakeFirst();
-}
-async function resolveTargetId(def, target) {
-	if (typeof target === "number" || typeof target === "string") return target;
-	const found = await findRelated(def, target);
-	if (found) return found.get("id");
-}
 /**
 * Splits a graph node's keys into column data and relation operations.
 * Handles both the old-style { create: ..., connect: ... } wrappers and
@@ -509,7 +894,7 @@ async function processNode(node, def, parentFK, options, context, path) {
 	}
 	const instance = await def.insert(columnData);
 	if (nodeId && typeof nodeId === "string") context.processedRefs.set(nodeId, instance);
-	const pkCol = getPrimaryKeyColumn$2(def);
+	const pkCol = getPrimaryKeyColumn(def);
 	const pkValue = instance.get(pkCol);
 	if (pkValue == null) throw new DatabaseError("Cannot process relations without primary key", "MISSING_ID");
 	for (const [relName, op] of Object.entries(relationOps)) {
@@ -528,7 +913,7 @@ async function processNode(node, def, parentFK, options, context, path) {
 	return instance;
 }
 async function processBelongsTo(relation, op, options, context, path, parentColumnData) {
-	if (isMorphToRelation(relation)) return processMorphTo(relation, op, options, context, path, parentColumnData);
+	if (relation._morphMap !== void 0) return processMorphTo(relation, op, options, context, path, parentColumnData);
 	const relatedDef = relation.relatedModelClass;
 	if (op["#dbRef"] != null) {
 		const id = op["#dbRef"];
@@ -556,8 +941,8 @@ async function processBelongsTo(relation, op, options, context, path, parentColu
 */
 async function processMorphTo(relation, op, options, context, path, parentColumnData) {
 	const morphMap = relation._morphMap;
-	const morphType = getMorphType(relation);
-	const morphId = getMorphId(relation);
+	const morphType = relation._morphType;
+	const morphId = relation._morphId;
 	if (!morphMap || Object.keys(morphMap).length === 0) throw new Error("Cannot process MorphTo relation: no morphMap provided. Define a morphMap with model thunks when calling defineMorphTo().");
 	let typeValue = op.type;
 	if (!typeValue) {
@@ -567,7 +952,7 @@ async function processMorphTo(relation, op, options, context, path, parentColumn
 	if (!typeValue) throw new Error(`Cannot resolve MorphTo: no type specified. Provide a "type" key in the relation data (e.g., { type: "${Object.keys(morphMap)[0]}" }). Available types: ${Object.keys(morphMap).join(", ")}`);
 	const thunk = morphMap[typeValue];
 	if (!thunk) throw new Error(`No model registered for morph type "${typeValue}" in MorphTo. Available types: ${Object.keys(morphMap).join(", ")}`);
-	const relatedDef = resolveThunk$3(thunk);
+	const relatedDef = resolveThunk(thunk);
 	let instance = null;
 	if (op["#dbRef"] != null) {
 		const id = op["#dbRef"];
@@ -609,9 +994,9 @@ async function processHasMany(_instance, relation, op, pkValue, options, context
 			continue;
 		}
 		const parentData = { [fk]: pkValue };
-		if (isMorphManyRelation(relation)) {
-			const typeCol = getMorphType(relation);
-			const typeVal = getMorphTypeValue(relation);
+		if (relation._morphType !== void 0 && relation._morphMap === void 0) {
+			const typeCol = relation._morphType;
+			const typeVal = relation._morphTypeValue;
 			if (typeVal !== void 0) parentData[typeCol] = typeVal;
 		}
 		await processNode(item, relatedDef, parentData, options, context, path);
@@ -631,7 +1016,7 @@ async function processHasMany(_instance, relation, op, pkValue, options, context
 async function processManyToMany(_instance, relation, op, pkValue, options, context, path) {
 	const relatedDef = relation.relatedModelClass;
 	const { throughTable, foreignPivotKey, relatedPivotKey } = getPivotInfo(relation);
-	const db = getDb$1(relatedDef);
+	const db = getDb(relatedDef);
 	const items = Array.isArray(op) ? op : Array.isArray(op?.create) ? op.create : [];
 	for (const item of items) {
 		if (item["#dbRef"] != null) {
@@ -641,7 +1026,9 @@ async function processManyToMany(_instance, relation, op, pkValue, options, cont
 					[foreignPivotKey]: pkValue,
 					[relatedPivotKey]: id
 				}).execute();
-			} catch {}
+			} catch (e) {
+				if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+			}
 			continue;
 		}
 		const relatedId = (await processNode(item, relatedDef, null, options, context, path)).get(relation.localKey ?? "id");
@@ -650,7 +1037,9 @@ async function processManyToMany(_instance, relation, op, pkValue, options, cont
 				[foreignPivotKey]: pkValue,
 				[relatedPivotKey]: relatedId
 			}).execute();
-		} catch {}
+		} catch (e) {
+			if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+		}
 	}
 	const connectItems = !Array.isArray(op) ? op?.connect ?? [] : [];
 	for (const target of connectItems) {
@@ -660,7 +1049,9 @@ async function processManyToMany(_instance, relation, op, pkValue, options, cont
 				[foreignPivotKey]: pkValue,
 				[relatedPivotKey]: targetId
 			}).execute();
-		} catch {}
+		} catch (e) {
+			if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+		}
 	}
 }
 //#endregion
@@ -704,7 +1095,7 @@ async function upsertNode(node, def, parentFK, options, context, _path) {
 			if (relatedInstance) columnData[relation.foreignKey] = relatedInstance.get(relation.localKey);
 		}
 	}
-	const pkCol = getPrimaryKeyColumn$2(def);
+	const pkCol = getPrimaryKeyColumn(def);
 	const idValue = columnData[pkCol] ?? node[pkCol];
 	let instance;
 	if (idValue != null) if (isRelPathAllowed(pkCol, options.noUpdate)) {
@@ -740,13 +1131,13 @@ async function upsertHasMany(_instance, relation, op, pkValue, options, context,
 	const existingChildren = await relatedDef.query().where(fk, "=", pkValue).execute();
 	const existingMap = /* @__PURE__ */ new Map();
 	for (const child of existingChildren) {
-		const pkCol = getPrimaryKeyColumn$2(relatedDef);
+		const pkCol = getPrimaryKeyColumn(relatedDef);
 		existingMap.set(child.get(pkCol), child);
 	}
 	const items = Array.isArray(op) ? op : Array.isArray(op?.create) ? op.create : [];
 	const incomingIds = /* @__PURE__ */ new Set();
 	for (const item of items) {
-		const itemId = item[getPrimaryKeyColumn$2(relatedDef)] ?? item.id;
+		const itemId = item[getPrimaryKeyColumn(relatedDef)] ?? item.id;
 		if (itemId != null) {
 			incomingIds.add(itemId);
 			if (!isRelPathAllowed(relNameFromPath(path), options.noUpdate)) {
@@ -762,7 +1153,7 @@ async function upsertHasMany(_instance, relation, op, pkValue, options, context,
 						if (!rel) continue;
 						const nestedPath = `${path}.${relName}`;
 						assertRelationAllowed(relatedDef, nestedPath, context.allowedGraphSet);
-						const childPk = existing.get(getPrimaryKeyColumn$2(relatedDef));
+						const childPk = existing.get(getPrimaryKeyColumn(relatedDef));
 						if (rel.type === "hasMany" || rel.type === "hasOne") await upsertHasMany(existing, rel, relOp, childPk, options, context, nestedPath);
 						else if (rel.type === "manyToMany") await upsertManyToMany(existing, rel, relOp, childPk, options, context, nestedPath);
 					}
@@ -771,9 +1162,9 @@ async function upsertHasMany(_instance, relation, op, pkValue, options, context,
 			}
 		}
 		const parentData = { [fk]: pkValue };
-		if (isMorphManyRelation(relation)) {
-			const typeCol = getMorphType(relation);
-			const typeVal = getMorphTypeValue(relation);
+		if (relation._morphType !== void 0 && relation._morphMap === void 0) {
+			const typeCol = relation._morphType;
+			const typeVal = relation._morphTypeValue;
 			if (typeVal !== void 0) parentData[typeCol] = typeVal;
 		}
 		await processNode(item, relatedDef, parentData, options, context, path);
@@ -793,7 +1184,7 @@ async function upsertHasMany(_instance, relation, op, pkValue, options, context,
 async function upsertManyToMany(_instance, relation, op, pkValue, options, context, path) {
 	const relatedDef = relation.relatedModelClass;
 	const { throughTable, foreignPivotKey, relatedPivotKey } = getPivotInfo(relation);
-	const db = getDb$1(relatedDef);
+	const db = getDb(relatedDef);
 	let existingPivotIds = /* @__PURE__ */ new Set();
 	try {
 		const pivots = await db.selectFrom(throughTable).select(relatedPivotKey).where(foreignPivotKey, "=", pkValue).execute();
@@ -801,6 +1192,14 @@ async function upsertManyToMany(_instance, relation, op, pkValue, options, conte
 	} catch {}
 	const incomingIds = /* @__PURE__ */ new Set();
 	const items = Array.isArray(op) ? op : Array.isArray(op?.create) ? op.create : [];
+	const needsUpdate = !isRelPathAllowed(relNameFromPath(path), options.noUpdate);
+	const pkCol = getPrimaryKeyColumn(relatedDef);
+	const itemIds = items.filter((i) => i["#dbRef"] == null).map((i) => i[pkCol] ?? i.id).filter((id) => id != null);
+	const batchMap = /* @__PURE__ */ new Map();
+	if (needsUpdate && itemIds.length > 0) {
+		const records = await relatedDef.query().whereIn(pkCol, itemIds).execute();
+		for (const r of records) batchMap.set(r.get(pkCol), r);
+	}
 	for (const item of items) {
 		if (item["#dbRef"] != null) {
 			const id = item["#dbRef"];
@@ -810,14 +1209,16 @@ async function upsertManyToMany(_instance, relation, op, pkValue, options, conte
 					[foreignPivotKey]: pkValue,
 					[relatedPivotKey]: id
 				}).execute();
-			} catch {}
+			} catch (e) {
+				if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+			}
 			continue;
 		}
-		const itemId = item[getPrimaryKeyColumn$2(relatedDef)] ?? item.id;
+		const itemId = item[pkCol] ?? item.id;
 		if (itemId != null) {
 			incomingIds.add(itemId);
-			if (!isRelPathAllowed(relNameFromPath(path), options.noUpdate)) {
-				const existing = await relatedDef.find(itemId);
+			if (needsUpdate) {
+				const existing = batchMap.get(itemId);
 				if (existing) {
 					existing.fill(item);
 					await existing.$save();
@@ -828,7 +1229,9 @@ async function upsertManyToMany(_instance, relation, op, pkValue, options, conte
 					[foreignPivotKey]: pkValue,
 					[relatedPivotKey]: itemId
 				}).execute();
-			} catch {}
+			} catch (e) {
+				if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+			}
 		} else {
 			const relatedId = (await processNode(item, relatedDef, null, options, context, path)).get(relation.localKey ?? "id");
 			if (relatedId != null) {
@@ -838,13 +1241,33 @@ async function upsertManyToMany(_instance, relation, op, pkValue, options, conte
 						[foreignPivotKey]: pkValue,
 						[relatedPivotKey]: relatedId
 					}).execute();
-				} catch {}
+				} catch (e) {
+					if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+				}
 			}
 		}
 	}
 	const connectItems = !Array.isArray(op) ? op?.connect ?? [] : [];
+	const connectLookup = /* @__PURE__ */ new Map();
+	const connectObjects = connectItems.filter((t) => typeof t !== "number" && typeof t !== "string");
+	if (connectObjects.length > 0) {
+		const byKey = /* @__PURE__ */ new Map();
+		for (const t of connectObjects) {
+			const k = Object.keys(t)[0];
+			if (!byKey.has(k)) byKey.set(k, []);
+			byKey.get(k).push(t[k]);
+		}
+		for (const [k, vals] of byKey) {
+			const records = await relatedDef.query().whereIn(k, vals).execute();
+			for (const r of records) connectLookup.set(r.get(k), r.get("id"));
+		}
+	}
 	for (const target of connectItems) {
-		const targetId = await resolveTargetId(relatedDef, target);
+		let targetId = target;
+		if (typeof target !== "number" && typeof target !== "string") {
+			const t = target;
+			targetId = connectLookup.get(t[Object.keys(t)[0]]);
+		}
 		if (targetId != null) {
 			incomingIds.add(targetId);
 			if (!existingPivotIds.has(targetId)) try {
@@ -852,7 +1275,9 @@ async function upsertManyToMany(_instance, relation, op, pkValue, options, conte
 					[foreignPivotKey]: pkValue,
 					[relatedPivotKey]: targetId
 				}).execute();
-			} catch {}
+			} catch (e) {
+				if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+			}
 		}
 	}
 	const relName = relNameFromPath(path);
@@ -862,12 +1287,16 @@ async function upsertManyToMany(_instance, relation, op, pkValue, options, conte
 		for (const pivotId of existingPivotIds) if (!incomingIds.has(pivotId)) {
 			if (shouldUnrelate) try {
 				await db.deleteFrom(throughTable).where(foreignPivotKey, "=", pkValue).where(relatedPivotKey, "=", pivotId).execute();
-			} catch {}
+			} catch (e) {
+				if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+			}
 			else if (shouldDelete) {
 				await (await relatedDef.find(pivotId))?.$delete();
 				try {
 					await db.deleteFrom(throughTable).where(foreignPivotKey, "=", pkValue).where(relatedPivotKey, "=", pivotId).execute();
-				} catch {}
+				} catch (e) {
+					if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+				}
 			}
 		}
 	}
@@ -875,14 +1304,12 @@ async function upsertManyToMany(_instance, relation, op, pkValue, options, conte
 //#endregion
 //#region src/relations/graph/index.ts
 var graph_exports = /* @__PURE__ */ __exportAll({
+	deleteGraph: () => deleteGraph,
 	insertGraph: () => insertGraph,
 	upsertGraph: () => upsertGraph
 });
 //#endregion
 //#region src/query/builder.ts
-function rawSql(str) {
-	return sql([str]);
-}
 const SAFE_COLUMN = /^[a-zA-Z_*][a-zA-Z0-9_.*]*$/;
 function createQueryBuilder(def, peta) {
 	const db = peta?.kysely ?? def._orm?.kysely;
@@ -897,7 +1324,6 @@ function createQueryBuilder(def, peta) {
 	let hasEffectiveWhere = false;
 	let selectedColumns = null;
 	const aggregateColumns = [];
-	const aggregateAliases = [];
 	const whereOps = [];
 	let allowedGraphSet = null;
 	function validateColumn(ref) {
@@ -941,6 +1367,16 @@ function createQueryBuilder(def, peta) {
 		}
 		return models;
 	}
+	const _withAggregate = (relationName, aggregateSql, alias, isExists = false) => {
+		const rel = def.relations[relationName];
+		if (!rel) throw new RelationNotFoundError(def.name, relationName);
+		const relatedTable = rel.relatedModelClass.table;
+		const fk = rel.foreignKey;
+		const lk = rel.localKey;
+		const sql = isExists ? `(SELECT EXISTS(SELECT 1 FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk})) as ${alias}` : `(SELECT ${aggregateSql} FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`;
+		aggregateColumns.push(sql);
+		return self;
+	};
 	const self = {
 		then(onfulfilled, onrejected) {
 			return runExecute().then(onfulfilled, onrejected);
@@ -948,7 +1384,7 @@ function createQueryBuilder(def, peta) {
 		execute: runExecute,
 		async collect() {
 			const items = await runExecute();
-			const { createCollection } = await import("./collection-PFmrQHyM.mjs").then((n) => n.t);
+			const { createCollection } = await import("./collection-D9YZn2mL.mjs").then((n) => n.t);
 			return createCollection(items);
 		},
 		async executeTakeFirst() {
@@ -1004,70 +1440,10 @@ function createQueryBuilder(def, peta) {
 			return Number(result?.max ?? 0);
 		},
 		withCount(relation) {
-			const alias = `${relation}_count`;
-			const rel = def.relations[relation];
-			if (!rel) throw new RelationNotFoundError(def.name, relation);
-			const relatedTable = rel.relatedModelClass.table;
-			const fk = rel.foreignKey;
-			const lk = rel.localKey;
-			aggregateColumns.push(`(SELECT COUNT(*) FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`);
-			aggregateAliases.push(alias);
-			return self;
+			return _withAggregate(relation, "COUNT(*)", `${relation}_count`);
 		},
 		withSum(relation, column) {
-			const alias = `${relation}_sum_${column}`;
-			const rel = def.relations[relation];
-			if (!rel) throw new RelationNotFoundError(def.name, relation);
-			const relatedTable = rel.relatedModelClass.table;
-			const fk = rel.foreignKey;
-			const lk = rel.localKey;
-			aggregateColumns.push(`(SELECT COALESCE(SUM(${relatedTable}.${validateColumn(column)}), 0) FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`);
-			aggregateAliases.push(alias);
-			return self;
-		},
-		withAvg(relation, column) {
-			const alias = `${relation}_avg_${column}`;
-			const rel = def.relations[relation];
-			if (!rel) throw new RelationNotFoundError(def.name, relation);
-			const relatedTable = rel.relatedModelClass.table;
-			const fk = rel.foreignKey;
-			const lk = rel.localKey;
-			aggregateColumns.push(`(SELECT AVG(${relatedTable}.${validateColumn(column)}) FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`);
-			aggregateAliases.push(alias);
-			return self;
-		},
-		withMin(relation, column) {
-			const alias = `${relation}_min_${column}`;
-			const rel = def.relations[relation];
-			if (!rel) throw new RelationNotFoundError(def.name, relation);
-			const relatedTable = rel.relatedModelClass.table;
-			const fk = rel.foreignKey;
-			const lk = rel.localKey;
-			aggregateColumns.push(`(SELECT MIN(${relatedTable}.${validateColumn(column)}) FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`);
-			aggregateAliases.push(alias);
-			return self;
-		},
-		withMax(relation, column) {
-			const alias = `${relation}_max_${column}`;
-			const rel = def.relations[relation];
-			if (!rel) throw new RelationNotFoundError(def.name, relation);
-			const relatedTable = rel.relatedModelClass.table;
-			const fk = rel.foreignKey;
-			const lk = rel.localKey;
-			aggregateColumns.push(`(SELECT MAX(${relatedTable}.${validateColumn(column)}) FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk}) as ${alias}`);
-			aggregateAliases.push(alias);
-			return self;
-		},
-		withExists(relation) {
-			const alias = `${relation}_exists`;
-			const rel = def.relations[relation];
-			if (!rel) throw new RelationNotFoundError(def.name, relation);
-			const relatedTable = rel.relatedModelClass.table;
-			const fk = rel.foreignKey;
-			const lk = rel.localKey;
-			aggregateColumns.push(`(SELECT EXISTS(SELECT 1 FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk})) as ${alias}`);
-			aggregateAliases.push(alias);
-			return self;
+			return _withAggregate(relation, `COALESCE(SUM(${validateColumn(column)}), 0)`, `${relation}_sum_${column}`);
 		},
 		async chunk(size, callback) {
 			let offset = 0;
@@ -1128,6 +1504,19 @@ function createQueryBuilder(def, peta) {
 				allowGraph: allowedGraphSet ? [...allowedGraphSet] : options?.allowGraph
 			});
 		},
+		async upsert(data) {
+			const pk = getPrimaryKeyColumn(def);
+			const pkValue = data[pk];
+			if (pkValue != null) {
+				const existing = await db.selectFrom(def.table).selectAll().where(pk, "=", pkValue).executeTakeFirst();
+				if (existing) {
+					const instance = def.hydrate(existing);
+					instance.fill(data);
+					return instance.$save();
+				}
+			}
+			return insertModel(def, data);
+		},
 		async updateMany(data) {
 			applyScopes();
 			assertWhereForMutation();
@@ -1156,9 +1545,9 @@ function createQueryBuilder(def, peta) {
 			for (const op of whereOps) updateQb = op(updateQb);
 			try {
 				const result = await updateQb.execute();
-				return Number(result.numUpdatedRows ?? 0);
+				return Number(result[0]?.numUpdatedRows ?? 0);
 			} catch (e) {
-				const { normalizeError } = await import("./errors-sfFJolfu.mjs").then((n) => n.t);
+				const { normalizeError } = await import("./errors-i-gCZnlW.mjs").then((n) => n.t);
 				throw normalizeError(e, def.table);
 			}
 		},
@@ -1199,9 +1588,9 @@ function createQueryBuilder(def, peta) {
 			let numDeleted = 0;
 			try {
 				const result = await deleteQb.execute();
-				numDeleted = Number(result.numDeletedRows ?? 0);
+				numDeleted = Number(result[0]?.numDeletedRows ?? 0);
 			} catch (e) {
-				const { normalizeError } = await import("./errors-sfFJolfu.mjs").then((n) => n.t);
+				const { normalizeError } = await import("./errors-i-gCZnlW.mjs").then((n) => n.t);
 				throw normalizeError(e, def.table);
 			}
 			if (hasAfter && deletedRows.length > 0) {
@@ -1234,34 +1623,38 @@ function createQueryBuilder(def, peta) {
 			hasEffectiveWhere = values.length > 0;
 			return self;
 		},
-		whereInPivot(column, values) {
-			qb = qb.where(validateColumn(column), "in", values);
-			whereOps.push((q) => q.where(validateColumn(column), "in", values));
-			hasEffectiveWhere = values.length > 0;
-			return self;
-		},
 		has(relationName) {
 			const rel = def.relations[relationName];
 			if (!rel) throw new RelationNotFoundError(def.name, relationName);
 			const relatedTable = rel.relatedModelClass.table;
 			const fk = rel.foreignKey;
 			const lk = rel.localKey;
-			const existsExpr = rawSql(`EXISTS (SELECT 1 FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk})`);
+			const existsExpr = sql([`EXISTS (SELECT 1 FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk})`]);
 			qb = qb.where(existsExpr);
 			hasEffectiveWhere = true;
 			return self;
 		},
-		whereHas(relationName, _callback) {
-			return self.has(relationName);
+		whereHas(relationName, callback) {
+			const rel = def.relations[relationName];
+			if (!rel) throw new RelationNotFoundError(def.name, relationName);
+			const relatedTable = rel.relatedModelClass.table;
+			const fk = rel.foreignKey;
+			const lk = rel.localKey;
+			let subQuery = db.selectFrom(relatedTable).select(sql`1`.as("dummy")).whereRef(`${relatedTable}.${fk}`, "=", `${def.table}.${lk}`);
+			if (callback) subQuery = callback(subQuery) ?? subQuery;
+			qb = qb.where(sql`EXISTS ${subQuery}`);
+			hasEffectiveWhere = true;
+			return self;
 		},
-		whereDoesntHave(relationName, _callback) {
+		whereDoesntHave(relationName, callback) {
 			const rel = def.relations[relationName];
 			if (!rel) throw new RelationNotFoundError(def.name, relationName);
 			const relatedTable = rel.relatedModelClass.table;
 			const fk = rel.foreignKey;
 			const lk = rel.localKey;
-			const notExistsExpr = rawSql(`NOT EXISTS (SELECT 1 FROM ${relatedTable} WHERE ${relatedTable}.${fk} = ${def.table}.${lk})`);
-			qb = qb.where(notExistsExpr);
+			let subQuery = db.selectFrom(relatedTable).select(sql`1`.as("dummy")).whereRef(`${relatedTable}.${fk}`, "=", `${def.table}.${lk}`);
+			if (callback) subQuery = callback(subQuery) ?? subQuery;
+			qb = qb.where(sql`NOT EXISTS ${subQuery}`);
 			hasEffectiveWhere = true;
 			return self;
 		},
@@ -1357,6 +1750,44 @@ function createQueryBuilder(def, peta) {
 	return self;
 }
 //#endregion
+//#region src/model/computed.ts
+var computed_exports = /* @__PURE__ */ __exportAll({
+	applyComputedColumnsAsync: () => applyComputedColumnsAsync,
+	getComputedConfig: () => getComputedConfig,
+	setComputedConfig: () => setComputedConfig
+});
+const computedConfigs = /* @__PURE__ */ new WeakMap();
+function setComputedConfig(def, config) {
+	computedConfigs.set(def, config);
+}
+function getComputedConfig(def) {
+	return computedConfigs.get(def);
+}
+/**
+* Apply computed columns to a set of loaded records.
+* Handles SQL, runtime, and batch computed columns.
+*/
+/** Resolve a ComputedConfig entry (lazy function or plain object). */
+function resolveComputedColumn(entry) {
+	return typeof entry === "function" ? entry() : entry;
+}
+/**
+* Apply computed columns and return a promise (for async batch computes).
+*/
+async function applyComputedColumnsAsync(records, computedConfig, selectedColumns) {
+	if (records.length === 0) return;
+	const relevant = Object.entries(computedConfig).filter(([name]) => !selectedColumns || selectedColumns.includes(name));
+	const batchDefs = relevant.filter(([, c]) => resolveComputedColumn(c).type === "batch");
+	for (const [name, col] of batchDefs) if (col.batchCompute) {
+		const values = await col.batchCompute(records);
+		for (let i = 0; i < records.length && i < values.length; i++) records[i].set(name, values[i]);
+	}
+	for (const record of records) for (const [name, c] of relevant) {
+		const col = resolveComputedColumn(c);
+		if (col.type === "runtime" && col.compute) record.set(name, col.compute(record));
+	}
+}
+//#endregion
 //#region src/model/scopes.ts
 const globalScopes = /* @__PURE__ */ new WeakMap();
 function addScope(def, name, callback) {
@@ -1396,16 +1827,41 @@ function defineModel(table, config) {
 			return this.query().first();
 		},
 		async create(data) {
-			return (await import("./save-D5UKXvqC.mjs").then((n) => n.i)).insertModel(def, data);
+			return (await Promise.resolve().then(() => save_exports)).insertModel(def, data);
 		},
 		async insert(data) {
-			return (await import("./save-D5UKXvqC.mjs").then((n) => n.i)).insertModel(def, data);
+			return (await Promise.resolve().then(() => save_exports)).insertModel(def, data);
+		},
+		upsert(data) {
+			return this.query().all().upsert(data);
 		},
 		async insertMany(dataArray) {
-			return (await import("./save-D5UKXvqC.mjs").then((n) => n.i)).insertManyModel(def, dataArray);
+			return (await Promise.resolve().then(() => save_exports)).insertManyModel(def, dataArray);
+		},
+		async updateMany(data, where) {
+			let qb = this.query().all();
+			if (where.length > 0) {
+				const keys = Object.keys(where[0]);
+				for (const key of keys) {
+					const values = where.map((c) => c[key]);
+					qb = qb.whereIn(key, values);
+				}
+			}
+			return qb.updateMany(data);
+		},
+		async deleteMany(where) {
+			let qb = this.query().all();
+			if (where.length > 0) {
+				const keys = Object.keys(where[0]);
+				for (const key of keys) {
+					const values = where.map((c) => c[key]);
+					qb = qb.whereIn(key, values);
+				}
+			}
+			return qb.deleteMany();
 		},
 		async update(id, data) {
-			return (await import("./save-D5UKXvqC.mjs").then((n) => n.i)).updateModel(def, id, data);
+			return (await Promise.resolve().then(() => save_exports)).updateModel(def, id, data);
 		},
 		async insertGraph(data, options) {
 			return (await Promise.resolve().then(() => graph_exports)).insertGraph(def, data, options);
@@ -1413,6 +1869,12 @@ function defineModel(table, config) {
 		async upsertGraph(data, options) {
 			return (await Promise.resolve().then(() => graph_exports)).upsertGraph(def, data, options);
 		},
+		async deleteGraph(idOrInstance, options) {
+			const model = typeof idOrInstance === "object" ? idOrInstance : await def.find(idOrInstance);
+			if (!model) return;
+			const { deleteGraph: deleteGraphFn } = await Promise.resolve().then(() => graph_exports);
+			return deleteGraphFn(def, model, options);
+		},
 		async delete(id) {
 			const model = await this.findOrFail(id);
 			await (await Promise.resolve().then(() => delete_exports)).deleteModel(def, model);
@@ -1453,39 +1915,19 @@ function defineModel(table, config) {
 		beforeUpdate(callback) {
 			return addStaticHook(def, "beforeUpdate", callback);
 		},
-		afterUpdate(callback) {
-			return addStaticHook(def, "afterUpdate", callback);
-		},
-		beforeCreate(callback) {
-			return addStaticHook(def, "beforeCreate", callback);
-		},
-		afterCreate(callback) {
-			return addStaticHook(def, "afterCreate", callback);
-		},
-		beforeFind(callback) {
-			return addStaticHook(def, "beforeFind", callback);
-		},
-		afterFind(callback) {
-			return addStaticHook(def, "afterFind", callback);
-		},
 		_init(orm) {
 			def._orm = orm;
-			setConfig$1(def, config);
-			Promise.resolve().then(() => serialize_exports).then((mod) => mod.setConfig?.(def, config));
+			setConfig(def, config);
 		}
 	};
-	setConfig$1(def, config);
-	Promise.resolve().then(() => serialize_exports).then((mod) => mod.setConfig?.(def, config));
-	if (config.computed) Promise.resolve().then(() => computed_exports).then((mod) => mod.setComputedConfig?.(def, config.computed));
+	setConfig(def, config);
+	if (config.computed) setComputedConfig(def, config.computed);
 	def.registerTimestamps = (createdAtCol, updatedAtCol) => {
 		registerTimestampsFor(def, createdAtCol, updatedAtCol);
 	};
 	def.registerSoftDeletes = (deletedAtCol) => {
 		registerSoftDeletesFor(def, deletedAtCol);
 	};
-	def.discover = async () => {
-		throw new Error("discover() not yet implemented in v2");
-	};
 	return def;
 }
 //#endregion
@@ -1532,44 +1974,6 @@ var Attribute = class Attribute {
 	}
 };
 //#endregion
-//#region src/model/computed.ts
-var computed_exports = /* @__PURE__ */ __exportAll({
-	applyComputedColumnsAsync: () => applyComputedColumnsAsync,
-	getComputedConfig: () => getComputedConfig,
-	setComputedConfig: () => setComputedConfig
-});
-const computedConfigs = /* @__PURE__ */ new WeakMap();
-function setComputedConfig(def, config) {
-	computedConfigs.set(def, config);
-}
-function getComputedConfig(def) {
-	return computedConfigs.get(def);
-}
-/**
-* Apply computed columns to a set of loaded records.
-* Handles SQL, runtime, and batch computed columns.
-*/
-/** Resolve a ComputedConfig entry (lazy function or plain object). */
-function resolveComputedColumn(entry) {
-	return typeof entry === "function" ? entry() : entry;
-}
-/**
-* Apply computed columns and return a promise (for async batch computes).
-*/
-async function applyComputedColumnsAsync(records, computedConfig, selectedColumns) {
-	if (records.length === 0) return;
-	const relevant = Object.entries(computedConfig).filter(([name]) => !selectedColumns || selectedColumns.includes(name));
-	const batchDefs = relevant.filter(([, c]) => resolveComputedColumn(c).type === "batch");
-	for (const [name, col] of batchDefs) if (col.batchCompute) {
-		const values = await col.batchCompute(records);
-		for (let i = 0; i < records.length && i < values.length; i++) records[i].set(name, values[i]);
-	}
-	for (const record of records) for (const [name, c] of relevant) {
-		const col = resolveComputedColumn(c);
-		if (col.type === "runtime" && col.compute) record.set(name, col.compute(record));
-	}
-}
-//#endregion
 //#region src/model/delete.ts
 var delete_exports = /* @__PURE__ */ __exportAll({
 	deleteModel: () => deleteModel,
@@ -1577,20 +1981,8 @@ var delete_exports = /* @__PURE__ */ __exportAll({
 	restoreModel: () => restoreModel,
 	trashedModel: () => trashedModel
 });
-function getTable(def) {
-	return def.table;
-}
-function getDb(def) {
-	if (!def._orm) throw new ModelNotRegisteredError(def.name);
-	return def._orm.kysely;
-}
-function getPrimaryKeyColumn$1(def) {
-	const cols = def.columns;
-	for (const [name, col] of Object.entries(cols)) if (col.isPrimaryKey) return name;
-	return "id";
-}
 async function deleteModel(def, model) {
-	const pk = getPrimaryKeyColumn$1(def);
+	const pk = getPrimaryKeyColumn(def);
 	const pkValue = model.get(pk);
 	if (pkValue == null) throw new DatabaseError("Cannot delete model without primary key", "MISSING_ID");
 	const hm = getHooksFor(def);
@@ -1599,9 +1991,9 @@ async function deleteModel(def, model) {
 		const config = getSoftDeleteConfig(def);
 		const db = getDb(def);
 		try {
-			await db.updateTable(getTable(def)).set({ [config.column]: (/* @__PURE__ */ new Date()).toISOString() }).where(pk, "=", pkValue).execute();
+			await db.updateTable(def.table).set({ [config.column]: (/* @__PURE__ */ new Date()).toISOString() }).where(pk, "=", pkValue).execute();
 		} catch (e) {
-			throw normalizeError(e, getTable(def));
+			throw normalizeError(e, def.table);
 		}
 		model.set(config.column, (/* @__PURE__ */ new Date()).toISOString());
 		await hm.trigger("afterDelete", model);
@@ -1609,31 +2001,31 @@ async function deleteModel(def, model) {
 		await hm.trigger("beforeDelete", model);
 		const db = getDb(def);
 		try {
-			await db.deleteFrom(getTable(def)).where(pk, "=", pkValue).execute();
+			await db.deleteFrom(def.table).where(pk, "=", pkValue).execute();
 		} catch (e) {
-			throw normalizeError(e, getTable(def));
+			throw normalizeError(e, def.table);
 		}
 		setExists(model, false);
 		await hm.trigger("afterDelete", model);
 	}
 }
 async function forceDeleteModel(def, model) {
-	const pk = getPrimaryKeyColumn$1(def);
+	const pk = getPrimaryKeyColumn(def);
 	const pkValue = model.get(pk);
 	if (pkValue == null) throw new DatabaseError("Cannot delete model without primary key", "MISSING_ID");
 	const hm = getHooksFor(def);
 	await hm.trigger("beforeForceDelete", model);
 	const db = getDb(def);
 	try {
-		await db.deleteFrom(getTable(def)).where(pk, "=", pkValue).execute();
+		await db.deleteFrom(def.table).where(pk, "=", pkValue).execute();
 	} catch (e) {
-		throw normalizeError(e, getTable(def));
+		throw normalizeError(e, def.table);
 	}
 	setExists(model, false);
 	await hm.trigger("afterForceDelete", model);
 }
 async function restoreModel(def, model) {
-	const pk = getPrimaryKeyColumn$1(def);
+	const pk = getPrimaryKeyColumn(def);
 	const pkValue = model.get(pk);
 	if (pkValue == null) return;
 	if (!hasSoftDelete(def)) return;
@@ -1642,9 +2034,9 @@ async function restoreModel(def, model) {
 	const config = getSoftDeleteConfig(def);
 	const db = getDb(def);
 	try {
-		await db.updateTable(getTable(def)).set({ [config.column]: null }).where(pk, "=", pkValue).execute();
+		await db.updateTable(def.table).set({ [config.column]: null }).where(pk, "=", pkValue).execute();
 	} catch (e) {
-		throw normalizeError(e, getTable(def));
+		throw normalizeError(e, def.table);
 	}
 	model.set(config.column, null);
 	setExists(model, true);
@@ -1657,14 +2049,6 @@ function trashedModel(def, model) {
 }
 //#endregion
 //#region src/model/relation.ts
-var relation_exports = /* @__PURE__ */ __exportAll({
-	getModelDef: () => getModelDef,
-	loadModelRelations: () => loadModelRelations
-});
-const modelDefs = /* @__PURE__ */ new WeakMap();
-function getModelDef(instance) {
-	return modelDefs.get(instance);
-}
 async function loadModelRelations(model, def, ...relations) {
 	const { EagerLoader } = await Promise.resolve().then(() => eager_exports);
 	const loader = new EagerLoader();
@@ -1672,18 +2056,13 @@ async function loadModelRelations(model, def, ...relations) {
 }
 //#endregion
 //#region src/model/serialize.ts
-var serialize_exports = /* @__PURE__ */ __exportAll({
-	getConfig: () => getConfig,
-	modelToJSON: () => modelToJSON,
-	setConfig: () => setConfig
-});
 const VISITED = /* @__PURE__ */ new WeakSet();
 /** Type guard: checks if a value looks like a SerializableModel. */
 function isSerializableModel(value) {
 	return value !== null && typeof value === "object" && typeof value.$toJSON === "function";
 }
 function modelToJSON(def, model) {
-	const config = getConfig$1(def) ?? getConfig(def);
+	const config = getConfig(def);
 	const state = getState(model);
 	const result = {};
 	const attributes = state.attributes;
@@ -1730,13 +2109,6 @@ function modelToJSON(def, model) {
 	}
 	return result;
 }
-const configMap = /* @__PURE__ */ new WeakMap();
-function setConfig(def, config) {
-	configMap.set(def, config);
-}
-function getConfig(def) {
-	return configMap.get(def);
-}
 //#endregion
 //#region src/relations/related-query.ts
 /**
@@ -1895,9 +2267,14 @@ initRuntime({
 /**
 * Create an ORM instance — the central registry that wires Kysely to model definitions.
 * Replaces createPeta() from v0.x.
+*
+* Pass either `dialect` (to auto-create a Kysely instance) or `kysely` (to reuse one).
+* Passing a pre-existing Kysely instance avoids creating a second connection for
+* migration runners or other tools that already have their own Kysely.
 */
 function createORM(config) {
-	const kysely = new Kysely({ dialect: config.dialect });
+	if (!config.dialect && !config.kysely) throw new Error("createORM: provide either `dialect` (to create a Kysely instance) or `kysely` (to reuse one)");
+	const kysely = config.kysely ?? new Kysely({ dialect: config.dialect });
 	const modelMap = /* @__PURE__ */ new Map();
 	const orm = {
 		kysely,
@@ -1916,13 +2293,47 @@ function createORM(config) {
 			await kysely.destroy();
 		},
 		async transaction(fn) {
-			return kysely.transaction().execute((trx) => fn(trx));
+			return kysely.transaction().execute(async (trx) => {
+				this._trx = trx;
+				try {
+					return await fn(this);
+				} finally {
+					delete this._trx;
+				}
+			});
 		},
 		get models() {
 			return modelMap;
 		},
 		getModel(name) {
 			return modelMap.get(name);
+		},
+		async discover(pattern) {
+			const entries = [];
+			const glob = new Bun.Glob("**/*.ts");
+			const starIdx = pattern.lastIndexOf("*");
+			const baseDir = starIdx >= 0 ? pattern.slice(0, pattern.lastIndexOf("/", starIdx)) : pattern;
+			try {
+				for await (const match of glob.scan({
+					cwd: baseDir,
+					absolute: true,
+					onlyFiles: true
+				})) entries.push(match);
+			} catch {}
+			if (entries.length === 0) throw new Error(`discover: no files matched pattern "${pattern}"`);
+			const models = [];
+			const seen = /* @__PURE__ */ new Set();
+			for (const fp of entries) {
+				const mod = await import(pathToFileURL(fp).href);
+				for (const val of Object.values(mod)) if (val && typeof val === "object" && "columns" in val && "table" in val && typeof val.table === "string" && val.table.length > 0) {
+					const def = val;
+					if (!seen.has(def.table)) {
+						seen.add(def.table);
+						models.push(def);
+					}
+				}
+			}
+			return models;
 		}
 	};
 	if (config.models) for (const [_name, model] of Object.entries(config.models)) orm.register(model);
@@ -1968,12 +2379,6 @@ function createPaginator(items, total, perPage, currentPage) {
 		get onLastPage() {
 			return currentPage >= lastPage;
 		},
-		get count() {
-			return items.length;
-		},
-		map(fn) {
-			return items.map(fn);
-		},
 		toJSON() {
 			return {
 				data: collection.toJSON(),
@@ -1993,11 +2398,6 @@ function createPaginator(items, total, perPage, currentPage) {
 }
 //#endregion
 //#region src/plugins/soft-deletes.ts
-let _hooksMod = null;
-async function getHooksMod() {
-	if (!_hooksMod) _hooksMod = await import("./hooks-BD0xy7uw.mjs").then((n) => n.i);
-	return _hooksMod;
-}
 /**
 * Plugin that enables soft-delete behavior on a model.
 * Sets `deletedAt` on delete, automatically filters out deleted records.
@@ -2011,24 +2411,20 @@ async function getHooksMod() {
 function softDeletes(opts) {
 	const column = opts?.column ?? "deletedAt";
 	return (def) => {
-		getHooksMod().then((mod) => mod.registerSoftDeletesFor(def, column));
+		registerSoftDeletesFor(def, column);
 		def.on("beforeDelete", async (model) => {
 			const pk = getPrimaryKeyColumn(def);
 			const pkValue = model.get(pk);
 			if (pkValue == null) return;
-			const db = def._orm?.kysely;
-			if (!db) return;
+			const db = getDb(def);
 			try {
 				await db.updateTable(def.table).set({ [column]: (/* @__PURE__ */ new Date()).toISOString() }).where(pk, "=", pkValue).execute();
-			} catch {}
+			} catch (e) {
+				if (!isUniqueConstraintError(e)) throw normalizeError(e, def.table);
+			}
 		});
 	};
 }
-function getPrimaryKeyColumn(def) {
-	const cols = def.columns;
-	for (const [name, col] of Object.entries(cols)) if (col.isPrimaryKey) return name;
-	return "id";
-}
 //#endregion
 //#region src/plugins/timestamps.ts
 /**
@@ -2076,34 +2472,14 @@ function ulid() {
 }
 //#endregion
 //#region src/relations/has-many.ts
-const THUNK_CACHE$2 = /* @__PURE__ */ new WeakMap();
-function resolveThunk$2(thunk) {
-	let cls = THUNK_CACHE$2.get(thunk);
-	if (!cls) {
-		cls = thunk();
-		THUNK_CACHE$2.set(thunk, cls);
-	}
-	return cls;
-}
 function guessForeignKey(modelDef) {
 	const table = modelDef.table;
 	return `${table.endsWith("s") ? table.slice(0, -1) : table}Id`;
 }
-function groupByArray$1(items, key) {
-	const result = {};
-	for (const item of items) {
-		const v = item.get(key);
-		if (v == null) continue;
-		const k = String(v);
-		if (!result[k]) result[k] = [];
-		result[k].push(item);
-	}
-	return result;
-}
 function hasMany(relatedThunk, options = {}) {
 	let _related;
 	function getRelated() {
-		if (!_related) _related = resolveThunk$2(relatedThunk) ?? void 0;
+		if (!_related) _related = resolveThunk(relatedThunk) ?? void 0;
 		if (!_related) throw new Error(`Cannot resolve hasMany relation — related model not found`);
 		return _related;
 	}
@@ -2134,7 +2510,7 @@ function hasMany(relatedThunk, options = {}) {
 			else qb.where(foreignKey, "=", -1);
 		},
 		match(models, results, relationName) {
-			const grouped = groupByArray$1(results, foreignKey);
+			const grouped = groupByArray(results, foreignKey);
 			for (const model of models) {
 				const key = String(model.get(localKey));
 				model.$setRelation(relationName, grouped[key] ?? []);
@@ -2162,7 +2538,7 @@ function hasOne(relatedThunk, options = {}) {
 		Object.defineProperty(result, key, desc);
 	}
 	result.match = function match(models, results, relationName) {
-		const grouped = groupByArray$1(results, base.foreignKey);
+		const grouped = groupByArray(results, base.foreignKey);
 		for (const model of models) {
 			const key = String(model.get(base.localKey));
 			model.$setRelation(relationName, (grouped[key] ?? [])[0] ?? null);
@@ -2174,7 +2550,7 @@ function hasOne(relatedThunk, options = {}) {
 	return result;
 }
 function belongsTo(relatedThunk, options = {}) {
-	const related = resolveThunk$2(relatedThunk);
+	const related = resolveThunk(relatedThunk);
 	const foreignKey = options.foreignKey ?? guessForeignKey(related);
 	const localKey = options.localKey ?? "id";
 	return {
@@ -2221,24 +2597,15 @@ function belongsTo(relatedThunk, options = {}) {
 }
 //#endregion
 //#region src/relations/many-to-many.ts
-const THUNK_CACHE$1 = /* @__PURE__ */ new WeakMap();
 /** Stores pivot data for many-to-many relation results (instead of attaching to the model). */
 const pivotData = /* @__PURE__ */ new WeakMap();
-function resolveThunk$1(thunk) {
-	let cls = THUNK_CACHE$1.get(thunk);
-	if (!cls) {
-		cls = thunk();
-		THUNK_CACHE$1.set(thunk, cls);
-	}
-	return cls;
-}
 function snakeCase(str) {
 	return str.replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`).replace(/^_/, "");
 }
 function manyToMany(relatedThunk, options) {
 	let _related;
 	function getRelated() {
-		if (!_related) _related = resolveThunk$1(relatedThunk) ?? void 0;
+		if (!_related) _related = resolveThunk(relatedThunk) ?? void 0;
 		if (!_related) throw new Error(`Cannot resolve manyToMany relation — related model not found`);
 		return _related;
 	}
@@ -2324,11 +2691,11 @@ function manyToMany(relatedThunk, options) {
 	};
 }
 function hasManyThrough(relatedThunk, throughThunk, options = {}) {
-	const related = resolveThunk$1(relatedThunk);
-	const through = resolveThunk$1(throughThunk);
+	const related = resolveThunk(relatedThunk);
+	const through = resolveThunk(throughThunk);
 	const foreignKey = options.foreignKey ?? `${snakeCase(through.table)}Id`;
 	const localKey = options.localKey ?? "id";
-	const throughForeignKey = options.throughForeignKey ?? `${snakeCase(resolveThunk$1(relatedThunk).table)}Id`;
+	const throughForeignKey = options.throughForeignKey ?? `${snakeCase(resolveThunk(relatedThunk).table)}Id`;
 	const throughLocalKey = options.throughLocalKey ?? "id";
 	return {
 		type: "hasManyThrough",
@@ -2387,26 +2754,6 @@ function hasManyThrough(relatedThunk, throughThunk, options = {}) {
 }
 //#endregion
 //#region src/relations/morph.ts
-function groupByArray(items, key) {
-	const result = {};
-	for (const item of items) {
-		const v = item.get(key);
-		if (v == null) continue;
-		const k = String(v);
-		if (!result[k]) result[k] = [];
-		result[k].push(item);
-	}
-	return result;
-}
-const THUNK_CACHE = /* @__PURE__ */ new WeakMap();
-function resolveThunk(thunk) {
-	let cls = THUNK_CACHE.get(thunk);
-	if (!cls) {
-		cls = thunk();
-		THUNK_CACHE.set(thunk, cls);
-	}
-	return cls;
-}
 /**
 * Resolve the related model for a MorphTo relation given a parent instance.
 * Looks up the parent's `{name}Type` column value in the relation's morphMap
@@ -2474,12 +2821,12 @@ function defineMorphTo(options) {
 		*/
 		query(parent) {
 			const typeValue = parent.get(morphType);
-			if (!typeValue) throw new Error(`Cannot resolve morphTo "${options.name}": "${morphType}" is null on ${defName(parent)}`);
+			if (!typeValue) throw new Error(`Cannot resolve morphTo "${options.name}": "${morphType}" is null on ${parent.constructor?.name ?? "model"}`);
 			const thunk = morphMap[typeValue];
 			if (!thunk) throw new Error(`No model registered for morph type "${typeValue}" in morphTo "${options.name}". Available types: ${Object.keys(morphMap).join(", ") || "(none)"}`);
 			const relatedDef = resolveThunk(thunk);
 			const id = parent.get(morphId);
-			if (id == null) throw new Error(`Cannot resolve morphTo "${options.name}": "${morphId}" is null on ${defName(parent)}`);
+			if (id == null) throw new Error(`Cannot resolve morphTo "${options.name}": "${morphId}" is null on ${parent.constructor?.name ?? "model"}`);
 			return relatedDef.query().where("id", "=", id);
 		},
 		addEagerConstraints(_query, _models) {},
@@ -2577,28 +2924,66 @@ function defineMorphMany(options) {
 		}
 	};
 }
+//#endregion
+//#region src/repo/index.ts
 /**
-* Define a polymorphic hasOne relationship.
+* Create a repository — a composable set of chainable query methods.
+*
+* ```ts
+* const userRepo = createRepo(User, {
+*   queryMethods: {
+*     search(q, query: string) {
+*       return q.where('name', 'like', `%${query}%`)
+*     },
+*   },
+* })
+* const users = await userRepo.search('john').paginate(1, 20)
+* ```
 */
-function defineMorphOne(options) {
-	const base = defineMorphMany(options);
-	return {
-		...base,
-		type: "hasOne",
-		async getResults(parent) {
-			return (await base.getResults(parent))[0] ?? null;
-		},
-		match(models, results, relationName) {
-			const grouped = groupByArray(results, base.foreignKey);
-			for (const model of models) {
-				const related = grouped[String(model.get("id"))] ?? [];
-				model.$setRelation(relationName, related[0] ?? null);
+function createRepo(model, methods) {
+	const customMethods = /* @__PURE__ */ new Map();
+	if (methods.queryMethods) for (const [name, fn] of Object.entries(methods.queryMethods)) customMethods.set(name, fn);
+	/**
+	* Wrap a QueryBuilder so custom methods are available for chaining.
+	* Custom methods operate on the CURRENT QB (not a fresh one), so
+	* chaining carries forward previous conditions.
+	*/
+	function wrapQB(qb) {
+		return new Proxy(qb, { get(target, prop) {
+			if (typeof prop === "string") {
+				if (customMethods.has(prop)) {
+					const fn = customMethods.get(prop);
+					return (...args) => {
+						return wrapQB(fn(target, ...args));
+					};
+				}
+				if (methods.methods?.[prop]) return (...args) => methods.methods[prop](...args);
 			}
+			const val = target[prop];
+			if (typeof val === "function") return function(...args) {
+				const result = val.apply(target, args);
+				return result === target ? wrapQB(result) : result;
+			};
+			return val;
+		} });
+	}
+	return new Proxy({}, { get(_target, prop) {
+		if (typeof prop === "string") {
+			if (customMethods.has(prop)) {
+				const fn = customMethods.get(prop);
+				return (...args) => {
+					return wrapQB(fn(model.query(), ...args));
+				};
+			}
+			if (methods.methods?.[prop]) return (...args) => methods.methods[prop](...args);
 		}
-	};
-}
-function defName(instance) {
-	return instance.constructor?.name ?? "model";
+		const qb = model.query();
+		const val = qb[prop];
+		if (typeof val === "function") return (...args) => {
+			return wrapQB(val.apply(qb, args));
+		};
+		return val;
+	} });
 }
 //#endregion
-export { Attribute, DatabaseError, ModelNotFoundError, ModelNotRegisteredError, RelationNotAllowedError, RelationNotFoundError, ValidationError, belongsTo, createArkTypeSchemaConfig, createCollection, createColumn, createHookManager, createORM, createORM as createPeta, createPaginator, createQueryBuilder, defineModel, defineMorphMany, defineMorphOne, defineMorphTo, hasMany, hasManyThrough, hasOne, eager_exports as i, manyToMany, relation_exports as n, normalizeError, delete_exports as r, resolveMorphRelation, softDeletes, t, timestamps, ulid };
+export { Attribute, DatabaseError, ModelNotFoundError, ModelNotRegisteredError, RelationNotAllowedError, RelationNotFoundError, ValidationError, belongsTo, createArkTypeSchemaConfig, createCollection, createColumn, createColumnTypes, createDb, createHookManager, createORM, createORM as createPeta, createPaginator, createQueryBuilder, createRepo, defineModel, defineMorphMany, defineMorphTo, deleteGraph, hasMany, hasManyThrough, hasOne, manyToMany, eager_exports as n, normalizeError, petaMiddleware, petaPlugin, resolveMorphRelation, softDeletes, t, timestamps, ulid };