peta-orm 0.5.0 → 0.6.0

package/README.md

@@ -310,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"
 ```
 
 ---
@@ -394,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 };

package/dist/index.d.mts

@@ -40,8 +40,33 @@ declare function createColumn<T>(schema: SchemaConfig, dataType: string, args?:
 type ColumnShape = Record<string, Column>;
 type ColumnValue<C> = C extends Column<infer T> ? T : never;
 //#endregion
-//#region src/lib/kysely.d.ts
+//#region src/types.d.ts
 type Database = Kysely<Record<string, never>>;
+interface ModelLike<TColumns extends ColumnShape = ColumnShape> {
+  get<K extends keyof TColumns>(key: K): ColumnValue<TColumns[K]>;
+  get(key: string): unknown;
+  set(key: string, value: unknown): void;
+}
+interface ORMLike {
+  readonly kysely: Database;
+  register(model: ModelDefinition<any>): void;
+  registerAll(...models: (ModelDefinition<any> | ModelDefinition<any>[])[]): void;
+  destroy(): Promise<void>;
+  transaction<T>(fn: (orm: ORMLike) => Promise<T>): Promise<T>;
+  readonly models: ReadonlyMap<string, ModelDefinition<any>>;
+  getModel<T extends ColumnShape = ColumnShape>(name: string): ModelDefinition<T> | undefined;
+  /**
+   * Discover model definitions by scanning files matching a glob pattern.
+   *
+   * Uses `fast-glob` to resolve the pattern relative to `cwd`, then dynamically
+   * imports each matching file and collects exported `ModelDefinition` values.
+   * Does **not** auto-register — use `registerAll(...result)` to register them.
+   *
+   * @param pattern  Glob pattern (e.g. `"./src/models/**\/*.ts"`)
+   * @returns  Array of discovered model definitions
+   */
+  discover(pattern: string): Promise<ModelDefinition<any>[]>;
+}
 //#endregion
 //#region src/pagination/index.d.ts
 interface Paginator<TColumns extends ColumnShape = ColumnShape> {
@@ -56,8 +81,6 @@ interface Paginator<TColumns extends ColumnShape = ColumnShape> {
   readonly lastItem: number;
   readonly onFirstPage: boolean;
   readonly onLastPage: boolean;
-  readonly count: number;
-  map<T>(fn: (item: ModelInstance<TColumns>) => T): T[];
   toJSON(): PaginatorJson<TColumns>;
 }
 interface PaginatorJson<TColumns extends ColumnShape = ColumnShape> {
@@ -73,9 +96,14 @@ interface PaginatorJson<TColumns extends ColumnShape = ColumnShape> {
   onFirstPage: boolean;
   onLastPage: boolean;
 }
-type PaginatedResult = PaginatorJson;
 declare function createPaginator<TColumns extends ColumnShape = ColumnShape>(items: ModelInstance<TColumns>[], total: number, perPage: number, currentPage: number): Paginator<TColumns>;
 //#endregion
+//#region src/relations/graph/delete.d.ts
+interface DeleteGraphOptions {
+  allowedRelations?: string[];
+}
+declare function deleteGraph(def: ModelDefinition, model: ModelInstance, options?: DeleteGraphOptions): Promise<void>;
+//#endregion
 //#region src/relations/base.d.ts
 type RelationType = "hasMany" | "belongsTo" | "hasOne" | "manyToMany" | "hasManyThrough";
 interface RelationOptions {
@@ -156,14 +184,11 @@ interface QueryBuilder<TColumns extends ColumnShape = ColumnShape> extends Promi
   max(column: string): Promise<number>;
   withCount(relation: string): QueryBuilder<TColumns>;
   withSum(relation: string, column: string): QueryBuilder<TColumns>;
-  withAvg(relation: string, column: string): QueryBuilder<TColumns>;
-  withMin(relation: string, column: string): QueryBuilder<TColumns>;
-  withMax(relation: string, column: string): QueryBuilder<TColumns>;
-  withExists(relation: string): QueryBuilder<TColumns>;
   chunk(size: number, callback: (chunk: ModelInstance<TColumns>[]) => Promise<void>): Promise<void>;
   paginate(page: number, perPage?: number): Promise<Paginator<TColumns>>;
   insertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: InsertGraphOptions): Promise<any>;
   upsertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: UpsertGraphOptions): Promise<any>;
+  upsert(data: Record<string, unknown>): Promise<ModelInstance<TColumns>>;
   with(...relations: (string | Record<string, (qb: QueryBuilder<TColumns>) => void>)[]): QueryBuilder<TColumns>;
   /**
    * Whitelist allowed relations (and nested paths) for eager loading.
@@ -182,10 +207,18 @@ interface QueryBuilder<TColumns extends ColumnShape = ColumnShape> extends Promi
   withTrashed(): QueryBuilder<TColumns>;
   onlyTrashed(): QueryBuilder<TColumns>;
   whereIn(column: string, values: unknown[]): QueryBuilder<TColumns>;
-  whereInPivot(column: string, values: unknown[]): QueryBuilder<TColumns>;
   has(relationName: string): QueryBuilder<TColumns>;
-  whereHas(relationName: string, callback?: (qb: QueryBuilder<TColumns>) => void): QueryBuilder<TColumns>;
-  whereDoesntHave(relationName: string, callback?: (qb: QueryBuilder<TColumns>) => void): QueryBuilder<TColumns>;
+  /**
+   * Filter rows by related model existence with optional subquery filtering.
+   * The callback receives a raw Kysely subquery builder for the related table,
+   * not a peta-orm QueryBuilder. Chain `.where(...)` etc. directly on it.
+   */
+  whereHas(relationName: string, callback?: (subQb: any) => any): QueryBuilder<TColumns>;
+  /**
+   * Filter rows by absence of related model, with optional subquery filtering.
+   * Same callback semantics as `whereHas`.
+   */
+  whereDoesntHave(relationName: string, callback?: (subQb: any) => any): QueryBuilder<TColumns>;
   where(column: string, operator: unknown, value?: unknown): QueryBuilder<TColumns>;
   whereRef(col1: string, operator: string, col2: string): QueryBuilder<TColumns>;
   orWhere(column: string, operator: unknown, value?: unknown): QueryBuilder<TColumns>;
@@ -242,59 +275,6 @@ interface RelationQuery extends QueryBuilder {
  */
 type Plugin = (def: ModelDefinition) => undefined | ModelDefinition;
 //#endregion
-//#region src/types.d.ts
-type ModelId = number & {
-  readonly __brand: "ModelId";
-};
-interface ModelLike<TColumns extends ColumnShape = ColumnShape> {
-  get<K extends keyof TColumns>(key: K): ColumnValue<TColumns[K]>;
-  get(key: string): unknown;
-  set(key: string, value: unknown): void;
-}
-interface ORMLike {
-  readonly kysely: Database;
-  register(model: ModelDefinition$1<any>): void;
-  registerAll(...models: (ModelDefinition$1<any> | ModelDefinition$1<any>[])[]): void;
-  destroy(): Promise<void>;
-  transaction<T>(fn: (trx: import("kysely").Kysely<Record<string, never>>) => Promise<T>): Promise<T>;
-  readonly models: ReadonlyMap<string, ModelDefinition$1<any>>;
-  getModel<T extends ColumnShape = ColumnShape>(name: string): ModelDefinition$1<T> | undefined;
-  /**
-   * Discover model definitions by scanning files matching a glob pattern.
-   *
-   * Uses `fast-glob` to resolve the pattern relative to `cwd`, then dynamically
-   * imports each matching file and collects exported `ModelDefinition` values.
-   * Does **not** auto-register — use `registerAll(...result)` to register them.
-   *
-   * @param pattern  Glob pattern (e.g. `"./src/models/**\/*.ts"`)
-   * @returns  Array of discovered model definitions
-   */
-  discover(pattern: string): Promise<ModelDefinition$1<any>[]>;
-}
-interface ModelDefinition$1<TColumns extends ColumnShape = ColumnShape> {
-  readonly table: string;
-  readonly columns: TColumns;
-  readonly relations: Record<string, Relation>;
-  readonly name: string;
-  _orm: ORMLike | null;
-  query(): QueryBuilder<TColumns>;
-  find(id: number | string): Promise<ModelInstance<TColumns> | undefined>;
-  findOrFail(id: number | string): Promise<ModelInstance<TColumns>>;
-  first(): Promise<ModelInstance<TColumns> | undefined>;
-  create(data: Record<string, unknown>): Promise<ModelInstance<TColumns>>;
-  insert(data: Record<string, unknown>): Promise<ModelInstance<TColumns>>;
-  insertMany(dataArray: Record<string, unknown>[]): Promise<ModelInstance<TColumns>[]>;
-  update(id: number | string, data: Record<string, unknown>): Promise<ModelInstance<TColumns>>;
-  delete(id: number | string): Promise<void>;
-  hydrate(row: Record<string, unknown>): ModelInstance<TColumns>;
-  on(event: string, callback: (model: ModelInstance<TColumns>) => void | Promise<void>): () => void;
-  getHooks(): HookManager;
-  addGlobalScope(name: string, callback: (qb: QueryBuilder) => void): void;
-  removeGlobalScope(name: string): void;
-  getGlobalScopes(): Map<string, (qb: QueryBuilder) => void> | undefined;
-  _init(orm: ORMLike): void;
-}
-//#endregion
 //#region src/hooks/index.d.ts
 type LifecycleEvent = "beforeCreate" | "afterCreate" | "beforeUpdate" | "afterUpdate" | "beforeSave" | "afterSave" | "beforeDelete" | "afterDelete" | "beforeRestore" | "afterRestore" | "beforeForceDelete" | "afterForceDelete";
 type HookCallback = (model: ModelLike) => void | Promise<void>;
@@ -302,7 +282,6 @@ interface HookManager {
   on(event: LifecycleEvent, callback: HookCallback): () => void;
   off(event: LifecycleEvent, callback: HookCallback): void;
   trigger(event: LifecycleEvent, model: ModelLike): Promise<void>;
-  clone(): HookManager;
 }
 declare function createHookManager(): HookManager;
 //#endregion
@@ -319,14 +298,12 @@ type StaticHookCallback = (args: StaticHookArgs) => void | Promise<void>;
 //#endregion
 //#region src/model/computed.d.ts
 interface ComputedColumn<T = unknown> {
-  readonly type: "sql" | "runtime" | "batch";
+  readonly type: "runtime" | "batch";
   readonly dependencies: string[];
   /** Compute a value for a single record (runtime) */
   compute?: (record: ModelInstance) => T;
   /** Compute values for a batch of records (batch async) */
   batchCompute?: (records: ModelInstance[]) => Promise<T[]>;
-  /** Raw SQL expression to inline in SELECT */
-  sql?: string;
 }
 //#endregion
 //#region src/model/attribute.d.ts
@@ -410,10 +387,14 @@ interface ModelDefinition<TColumns extends ColumnShape = ColumnShape> {
   create(data: Record<string, unknown>): Promise<ModelInstance<TColumns>>;
   insert(data: Record<string, unknown>): Promise<ModelInstance<TColumns>>;
   insertMany(dataArray: Record<string, unknown>[]): Promise<ModelInstance<TColumns>[]>;
+  updateMany(data: Record<string, unknown>, where: Record<string, unknown>[]): Promise<number>;
+  deleteMany(where: Record<string, unknown>[]): Promise<number>;
   update(id: number | string, data: Record<string, unknown>): Promise<ModelInstance<TColumns>>;
   delete(id: number | string): Promise<void>;
+  deleteGraph(idOrInstance: any, options?: DeleteGraphOptions): Promise<void>;
   insertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: InsertGraphOptions): Promise<any>;
   upsertGraph(data: Record<string, unknown> | Record<string, unknown>[], options?: UpsertGraphOptions): Promise<any>;
+  upsert(data: Record<string, unknown>): Promise<ModelInstance<TColumns>>;
   hydrate(row: Record<string, unknown>): ModelInstance<TColumns>;
   use(plugin: Plugin): ModelDefinition<TColumns>;
   makeHelper<A extends any[], R>(fn: (qb: QueryBuilder, ...args: A) => R): (...args: A) => R;
@@ -422,11 +403,6 @@ interface ModelDefinition<TColumns extends ColumnShape = ColumnShape> {
   beforeDelete(callback: StaticHookCallback): () => void;
   afterDelete(callback: StaticHookCallback): () => void;
   beforeUpdate(callback: StaticHookCallback): () => void;
-  afterUpdate(callback: StaticHookCallback): () => void;
-  beforeCreate(callback: StaticHookCallback): () => void;
-  afterCreate(callback: StaticHookCallback): () => void;
-  beforeFind(callback: StaticHookCallback): () => void;
-  afterFind(callback: StaticHookCallback): () => void;
   addGlobalScope(name: string, callback: (qb: QueryBuilder) => void): void;
   removeGlobalScope(name: string): void;
   getGlobalScopes(): Map<string, (qb: QueryBuilder) => void> | undefined;
@@ -468,7 +444,6 @@ interface Collection<TColumns extends ColumnShape = ColumnShape> {
   filter(fn: (item: ModelInstance<TColumns>, index: number) => boolean): Collection<TColumns>;
   reduce<T>(fn: (acc: T, item: ModelInstance<TColumns>, index: number) => T, initial: T): T;
   forEach(fn: (item: ModelInstance<TColumns>, index: number) => void): void;
-  each(fn: (item: ModelInstance<TColumns>, index: number) => void): Collection<TColumns>;
   unique(key?: string): Collection<TColumns>;
   sortBy(key: string, direction?: "asc" | "desc"): Collection<TColumns>;
   shuffle(): Collection<TColumns>;
@@ -601,6 +576,24 @@ declare function normalizeError(e: unknown, table?: string): DatabaseError;
  */
 declare function createDb<T>(factory: () => Promise<T>): () => Promise<T>;
 //#endregion
+//#region src/integrations/elysia.d.ts
+interface PetaElysiaPluginOptions {
+  peta: ORMLike;
+}
+/**
+ * Elysia.js plugin that attaches the ORM instance to the app context.
+ */
+declare function petaPlugin(options: PetaElysiaPluginOptions): (app: any) => any;
+//#endregion
+//#region src/integrations/hono.d.ts
+interface PetaHonoMiddlewareOptions {
+  peta: ORMLike;
+}
+/**
+ * Hono middleware that sets the ORM instance on the context.
+ */
+declare function petaMiddleware(options: PetaHonoMiddlewareOptions): (c: any, next: any) => Promise<void>;
+//#endregion
 //#region src/model/define.d.ts
 declare function defineModel<TColumns extends ColumnShape>(table: string, config: ModelConfig<TColumns>): ModelDefinition<TColumns>;
 //#endregion
@@ -669,6 +662,42 @@ declare function timestamps(opts?: {
  */
 declare function ulid(): Plugin;
 //#endregion
+//#region src/relations/crud.d.ts
+interface BelongsToOp {
+  create?: Record<string, unknown>;
+  connect?: Record<string, unknown>;
+  connectOrCreate?: {
+    where: Record<string, unknown>;
+    create: Record<string, unknown>;
+  };
+  update?: Record<string, unknown>;
+  upsert?: {
+    update: Record<string, unknown>;
+    create: Record<string, unknown>;
+  };
+  delete?: boolean;
+  disconnect?: boolean;
+  set?: Record<string, unknown>;
+}
+interface HasManyOp {
+  create?: Record<string, unknown>[];
+  connect?: (number | string | Record<string, unknown>)[];
+  set?: (number | string | Record<string, unknown>)[];
+  delete?: Record<string, unknown> | Record<string, unknown>[];
+  update?: {
+    where: Record<string, unknown> | Record<string, unknown>[];
+    data: Record<string, unknown>;
+  };
+}
+interface ManyToManyOp {
+  create?: Record<string, unknown>[];
+  connect?: (number | string | Record<string, unknown>)[];
+  disconnect?: Record<string, unknown> | Record<string, unknown>[];
+  set?: (number | string | Record<string, unknown>)[];
+  add?: (number | string | Record<string, unknown>)[];
+}
+type RelationData = BelongsToOp | HasManyOp | ManyToManyOp;
+//#endregion
 //#region src/relations/has-many.d.ts
 declare function hasMany(relatedThunk: () => ModelDefinition, options?: RelationOptions): Relation;
 declare function hasOne(relatedThunk: () => ModelDefinition, options?: RelationOptions): Relation;
@@ -709,13 +738,6 @@ interface MorphManyOptions {
    */
   typeValue?: string;
 }
-interface MorphOneOptions {
-  name: string;
-  related: () => ModelDefinition;
-  type?: string;
-  id?: string;
-  typeValue?: string;
-}
 /**
  * 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
@@ -756,10 +778,6 @@ declare function defineMorphTo(options: MorphToOptions): Relation;
  * The related table stores the parent's type and id.
  */
 declare function defineMorphMany(options: MorphManyOptions): Relation;
-/**
- * Define a polymorphic hasOne relationship.
- */
-declare function defineMorphOne(options: MorphOneOptions): Relation;
 //#endregion
 //#region src/repo/index.d.ts
 type QueryMethod = (qb: QueryBuilder, ...args: any[]) => QueryBuilder;
@@ -783,4 +801,4 @@ interface RepoMethods {
  */
 declare function createRepo<TMethods extends RepoMethods>(model: ModelDefinition, methods: TMethods): Record<string, never>;
 //#endregion
-export { Attribute, type Collection, type Column, type ColumnShape, type ColumnTypes, type ColumnValue, type Constraint, DatabaseError, type DatabaseErrorCode, type HookCallback, type HookManager, type InsertGraphOptions, type LifecycleEvent, type ModelConfig, type ModelDefinition, type ModelId, type ModelInstance, ModelNotFoundError, ModelNotRegisteredError, type MorphManyOptions, type MorphOneOptions, type MorphToOptions, type ORMConfig, type ORMLike, type PaginatedResult, type Paginator, type PaginatorJson, type Plugin, type QueryBuilder, type QueryMethod, type Relation, RelationNotAllowedError, RelationNotFoundError, type RelationOptions, type RelationType, type RepoMethods, type SchemaConfig, type SerializedShape, type UpsertGraphOptions, ValidationError, belongsTo, createArkTypeSchemaConfig, createCollection, createColumn, createColumnTypes, createDb, createHookManager, createORM, createORM as createPeta, createPaginator, createQueryBuilder, createRepo, defineModel, defineMorphMany, defineMorphOne, defineMorphTo, hasMany, hasManyThrough, hasOne, manyToMany, normalizeError, resolveMorphRelation, softDeletes, t, timestamps, ulid };
+export { Attribute, type BelongsToOp, type Collection, type Column, type ColumnShape, type ColumnTypes, type ColumnValue, type Constraint, DatabaseError, type DatabaseErrorCode, type DeleteGraphOptions, type HasManyOp, type HookCallback, type HookManager, type InsertGraphOptions, type LifecycleEvent, type ManyToManyOp, type ModelConfig, type ModelDefinition, type ModelInstance, ModelNotFoundError, ModelNotRegisteredError, type MorphManyOptions, type MorphToOptions, type ORMConfig, type ORMLike, type Paginator, type PaginatorJson, type Plugin, type QueryBuilder, type QueryMethod, type Relation, type RelationData, RelationNotAllowedError, RelationNotFoundError, type RelationOptions, type RelationType, type RepoMethods, type SchemaConfig, type SerializedShape, type UpsertGraphOptions, ValidationError, belongsTo, createArkTypeSchemaConfig, createCollection, createColumn, createColumnTypes, createDb, createHookManager, createORM, createORM as createPeta, createPaginator, createQueryBuilder, createRepo, defineModel, defineMorphMany, defineMorphTo, deleteGraph, hasMany, hasManyThrough, hasOne, manyToMany, normalizeError, petaMiddleware, petaPlugin, resolveMorphRelation, softDeletes, t, timestamps, ulid };