peta-orm 0.2.6 → 0.4.0

package/dist/migrations/cli.d.mts

@@ -0,0 +1,4 @@
+//#region src/migrations/cli.d.ts
+declare function run(): Promise<void>;
+//#endregion
+export { run };

package/dist/migrations/cli.mjs

@@ -0,0 +1,74 @@
+import { a as loadMigrationFiles, i as loadConfig, n as createMigrationGenerator, t as createMigrationRunner } from "../runner-DQ7uT6LC.mjs";
+import { resolve } from "node:path";
+import { mkdirSync, writeFileSync } from "node:fs";
+import cac from "cac";
+import ora from "ora";
+//#region src/migrations/cli.ts
+async function run() {
+	const cli = cac("peta");
+	cli.command("migrate:init", "Create migrations directory and tracking table").action(async () => {
+		const config = await loadConfig();
+		const spinner = ora("Setting up migrations...").start();
+		mkdirSync(config.migrationsDir, { recursive: true });
+		await createMigrationRunner(config.getKysely()).ensureTable();
+		spinner.succeed(`Migrations directory created at ${config.migrationsDir}`);
+	});
+	cli.command("migrate:generate [name]", "Generate initial migration from models").action(async (name) => {
+		const config = await loadConfig();
+		const spinner = ora("Generating migration...").start();
+		const code = createMigrationGenerator().generateInitialMigration(/* @__PURE__ */ new Map(), { name: name ?? "Initial" });
+		const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
+		const safeName = (name ?? "initial").replace(/[^a-zA-Z0-9_]/g, "_");
+		const filename = resolve(config.migrationsDir, `${timestamp}_${safeName}.ts`);
+		mkdirSync(config.migrationsDir, { recursive: true });
+		writeFileSync(filename, code);
+		spinner.succeed(`Created ${filename}`);
+	});
+	cli.command("migrate:up", "Apply pending migrations").action(async () => {
+		const config = await loadConfig();
+		const migrations = await loadMigrationFiles(config.migrationsDir);
+		if (migrations.length === 0) {
+			console.log("No migration files found.");
+			return;
+		}
+		const runner = createMigrationRunner(config.getKysely());
+		const status = await runner.status(migrations);
+		if (status.pending.length === 0) {
+			console.log("All migrations have been applied.");
+			return;
+		}
+		const spinner = ora(`Running ${status.pending.length} migration(s)...`).start();
+		await runner.up(migrations);
+		spinner.succeed(`Applied ${(await runner.getCompleted()).length} migration(s)`);
+	});
+	cli.command("migrate:down", "Rollback last batch").action(async () => {
+		const config = await loadConfig();
+		const migrations = await loadMigrationFiles(config.migrationsDir);
+		if (migrations.length === 0) {
+			console.log("No migration files found.");
+			return;
+		}
+		const runner = createMigrationRunner(config.getKysely());
+		if ((await runner.getCompleted()).length === 0) {
+			console.log("Nothing to rollback.");
+			return;
+		}
+		const spinner = ora("Rolling back...").start();
+		await runner.down(migrations);
+		spinner.succeed("Rolled back");
+	});
+	cli.command("migrate:status", "Show migration status").action(async () => {
+		const config = await loadConfig();
+		const migrations = await loadMigrationFiles(config.migrationsDir);
+		const { completed, pending } = await createMigrationRunner(config.getKysely()).status(migrations);
+		console.log(`\n  Completed: ${completed.length}`);
+		for (const m of completed) console.log(`    ✓ ${m.name}`);
+		console.log(`\n  Pending: ${pending.length}`);
+		for (const m of pending) console.log(`    · ${m.name}`);
+		console.log();
+	});
+	cli.help();
+	cli.parse();
+}
+//#endregion
+export { run };

package/dist/migrations/index.d.mts

@@ -0,0 +1,53 @@
+import { a as ModelDefinition } from "../index-BdJnSMYi.mjs";
+import { Kysely } from "kysely";
+
+//#region src/migrations/types.d.ts
+interface MigrationFile {
+  name: string;
+  up: (db: Kysely<unknown>) => Promise<void>;
+  down: (db: Kysely<unknown>) => Promise<void>;
+}
+interface MigrationRecord {
+  name: string;
+  appliedAt: string;
+}
+interface MigrationStatus {
+  completed: MigrationRecord[];
+  pending: MigrationFile[];
+}
+interface PetaMigrateConfig {
+  migrationsDir: string;
+  models: string[] | string;
+  getKysely: () => Kysely<unknown>;
+}
+interface ResolvedConfig {
+  migrationsDir: string;
+  models: string[] | string;
+  getKysely: () => Kysely<unknown>;
+}
+//#endregion
+//#region src/migrations/config.d.ts
+declare function defineConfig(config: PetaMigrateConfig): PetaMigrateConfig;
+declare function loadConfig(): Promise<ResolvedConfig>;
+declare function loadMigrationFiles(dir: string): Promise<MigrationFile[]>;
+//#endregion
+//#region src/migrations/generator.d.ts
+interface GeneratorOptions {
+  name?: string;
+}
+interface MigrationGenerator {
+  generateInitialMigration(models: Map<string, ModelDefinition>, options?: GeneratorOptions): string;
+}
+declare function createMigrationGenerator(): MigrationGenerator;
+//#endregion
+//#region src/migrations/runner.d.ts
+interface MigrationRunner {
+  ensureTable(): Promise<void>;
+  getCompleted(): Promise<MigrationRecord[]>;
+  up(migrations: MigrationFile[]): Promise<void>;
+  down(migrations: MigrationFile[]): Promise<void>;
+  status(migrations: MigrationFile[]): Promise<MigrationStatus>;
+}
+declare function createMigrationRunner(db: Kysely<Record<string, never>>, table?: string): MigrationRunner;
+//#endregion
+export { type GeneratorOptions, type MigrationFile, type MigrationGenerator, type MigrationRecord, type MigrationRunner, type MigrationStatus, type PetaMigrateConfig, type ResolvedConfig, createMigrationGenerator, createMigrationRunner, defineConfig, loadConfig, loadMigrationFiles };

package/dist/migrations/index.mjs

@@ -0,0 +1,2 @@
+import { a as loadMigrationFiles, i as loadConfig, n as createMigrationGenerator, r as defineConfig, t as createMigrationRunner } from "../runner-DQ7uT6LC.mjs";
+export { createMigrationGenerator, createMigrationRunner, defineConfig, loadConfig, loadMigrationFiles };

package/dist/rolldown-runtime-D7D4PA-g.mjs

@@ -0,0 +1,13 @@
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (!no_symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+//#endregion
+export { __exportAll as t };

package/dist/runner-DQ7uT6LC.mjs

@@ -0,0 +1,180 @@
+import { sql } from "kysely";
+import { resolve } from "node:path";
+//#region src/migrations/config.ts
+function defineConfig(config) {
+	return config;
+}
+async function loadConfig() {
+	const candidates = [
+		"peta.config.ts",
+		"peta.config.js",
+		"peta.config.mjs"
+	];
+	let mod = null;
+	for (const file of candidates) try {
+		mod = await import(resolve(process.cwd(), file));
+		break;
+	} catch {}
+	if (!mod) throw new Error("No peta.config.ts found. Create one in your project root.");
+	const config = mod.default ?? mod;
+	return {
+		migrationsDir: config.migrationsDir,
+		models: config.models,
+		getKysely: config.getKysely
+	};
+}
+async function loadMigrationFiles(dir) {
+	const { readdirSync } = await import("node:fs");
+	const files = readdirSync(dir).filter((f) => f.endsWith(".ts") || f.endsWith(".js")).sort();
+	const migrations = [];
+	for (const file of files) {
+		const mod = await import(resolve(dir, file));
+		if (mod.up) migrations.push({
+			name: file.replace(/\.(ts|js)$/, ""),
+			up: mod.up,
+			down: mod.down ?? (async () => {})
+		});
+	}
+	return migrations;
+}
+//#endregion
+//#region src/migrations/generator.ts
+function createMigrationGenerator() {
+	function generateInitialMigration(models, options = {}) {
+		options.name;
+		const parts = [];
+		const indexParts = [];
+		const warnings = [];
+		const registeredTables = new Set([...models.values()].map((m) => m.table).filter(Boolean));
+		for (const [, modelDef] of models) {
+			const table = modelDef.table;
+			if (!table) continue;
+			parts.push(generateCreateTable(table, modelDef.columns));
+			for (const [colName, col] of Object.entries(modelDef.columns)) if (col.hasConstraint("index") && !col.isPrimaryKey && !col.isUnique) indexParts.push(generateCreateIndex(table, colName));
+			for (const [, rel] of Object.entries(modelDef.relations ?? {})) if (rel.type === "manyToMany") {
+				const through = rel.throughTable;
+				if (through && !registeredTables.has(through)) warnings.push(`// ⚠ Detected ManyToMany "${modelDef.name}" references table "${through}" but no model is registered for it.\n//   Add a model to include the pivot table.`);
+			}
+		}
+		const upBody = [...parts, ...indexParts].join("\n\n");
+		const downTables = [...models.values()].filter((m) => m.table).map((m) => `  await db.schema.dropTable("${m.table}").ifExists().execute()`).join("\n");
+		return `import type { Kysely } from "kysely"\nimport { sql } from "kysely"\n\nexport async function up(db: Kysely<any>): Promise<void> {\n${warnings.length > 0 ? `  // Warnings:\n${warnings.join("\n")}\n\n` : ""}${upBody}\n}\n\nexport async function down(db: Kysely<any>): Promise<void> {\n${downTables}\n}\n`;
+	}
+	return { generateInitialMigration };
+}
+function generateCreateTable(table, columns) {
+	const lines = [`  await db.schema.createTable("${table}").ifNotExists()`];
+	for (const [name, col] of Object.entries(columns)) lines.push(`    .addColumn("${name}", "${mapType(col)}"${columnCallback(col)})`);
+	lines.push("    .execute()");
+	return lines.join("\n");
+}
+function generateCreateIndex(table, column) {
+	return [
+		`  await db.schema.createIndex("${table}_${column}_index")`,
+		`    .on("${table}")`,
+		`    .column("${column}")`,
+		"    .execute()"
+	].join("\n");
+}
+function columnCallback(col) {
+	const calls = [];
+	if (col.isPrimaryKey) {
+		if (col.dataType === "integer") calls.push("autoIncrement()");
+		calls.push("primaryKey()");
+	}
+	if (!col.isNullable && !col.isPrimaryKey) calls.push("notNull()");
+	const dv = col.defaultValue;
+	if (dv !== void 0 && typeof dv !== "function") calls.push(`defaultTo(${JSON.stringify(dv)})`);
+	if (col.isUnique && !col.isPrimaryKey) calls.push("unique()");
+	const refConstraint = col.constraints.find((c) => c.type === "references");
+	if (refConstraint?.args[0]) {
+		const targetTable = (typeof refConstraint.args[0] === "function" ? refConstraint.args[0]() : refConstraint.args[0])?.table;
+		const targetColumns = refConstraint.args[1];
+		if (typeof targetTable === "string" && targetTable && targetColumns?.length) calls.push(`references("${targetTable}.${targetColumns[0]}")`);
+	}
+	return calls.length === 0 ? "" : `, (c) => c.${calls.join(".")}`;
+}
+function mapType(col) {
+	switch (col.dataType) {
+		case "integer":
+		case "smallint":
+		case "bigint":
+		case "text":
+		case "boolean":
+		case "timestamp":
+		case "date":
+		case "float":
+		case "double":
+		case "uuid": return col.dataType;
+		case "string": {
+			const max = col.args[0];
+			return max != null ? `varchar(${max})` : "varchar";
+		}
+		case "json":
+		case "jsonb": return "json";
+		case "decimal": {
+			const p = col.args[0];
+			const s = col.args[1];
+			return p != null ? `decimal(${p}, ${s ?? 0})` : "decimal";
+		}
+		case "enum": return "text";
+		default: return col.dataType;
+	}
+}
+//#endregion
+//#region src/migrations/runner.ts
+function createMigrationRunner(db, table = "_peta_migrations") {
+	async function ensureTable() {
+		await db.schema.createTable(table).ifNotExists().addColumn("name", "varchar", (c) => c.notNull().primaryKey()).addColumn("applied_at", "timestamp", (c) => c.notNull().defaultTo(sql`CURRENT_TIMESTAMP`)).execute();
+	}
+	async function getCompleted() {
+		try {
+			return (await db.selectFrom(table).select(["name", "applied_at"]).orderBy("name", "asc").execute()).map((r) => ({
+				name: String(r.name),
+				appliedAt: String(r.applied_at)
+			}));
+		} catch {
+			return [];
+		}
+	}
+	async function up(migrations) {
+		await ensureTable();
+		const completed = await getCompleted();
+		const completedNames = new Set(completed.map((r) => r.name));
+		for (const m of migrations.filter((m) => !completedNames.has(m.name)).sort(byName)) {
+			await m.up(db);
+			await db.insertInto(table).values({
+				name: m.name,
+				applied_at: (/* @__PURE__ */ new Date()).toISOString()
+			}).execute();
+		}
+	}
+	async function down(migrations) {
+		const completed = await getCompleted();
+		if (completed.length === 0 || migrations.length === 0) return;
+		for (const m of migrations.filter((m) => completed.some((r) => r.name === m.name)).sort(byName).reverse()) {
+			await m.down(db);
+			await db.deleteFrom(table).where("name", "=", m.name).execute();
+		}
+	}
+	async function status(migrations) {
+		const completed = await getCompleted();
+		const completedNames = new Set(completed.map((r) => r.name));
+		return {
+			completed,
+			pending: migrations.filter((m) => !completedNames.has(m.name)).sort(byName)
+		};
+	}
+	return {
+		ensureTable,
+		getCompleted,
+		up,
+		down,
+		status
+	};
+}
+function byName(a, b) {
+	return a.name.localeCompare(b.name);
+}
+//#endregion
+export { loadMigrationFiles as a, loadConfig as i, createMigrationGenerator as n, defineConfig as r, createMigrationRunner as t };

package/dist/save-D5UKXvqC.mjs

@@ -0,0 +1,331 @@
+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 };