peta-orm 0.4.1 → 0.6.0

package/README.md

@@ -20,24 +20,67 @@ const page = await Post.query().with("author").orderBy("id", "asc").paginate(1,
 bun add peta-orm arktype kysely @libsql/kysely-libsql @libsql/client
 ```
 
+### Simple setup (examples, scripts)
+
 ```ts
 import { createClient } from "@libsql/client"
 import { LibsqlDialect } from "@libsql/kysely-libsql"
 import { createORM, defineModel, t } from "peta-orm"
 
-const orm = createORM({
-  dialect: new LibsqlDialect({ url: "file:my-app.db" }),
+const User = defineModel("users", {
+  columns: { id: t.integer().primaryKey(), name: t.string(255), email: t.text().unique() },
 })
 
+// Eager init — fine for scripts, one-off tasks
+const client = createClient({ url: "file::memory:?cache=shared" })
+await client.execute(
+  "CREATE TABLE users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL UNIQUE)",
+)
+
+const orm = createORM({ dialect: new LibsqlDialect({ client }), models: { User } })
+
+const user = await User.insert({ name: "Alice", email: "alice@test.com" })
+```
+
+### Production setup (apps, servers) — no module-level side effects
+
+Module-level side effects (database connections, schema init, ORM setup at import time) cause problems with testing, HMR, and error recovery. Use `createDb()` for lazy, safe initialization:
+
+```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: { id: t.integer().primaryKey(), name: t.string(255), email: t.text().unique() },
 })
 
-orm.registerAll(User)
+async function setup() {
+  const client = createClient({ url: "file:my-app.db" })
+  await client.execute(
+    "CREATE TABLE IF NOT EXISTS users (id INTEGER PRIMARY KEY AUTOINCREMENT, name TEXT NOT NULL, email TEXT NOT NULL UNIQUE)",
+  )
+  const orm = createORM({ dialect: new LibsqlDialect({ client }) })
+  orm.registerAll(User)
+  return orm
+}
 
-const user = await User.insert({ name: "Alice", email: "alice@test.com" })
+/** Lazy singleton — first call creates the connection, subsequent calls reuse it. */
+export const db = createDb(setup)
+
+// In route handlers:
+// const orm = await db()
+// const users = await User.query().execute()
 ```
 
+The factory function runs **once** on the first `await db()` call. Importing models has zero side effects — no connection, no schema init, no unhandled promises.
+
+> [!TIP]
+> For an existing Kysely instance (e.g. from a migration runner), pass it via the `kysely` config option:
+> ```ts
+> const orm = createORM({ kysely: existingKysely })
+> ```
+
 > [!TIP]
 > See the 32 [runnable examples](./examples) for every feature. Run them with `bun run examples/XX-*.ts`.
 
@@ -70,7 +113,6 @@ const user = await User.insert({ name: "Alice", email: "alice@test.com" })
 Column definitions double as validation schemas — no separate validation step needed.
 
 ```ts
-const t = columnTypes({ schema: createArkTypeSchemaConfig() })
 
 const User = defineModel("users", {
   columns: {
@@ -268,25 +310,10 @@ const posts = await Post.query()
 
 ## Migrations
 
-Generate and run migrations from model definitions:
+See the [peta-migrate](../migrate/README.md) package for migration generation and running.
 
 ```ts
-import { createMigrationRunner, createMigrationGenerator } from "peta-orm/migrator"
-
-const runner = createMigrationRunner(kysely)
-const gen = createMigrationGenerator()
-
-const code = gen.generateInitialMigration(models)
-await runner.up(migrationFiles)
-```
-
-Or via the CLI:
-
-```bash
-bun run bin/peta migrate:init
-bun run bin/peta migrate:generate
-bun run bin/peta migrate:up
-bun run bin/peta migrate:status
+import { createMigrationRunner, createMigrationGenerator } from "peta-migrate"
 ```
 
 ---
@@ -352,7 +379,16 @@ cd packages/orm
 bun test test/integration/
 ```
 
-Set `INTEGRATION_SKIP_PG=1` or `INTEGRATION_SKIP_MYSQL=1` to skip specific databases.
+### Environment Variables
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `INTEGRATION_PG_URL` | `postgres://postgres:postgres@localhost:5432/peta_orm_test` | PostgreSQL connection string |
+| `INTEGRATION_MYSQL_URL` | `mysql://root:mysqlroot@localhost:3306/peta_orm_test` | MySQL connection string |
+| `INTEGRATION_SKIP_PG` | — | Set to `1` to skip PostgreSQL integration tests |
+| `INTEGRATION_SKIP_MYSQL` | — | Set to `1` to skip MySQL integration tests |
+
+See [`.env.example`](./.env.example) for a copyable template.
 
 ---
 

package/dist/{collection-PFmrQHyM.mjs → collection-D9YZn2mL.mjs}

@@ -44,7 +44,7 @@ function createCollection(items) {
 			return data.map((d) => d.get(key));
 		},
 		pluck(key) {
-			return data.map((d) => d.get(key));
+			return this.get(key);
 		},
 		groupBy(key) {
 			const result = {};
@@ -72,10 +72,6 @@ function createCollection(items) {
 		forEach(fn) {
 			data.forEach(fn);
 		},
-		each(fn) {
-			data.forEach(fn);
-			return collection;
-		},
 		unique(key) {
 			if (!key) {
 				const seen = /* @__PURE__ */ new Set();
@@ -152,11 +148,10 @@ function createCollection(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 { EagerLoader } = await import("./index.mjs").then((n) => n.n);
+			const { getModelDefFromInstance } = await import("./factory-_JPR5fVl.mjs").then((n) => n.n);
 			const first = data[0];
-			const def = getModelDefFromInstance(first) ?? getModelDef(first);
+			const def = getModelDefFromInstance(first);
 			if (def) {
 				const loader = new EagerLoader();
 				for (const rel of relations) await loader.loadRelated(data, { name: rel }, def);

package/dist/{crud-BCWvg5MI.mjs → crud-Di2nvpjB.mjs}

@@ -1,4 +1,6 @@
-import { r as DatabaseError, s as RelationNotFoundError } from "./errors-sfFJolfu.mjs";
+import { c as RelationNotFoundError, i as DatabaseError, n as isUniqueConstraintError, r as normalizeError } from "./errors-i-gCZnlW.mjs";
+import { t as getDb } from "./model-helpers-BBpD3qdv.mjs";
+import { i as resolveTargetId, n as getPivotInfo, t as findRelated } from "./helpers-CcxHFhtz.mjs";
 //#region src/relations/crud.ts
 function extractRelationData(def, data) {
 	const columnData = {};
@@ -12,10 +14,6 @@ function extractRelationData(def, data) {
 		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
@@ -77,25 +75,10 @@ async function processManyToManyCreate(_instance, relation, op, pkValue) {
 				[foreignPivotKey]: pkValue,
 				[relatedPivotKey]: relatedId
 			}).execute();
-		} catch {}
+		} catch (e) {
+			if (!isUniqueConstraintError(e)) throw normalizeError(e, throughTable);
+		}
 	}
 }
-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 → errors-i-gCZnlW.mjs}

@@ -62,8 +62,21 @@ function normalizeError(e, table) {
 	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);
 }
+function isUniqueConstraintError(error) {
+	if (error instanceof Error) {
+		const msg = error.message.toLowerCase();
+		if (msg.includes("unique") || msg.includes("sqlite_constraint")) return true;
+		if (msg.includes("23505")) return true;
+		if (msg.includes("1062") || msg.includes("duplicate entry")) return true;
+	}
+	if (error && typeof error === "object" && "code" in error) {
+		const code = error.code;
+		if (code === "23505" || code === "ER_DUP_ENTRY" || code === "SQLITE_CONSTRAINT_UNIQUE") return true;
+	}
+	return false;
+}
 //#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 };
+export { ModelNotFoundError as a, RelationNotFoundError as c, DatabaseError as i, ValidationError as l, isUniqueConstraintError as n, ModelNotRegisteredError as o, normalizeError as r, RelationNotAllowedError as s, errors_exports as t };

package/dist/{factory-BBvIMQuc.mjs → factory-_JPR5fVl.mjs}

@@ -39,10 +39,10 @@ function castForSet(value, type) {
 		default: return value;
 	}
 }
-function applyCastsToData(config, data, mode) {
+function applyCastsToData(config, data) {
 	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);
+	for (const [key, type] of Object.entries(config.casts)) if (key in result) result[key] = castValue(result[key], type);
 	return result;
 }
 //#endregion
@@ -77,6 +77,7 @@ function getModelDefFromInstance(instance) {
 	return instanceDefs.get(instance);
 }
 function createInstance(def, config, data, exists) {
+	const validColumns = new Set(Object.keys(def.columns));
 	const instance = {
 		get exists() {
 			return getExists(instance);
@@ -106,7 +107,7 @@ function createInstance(def, config, data, exists) {
 		},
 		fill(data) {
 			const safe = {};
-			for (const [key, value] of Object.entries(data)) if (!FORBIDDEN_KEYS.has(key)) {
+			for (const [key, value] of Object.entries(data)) if (!FORBIDDEN_KEYS.has(key) && validColumns.has(key)) {
 				let v = value;
 				const attrDef = config.attributes?.[key];
 				if (attrDef?.set) v = attrDef.set(v, instance);
@@ -160,7 +161,7 @@ function createInstance(def, config, data, exists) {
 			return getRuntime().modelToJSON(def, instance);
 		}
 	};
-	if (exists) initState(instance, applyCastsToData(config, data || {}, "get"), true);
+	if (exists) initState(instance, applyCastsToData(config, data || {}), true);
 	else {
 		initState(instance, {}, false);
 		if (data && Object.keys(data).length > 0) instance.fill(data);

package/dist/helpers-CcxHFhtz.mjs

@@ -0,0 +1,40 @@
+//#region src/relations/helpers.ts
+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;
+}
+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;
+}
+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 { resolveThunk as a, resolveTargetId as i, getPivotInfo as n, groupByArray as r, findRelated as t };

package/dist/{hooks-BD0xy7uw.mjs → hooks-D508wLQg.mjs}

@@ -1,4 +1,3 @@
-import { t as __exportAll } from "./rolldown-runtime-D7D4PA-g.mjs";
 //#region src/hooks/index.ts
 function createHookManager() {
 	const listeners = /* @__PURE__ */ new Map();
@@ -22,27 +21,14 @@ function createHookManager() {
 		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
+		trigger
 	};
 }
 //#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);
@@ -74,4 +60,4 @@ function registerTimestampsFor(def, createdAtCol = "createdAt", updatedAtCol = "
 	});
 }
 //#endregion
-export { registerSoftDeletesFor as a, hooks_exports as i, getSoftDeleteConfig as n, registerTimestampsFor as o, hasSoftDelete as r, createHookManager as s, getHooksFor as t };
+export { registerTimestampsFor as a, registerSoftDeletesFor as i, getSoftDeleteConfig as n, createHookManager as o, hasSoftDelete as r, getHooksFor as t };