peta-orm 0.2.6 → 0.4.0

package/dist/collection-PFmrQHyM.mjs

@@ -0,0 +1,173 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+//#region src/collection/index.ts
+var collection_exports = /* @__PURE__ */ __exportAll({ createCollection: () => createCollection });
+function createCollection(items) {
+	const data = [...items ?? []];
+	const collection = {
+		get length() {
+			return data.length;
+		},
+		[Symbol.iterator]() {
+			return data[Symbol.iterator]();
+		},
+		at(index) {
+			return data[index];
+		},
+		first() {
+			return data[0];
+		},
+		last() {
+			return data[data.length - 1];
+		},
+		all() {
+			return [...data];
+		},
+		findBy(id) {
+			return data.find((d) => d.get("id") === id);
+		},
+		find(callback) {
+			return data.find(callback);
+		},
+		some(callback) {
+			return data.some(callback);
+		},
+		includes(item) {
+			return data.includes(item);
+		},
+		isEmpty() {
+			return data.length === 0;
+		},
+		isNotEmpty() {
+			return data.length > 0;
+		},
+		get(key) {
+			return data.map((d) => d.get(key));
+		},
+		pluck(key) {
+			return data.map((d) => d.get(key));
+		},
+		groupBy(key) {
+			const result = {};
+			for (const item of data) {
+				const v = String(item.get(key));
+				if (!result[v]) result[v] = [];
+				result[v].push(item);
+			}
+			return result;
+		},
+		keyBy(key) {
+			const result = {};
+			for (const item of data) result[String(item.get(key))] = item;
+			return result;
+		},
+		map(fn) {
+			return data.map(fn);
+		},
+		filter(fn) {
+			return createCollection(data.filter(fn));
+		},
+		reduce(fn, initial) {
+			return data.reduce(fn, initial);
+		},
+		forEach(fn) {
+			data.forEach(fn);
+		},
+		each(fn) {
+			data.forEach(fn);
+			return collection;
+		},
+		unique(key) {
+			if (!key) {
+				const seen = /* @__PURE__ */ new Set();
+				return createCollection(data.filter((d) => {
+					const id = d.get("id");
+					if (seen.has(id)) return false;
+					seen.add(id);
+					return true;
+				}));
+			}
+			const seen = /* @__PURE__ */ new Set();
+			return createCollection(data.filter((d) => {
+				const v = d.get(key);
+				if (seen.has(v)) return false;
+				seen.add(v);
+				return true;
+			}));
+		},
+		sortBy(key, direction = "asc") {
+			return createCollection([...data].sort((a, b) => {
+				const va = a.get(key);
+				const vb = b.get(key);
+				if (va < vb) return direction === "asc" ? -1 : 1;
+				if (va > vb) return direction === "asc" ? 1 : -1;
+				return 0;
+			}));
+		},
+		shuffle() {
+			const shuffled = [...data];
+			for (let i = shuffled.length - 1; i > 0; i--) {
+				const j = Math.floor(Math.random() * (i + 1));
+				const temp = shuffled[i];
+				shuffled[i] = shuffled[j];
+				shuffled[j] = temp;
+			}
+			return createCollection(shuffled);
+		},
+		take(n) {
+			return createCollection(data.slice(0, n));
+		},
+		skip(n) {
+			return createCollection(data.slice(n));
+		},
+		chunk(size) {
+			const chunks = [];
+			for (let i = 0; i < data.length; i += size) chunks.push(createCollection(data.slice(i, i + size)));
+			return chunks;
+		},
+		sum(key) {
+			return data.reduce((acc, d) => acc + (Number(d.get(key)) || 0), 0);
+		},
+		avg(key) {
+			return data.length === 0 ? 0 : this.sum(key) / data.length;
+		},
+		min(key) {
+			return Math.min(...data.map((d) => Number(d.get(key)) || 0));
+		},
+		max(key) {
+			return Math.max(...data.map((d) => Number(d.get(key)) || 0));
+		},
+		diff(other) {
+			const otherIds = new Set(other.pluck("id"));
+			return createCollection(data.filter((d) => !otherIds.has(d.get("id"))));
+		},
+		intersect(other) {
+			const otherIds = new Set(other.pluck("id"));
+			return createCollection(data.filter((d) => otherIds.has(d.get("id"))));
+		},
+		concat(other) {
+			return createCollection([...data, ...other.all()]);
+		},
+		push(...items) {
+			data.push(...items);
+		},
+		async load(...relations) {
+			if (data.length === 0) return collection;
+			const { EagerLoader } = await import("./index.mjs").then((n) => n.i);
+			const { getModelDefFromInstance } = await import("./factory-BBvIMQuc.mjs").then((n) => n.n);
+			const { getModelDef } = await import("./index.mjs").then((n) => n.n);
+			const first = data[0];
+			const def = getModelDefFromInstance(first) ?? getModelDef(first);
+			if (def) {
+				const loader = new EagerLoader();
+				for (const rel of relations) await loader.loadRelated(data, { name: rel }, def);
+			}
+			return collection;
+		},
+		toJSON() {
+			return data.map((d) => d.toJSON());
+		}
+	};
+	return collection;
+}
+//#endregion
+export { createCollection as n, collection_exports as t };

package/dist/crud-BCWvg5MI.mjs

@@ -0,0 +1,101 @@
+import { r as DatabaseError, s as RelationNotFoundError } from "./errors-sfFJolfu.mjs";
+//#region src/relations/crud.ts
+function extractRelationData(def, data) {
+	const columnData = {};
+	const relationOps = {};
+	for (const [key, value] of Object.entries(data)) if (def.relations[key] && typeof value === "object" && value !== null && !Array.isArray(value)) relationOps[key] = value;
+	else if (def.relations[key] && Array.isArray(value)) relationOps[key] = { connect: value };
+	else if (def.relations[key] && typeof value === "object" && value !== null && "create" in value) relationOps[key] = value;
+	else columnData[key] = value;
+	return {
+		columnData,
+		relationOps
+	};
+}
+function getDb(def) {
+	if (!def._orm) throw new Error("Model not registered");
+	return def._orm.kysely;
+}
+/**
+* Process relation operations after the parent model has been created.
+* For belongsTo, the related model must be created FIRST, then its ID
+* is set on the parent. For hasMany/hasOne/manyToMany, the parent
+* is created first, then children are created with the parent's FK.
+*
+* This function handles the post-creation phase.
+*/
+async function processCreateRelations(def, instance, relationOps) {
+	for (const [relName, op] of Object.entries(relationOps)) {
+		const relation = def.relations[relName];
+		if (!relation) throw new RelationNotFoundError(def.name, relName);
+		relation.relatedModelClass;
+		const pkValue = instance.get(relation.localKey);
+		if (pkValue == null) throw new DatabaseError("Cannot create relations without primary key", "MISSING_ID");
+		if (relation.type === "belongsTo") await processBelongsToCreate(instance, relation, op, pkValue);
+		else if (relation.type === "hasOne") await processHasManyCreate(instance, relation, op, pkValue);
+		else if (relation.type === "hasMany") await processHasManyCreate(instance, relation, op, pkValue);
+		else if (relation.type === "manyToMany") await processManyToManyCreate(instance, relation, op, pkValue);
+	}
+}
+async function processBelongsToCreate(instance, relation, op, _pkValue) {
+	const relatedDef = relation.relatedModelClass;
+	let relatedId = instance.get(relation.foreignKey);
+	if (op.create) relatedId = (await relatedDef.insert(op.create)).get(relation.localKey);
+	else if (op.connect) {
+		const related = await findRelated(relatedDef, op.connect);
+		if (related) relatedId = related.get(relation.localKey);
+	} else if (op.connectOrCreate) {
+		const existing = await findRelated(relatedDef, op.connectOrCreate.where);
+		if (existing) relatedId = existing.get(relation.localKey);
+		else relatedId = (await relatedDef.insert(op.connectOrCreate.create)).get(relation.localKey);
+	}
+	if (relatedId !== void 0) await getDb(relatedDef).updateTable(relatedDef.table).set({ [relation.foreignKey]: relatedId }).where(relation.localKey, "=", _pkValue).execute();
+}
+async function processHasManyCreate(_instance, relation, op, pkValue) {
+	const relatedDef = relation.relatedModelClass;
+	const fk = relation.foreignKey;
+	if (op.create) for (const data of op.create) await relatedDef.insert({
+		...data,
+		[fk]: pkValue
+	});
+}
+async function processManyToManyCreate(_instance, relation, op, pkValue) {
+	const relatedDef = relation.relatedModelClass;
+	const { throughTable, foreignPivotKey, relatedPivotKey } = getPivotInfo(relation);
+	const db = getDb(relatedDef);
+	if (op.create) for (const data of op.create) {
+		const relatedId = (await relatedDef.insert(data)).get(relation.localKey ?? "id");
+		await db.insertInto(throughTable).values({
+			[foreignPivotKey]: pkValue,
+			[relatedPivotKey]: relatedId
+		}).execute();
+	}
+	if (op.connect) for (const target of op.connect) {
+		const relatedId = await resolveTargetId(relatedDef, target);
+		if (relatedId != null) try {
+			await db.insertInto(throughTable).values({
+				[foreignPivotKey]: pkValue,
+				[relatedPivotKey]: relatedId
+			}).execute();
+		} catch {}
+	}
+}
+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");
+}
+//#endregion
+export { extractRelationData, processCreateRelations };

package/dist/errors-sfFJolfu.mjs

@@ -0,0 +1,69 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+//#region src/errors/classes.ts
+var ValidationError = class extends Error {
+	name = "ValidationError";
+};
+var ModelNotFoundError = class extends Error {
+	name = "ModelNotFoundError";
+	constructor(model, id) {
+		super(`${model} with id ${id} not found`);
+	}
+};
+var RelationNotFoundError = class extends Error {
+	name = "RelationNotFoundError";
+	constructor(model, relation) {
+		super(`Relation "${relation}" not found on ${model}`);
+	}
+};
+var RelationNotAllowedError = class extends Error {
+	name = "RelationNotAllowedError";
+	constructor(model, relation) {
+		super(`Relation "${relation}" is not in the allowGraph whitelist for ${model}`);
+	}
+};
+var ModelNotRegisteredError = class extends Error {
+	name = "ModelNotRegisteredError";
+	constructor(model) {
+		super(`Model "${model}" is not registered. Call orm.register() or pass it to createORM()`);
+	}
+};
+var DatabaseError = class extends Error {
+	name = "DatabaseError";
+	code;
+	table;
+	detail;
+	constructor(message, code, table, detail) {
+		super(message);
+		this.code = code;
+		this.table = table;
+		this.detail = detail;
+	}
+};
+//#endregion
+//#region src/errors/normalizer.ts
+function normalizeError(e, table) {
+	const raw = e;
+	const msg = raw.message ?? "";
+	if (raw.code === "SQLITE_CONSTRAINT_UNIQUE" || raw.code === "SQLITE_CONSTRAINT") return new DatabaseError(`Unique constraint violation on ${table}: ${msg}`, "UNIQUE_CONSTRAINT", table, msg);
+	if (raw.code === "SQLITE_CONSTRAINT_FOREIGNKEY" || raw.code === "SQLITE_CONSTRAINT_FOREIGN_KEY") return new DatabaseError(`Foreign key constraint violation on ${table}: ${msg}`, "FOREIGN_KEY_CONSTRAINT", table, msg);
+	if (raw.code === "SQLITE_CONSTRAINT_NOTNULL" || raw.code === "SQLITE_CONSTRAINT_NOT_NULL") return new DatabaseError(`Not null constraint violation on ${table}: ${msg}`, "NOT_NULL_CONSTRAINT", table, msg);
+	if (raw.code === "SQLITE_CONSTRAINT_CHECK") return new DatabaseError(`Check constraint violation on ${table}: ${msg}`, "CHECK_CONSTRAINT", table, msg);
+	if (raw.errno === 19 || raw.errno === 2067) {
+		if (msg.includes("UNIQUE")) return new DatabaseError(msg, "UNIQUE_CONSTRAINT", table, msg);
+		if (msg.includes("FOREIGN KEY")) return new DatabaseError(msg, "FOREIGN_KEY_CONSTRAINT", table, msg);
+		if (msg.includes("NOT NULL")) return new DatabaseError(msg, "NOT_NULL_CONSTRAINT", table, msg);
+		if (msg.includes("CHECK")) return new DatabaseError(msg, "CHECK_CONSTRAINT", table, msg);
+	}
+	if (raw.code === "23505") return new DatabaseError(msg, "UNIQUE_CONSTRAINT", table, msg);
+	if (raw.code === "23503") return new DatabaseError(msg, "FOREIGN_KEY_CONSTRAINT", table, msg);
+	if (raw.code === "23502") return new DatabaseError(msg, "NOT_NULL_CONSTRAINT", table, msg);
+	if (raw.code === "ER_DUP_ENTRY" || raw.errno === 1062) return new DatabaseError(`Unique constraint violation on ${table}: ${msg}`, "UNIQUE_CONSTRAINT", table, msg);
+	if (raw.code === "ER_NO_REFERENCED_ROW_2" || raw.errno === 1452) return new DatabaseError(`Foreign key constraint violation on ${table}: ${msg}`, "FOREIGN_KEY_CONSTRAINT", table, msg);
+	if (raw.code === "ER_BAD_NULL_ERROR" || raw.errno === 1048) return new DatabaseError(`Not null constraint violation on ${table}: ${msg}`, "NOT_NULL_CONSTRAINT", table, msg);
+	return new DatabaseError(msg || "Unknown database error", "UNKNOWN", table, msg);
+}
+//#endregion
+//#region src/errors.ts
+var errors_exports = /* @__PURE__ */ __exportAll({ normalizeError: () => normalizeError });
+//#endregion
+export { ModelNotRegisteredError as a, ValidationError as c, ModelNotFoundError as i, normalizeError as n, RelationNotAllowedError as o, DatabaseError as r, RelationNotFoundError as s, errors_exports as t };

package/dist/factory-BBvIMQuc.mjs

@@ -0,0 +1,173 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+import { a as getRawRelations, c as isDirty, f as syncOriginal, i as getExists, l as resetAttrs, n as getAttr, o as getState, r as getDirtyAttributes, s as initState, t as fillAttrs, u as setAttr } from "./state-LtlHp6XV.mjs";
+//#region src/model/casts.ts
+function castValue(value, type) {
+	if (value == null) return value;
+	switch (type) {
+		case "json":
+		case "object": return typeof value === "string" ? JSON.parse(value) : value;
+		case "boolean":
+		case "bool": return Boolean(value);
+		case "integer":
+		case "int": return Number(value);
+		case "float":
+		case "double": return Number(value);
+		case "date":
+		case "datetime": return typeof value === "string" ? value : value.toISOString();
+		default: return value;
+	}
+}
+function prepareForDb(value, type) {
+	if (value == null) return value;
+	switch (type) {
+		case "json":
+		case "object": return typeof value === "string" ? value : JSON.stringify(value);
+		case "boolean":
+		case "bool": return value ? 1 : 0;
+		default: return value;
+	}
+}
+function castForSet(value, type) {
+	if (value == null) return value;
+	switch (type) {
+		case "json":
+		case "object": return typeof value === "string" ? JSON.parse(value) : value;
+		case "boolean":
+		case "bool": return Boolean(value);
+		case "integer":
+		case "int": return Number(value);
+		default: return value;
+	}
+}
+function applyCastsToData(config, data, mode) {
+	if (!config.casts) return { ...data };
+	const result = { ...data };
+	for (const [key, type] of Object.entries(config.casts)) if (key in result) result[key] = mode === "get" ? castValue(result[key], type) : prepareForDb(result[key], type);
+	return result;
+}
+//#endregion
+//#region src/model/runtime.ts
+let runtime = null;
+function initRuntime(fns) {
+	runtime = fns;
+}
+function getRuntime() {
+	if (!runtime) throw new Error("Model runtime not initialized. Call initRuntime() first.");
+	return runtime;
+}
+//#endregion
+//#region src/model/types.ts
+const FORBIDDEN_KEYS = /* @__PURE__ */ new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+//#endregion
+//#region src/model/factory.ts
+var factory_exports = /* @__PURE__ */ __exportAll({
+	createInstance: () => createInstance,
+	getModelDefFromInstance: () => getModelDefFromInstance,
+	setModelDefOnInstance: () => setModelDefOnInstance
+});
+const instanceDefs = /* @__PURE__ */ new WeakMap();
+function setModelDefOnInstance(instance, def) {
+	instanceDefs.set(instance, def);
+}
+function getModelDefFromInstance(instance) {
+	return instanceDefs.get(instance);
+}
+function createInstance(def, config, data, exists) {
+	const instance = {
+		get exists() {
+			return getExists(instance);
+		},
+		get attributes() {
+			return { ...getState(instance).attributes };
+		},
+		get dirtyAttributes() {
+			return getDirtyAttributes(instance);
+		},
+		isDirty(key) {
+			return isDirty(instance, key);
+		},
+		get(key) {
+			let result = getAttr(instance, key);
+			if (config.casts?.[key]) result = castValue(result, config.casts[key]);
+			const attrDef = config.attributes?.[key];
+			if (attrDef?.get) result = attrDef.get(result, instance);
+			return result;
+		},
+		set(key, value) {
+			if (FORBIDDEN_KEYS.has(key)) return;
+			let result = value;
+			const attrDef = config.attributes?.[key];
+			if (attrDef?.set) result = attrDef.set(result, instance);
+			setAttr(instance, key, config.casts?.[key] ? castForSet(result, config.casts[key]) : result);
+		},
+		fill(data) {
+			const safe = {};
+			for (const [key, value] of Object.entries(data)) if (!FORBIDDEN_KEYS.has(key)) {
+				let v = value;
+				const attrDef = config.attributes?.[key];
+				if (attrDef?.set) v = attrDef.set(v, instance);
+				safe[key] = config.casts?.[key] ? castForSet(v, config.casts[key]) : v;
+			}
+			fillAttrs(instance, safe);
+		},
+		reset() {
+			resetAttrs(instance);
+		},
+		$getRelation(name) {
+			return getRawRelations(instance)?.[name] ?? null;
+		},
+		$setRelation(name, value) {
+			getRawRelations(instance)[name] = value;
+		},
+		$hasRelation(name) {
+			return name in (getRawRelations(instance) ?? {});
+		},
+		$relationData() {
+			return { ...getRawRelations(instance) };
+		},
+		$load: (...relations) => {
+			return getRuntime().loadModelRelations(instance, def, ...relations);
+		},
+		$related: (name) => {
+			return getRuntime().createRelationQuery(instance, def, name);
+		},
+		$save: () => {
+			return getRuntime().saveModel(def, instance);
+		},
+		$delete: () => {
+			return getRuntime().deleteModel(def, instance);
+		},
+		$forceDelete: () => {
+			return getRuntime().forceDeleteModel(def, instance);
+		},
+		$restore: () => {
+			return getRuntime().restoreModel(def, instance);
+		},
+		$trashed() {
+			return getRuntime().trashedModel(def, instance);
+		},
+		$reload: () => {
+			return getRuntime().reloadModel(def, instance);
+		},
+		$toJSON() {
+			return getRuntime().modelToJSON(def, instance);
+		},
+		toJSON() {
+			return getRuntime().modelToJSON(def, instance);
+		}
+	};
+	if (exists) initState(instance, applyCastsToData(config, data || {}, "get"), true);
+	else {
+		initState(instance, {}, false);
+		if (data && Object.keys(data).length > 0) instance.fill(data);
+		syncOriginal(instance);
+	}
+	setModelDefOnInstance(instance, def);
+	return instance;
+}
+//#endregion
+export { castValue as a, applyCastsToData as i, factory_exports as n, prepareForDb as o, initRuntime as r, createInstance as t };

package/dist/hooks-BD0xy7uw.mjs

@@ -0,0 +1,77 @@
+import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
+//#region src/hooks/index.ts
+function createHookManager() {
+	const listeners = /* @__PURE__ */ new Map();
+	function on(event, callback) {
+		let cbs = listeners.get(event);
+		if (!cbs) {
+			cbs = [];
+			listeners.set(event, cbs);
+		}
+		cbs.push(callback);
+		return () => off(event, callback);
+	}
+	function off(event, callback) {
+		const cbs = listeners.get(event);
+		if (cbs) {
+			const idx = cbs.indexOf(callback);
+			if (idx !== -1) cbs.splice(idx, 1);
+		}
+	}
+	async function trigger(event, model) {
+		const cbs = listeners.get(event);
+		if (cbs) for (const cb of cbs) await cb(model);
+	}
+	function clone() {
+		const cloned = createHookManager();
+		for (const [event, cbs] of listeners) for (const cb of cbs) cloned.on(event, cb);
+		return cloned;
+	}
+	return {
+		on,
+		off,
+		trigger,
+		clone
+	};
+}
+//#endregion
+//#region src/model/hooks.ts
+var hooks_exports = /* @__PURE__ */ __exportAll({
+	getHooksFor: () => getHooksFor,
+	getSoftDeleteConfig: () => getSoftDeleteConfig,
+	hasSoftDelete: () => hasSoftDelete,
+	registerSoftDeletesFor: () => registerSoftDeletesFor,
+	registerTimestampsFor: () => registerTimestampsFor
+});
+const hookManagers = /* @__PURE__ */ new WeakMap();
+function getHooksFor(def) {
+	let hm = hookManagers.get(def);
+	if (!hm) {
+		hm = createHookManager();
+		hookManagers.set(def, hm);
+	}
+	return hm;
+}
+const SOFT_DELETE = /* @__PURE__ */ new WeakMap();
+function hasSoftDelete(def) {
+	return SOFT_DELETE.has(def);
+}
+function getSoftDeleteConfig(def) {
+	return SOFT_DELETE.get(def);
+}
+function registerSoftDeletesFor(def, deletedAtColumn = "deletedAt") {
+	SOFT_DELETE.set(def, { column: deletedAtColumn });
+}
+function registerTimestampsFor(def, createdAtCol = "createdAt", updatedAtCol = "updatedAt") {
+	const hm = getHooksFor(def);
+	hm.on("beforeCreate", (model) => {
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		if (!model.get(createdAtCol)) model.set(createdAtCol, now);
+		model.set(updatedAtCol, now);
+	});
+	hm.on("beforeUpdate", (model) => {
+		model.set(updatedAtCol, (/* @__PURE__ */ new Date()).toISOString());
+	});
+}
+//#endregion
+export { registerSoftDeletesFor as a, hooks_exports as i, getSoftDeleteConfig as n, registerTimestampsFor as o, hasSoftDelete as r, createHookManager as s, getHooksFor as t };