peta-orm 0.2.2 → 0.2.4

package/README.md

@@ -23,6 +23,7 @@ bun add -d kysely-bun-sqlite
 // db.ts
 import { Database } from "bun:sqlite"
 import { BunSqliteDialect } from "kysely-bun-sqlite"
+import type { ColumnShape } from "peta-orm"
 import { Peta, $t, ArkTypeSchemaConfig, Model, HasMany } from "peta-orm"
 
 const t = $t({ schema: new ArkTypeSchemaConfig() })
@@ -32,8 +33,8 @@ class User extends Model {
   static override columns = {
     id: t.integer().primaryKey(),
     name: t.string(255).min(2),
-    email: t.text().email(),
-  }
+    email: t.text().email().unique(),
+  } satisfies ColumnShape
   static override relations = {
     posts: new HasMany(() => Post),
   }
@@ -43,9 +44,9 @@ class Post extends Model {
   static override table = "posts"
   static override columns = {
     id: t.integer().primaryKey(),
-    userId: t.integer(),
+    userId: t.integer().references(() => User, ["id"]),
     title: t.string(255),
-  }
+  } satisfies ColumnShape
 }
 
 const database = new Database("my-app.db")
@@ -88,18 +89,30 @@ export { peta, User, Post }
 ### Column Types & Validation
 
 ```ts
+import type { ColumnShape } from "peta-orm"
+
 const t = $t({ schema: new ArkTypeSchemaConfig() })
 
 class User extends Model {
   static override columns = {
     id: t.integer().primaryKey(),
     name: t.string(255).min(2),          // min length
-    email: t.text().email(),             // email format
+    email: t.text().email().unique(),    // email format + unique constraint
     age: t.integer().nullable().min(0).max(150).default(0),
     role: t.enum("admin", "user").default("user"),
     score: t.double().nullable(),
     ...t.timestamps(),                   // createdAt, updatedAt
-  }
+  } satisfies ColumnShape
+}
+
+class Post extends Model {
+  static override columns = {
+    id: t.integer().primaryKey(),
+    userId: t.integer().references(() => User, ["id"]),  // foreign key
+    title: t.string(255),
+    slug: t.string().unique(),
+    published: t.boolean().default(false),
+  } satisfies ColumnShape
 }
 ```
 
@@ -132,6 +145,36 @@ const authors = await User.query().has("posts").execute()
 const active = await User.query().whereHas("posts", (q) => q.where("published", true)).execute()
 ```
 
+### ManyToMany
+
+```ts
+class Post extends Model {
+  static override columns = { id: t.integer().primaryKey(), title: t.string(255) } satisfies ColumnShape
+  static override relations = {
+    tags: new ManyToMany(() => Tag, {
+      through: "post_tags",
+      foreignPivotKey: "postId",
+      relatedPivotKey: "tagId",
+    }),
+  }
+}
+
+class Tag extends Model {
+  static override columns = { id: t.integer().primaryKey(), name: t.string(255) } satisfies ColumnShape
+}
+
+// Pivot tables are regular Models — register them so the migration
+// generator includes the pivot table automatically.
+class PostTag extends Model {
+  static override table = "post_tags"
+  static override columns = {
+    id: t.integer().primaryKey(),
+    postId: t.integer().references(() => Post, ["id"]),
+    tagId: t.integer().references(() => Tag, ["id"]),
+  } satisfies ColumnShape
+}
+```
+
 ### CRUD & Pagination
 
 ```ts

package/dist/{index-zth6eamb.js → index-bv1vk6ec.js}

@@ -5,6 +5,7 @@ import {
   CreateViewNode,
   IdentifierNode,
   InsertQueryNode,
+  ManyToMany,
   MergeQueryNode,
   NOOP_QUERY_EXECUTOR,
   OperatorNode,
@@ -30,7 +31,7 @@ import {
   parseTable,
   parseValueExpression,
   preventAwait
-} from "./index-qwps5bne.js";
+} from "./index-gacxptb4.js";
 import {
   __require
 } from "./index-k18nf2r7.js";
@@ -2091,6 +2092,8 @@ class MigrationGenerator {
     const timestamp = new Date().toISOString().replace(/[-:T.Z]/g, "").slice(0, 14);
     const parts = [];
     const indexParts = [];
+    const warnings = [];
+    const registeredTables = new Set([...models.values()].map((m) => m.table).filter(Boolean));
     for (const [, modelClass] of models) {
       const table = modelClass.table;
       if (!table)
@@ -2102,16 +2105,30 @@ class MigrationGenerator {
           indexParts.push(this.#generateCreateIndex(table, colName));
         }
       }
+      for (const [relName, rel] of Object.entries(modelClass.relations ?? {})) {
+        if (rel instanceof ManyToMany) {
+          const through = rel.throughTable;
+          if (!registeredTables.has(through)) {
+            warnings.push(`// \u26A0 Detected ManyToMany "${modelClass.name}.${relName}" references table "${through}" ` + `but no model is registered for it.
+` + `//   Add a model class with static override table = "${through}" to include the pivot ` + `table in the generated migration.`);
+          }
+        }
+      }
     }
     const upBody = [...parts, ...indexParts].join(`
 
 `);
     const downTables = [...models.values()].filter((m) => m.table).map((m) => `  await db.schema.dropTable("${m.table}").ifExists().execute()`);
+    const warningBlock = warnings.length > 0 ? `  // Warnings:
+${warnings.join(`
+`)}
+
+` : "";
     return `import type { Kysely } from "kysely"
 import { sql } from "kysely"
 
 export async function up(db: Kysely<any>): Promise<void> {
-${upBody}
+${warningBlock}${upBody}
 }
 
 export async function down(db: Kysely<any>): Promise<void> {
@@ -2122,7 +2139,7 @@ ${downTables.join(`
   }
   #generateCreateTable(table, columns) {
     const lines = [];
-    lines.push(`  await db.schema.createTable("${table}")`);
+    lines.push(`  await db.schema.createTable("${table}").ifNotExists()`);
     for (const [name, col] of Object.entries(columns)) {
       const typeSql = this.#mapType(col);
       const cb = this.#columnCallback(col);

package/dist/{index-qwps5bne.js → index-gacxptb4.js}

@@ -7531,4 +7531,289 @@ class Peta {
   }
 }
 
-export { isString, isNumber, isBoolean, isNull, isDate, isBigInt, getLast, freeze, IdentifierNode, CreateTableNode, AliasNode, isOperationNodeSource, OperatorNode, RawNode, parseStringReference, ValueNode, parseValueExpression, ParensNode, preventAwait, InsertQueryNode, MergeQueryNode, QueryNode, createQueryId, WithSchemaPlugin, NOOP_QUERY_EXECUTOR, SetOperationNode, parseTable, CreateViewNode, isModelClass, Peta };
+// src/relations/relation.ts
+var thunkCache = new WeakMap;
+function resolve2(thunk) {
+  let cls = thunkCache.get(thunk);
+  if (!cls) {
+    cls = thunk();
+    thunkCache.set(thunk, cls);
+  }
+  return cls;
+}
+function guessForeignKey(modelClass) {
+  const table = modelClass.table;
+  const singular = table.endsWith("s") ? table.slice(0, -1) : table;
+  return `${singular}Id`;
+}
+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;
+}
+
+class Relation {
+  type;
+  #relatedThunk;
+  constructor(type, relatedThunk) {
+    this.type = type;
+    this.#relatedThunk = relatedThunk;
+  }
+  get relatedModelClass() {
+    return resolve2(this.#relatedThunk);
+  }
+}
+
+class HasMany extends Relation {
+  #options;
+  constructor(relatedThunk, options = {}) {
+    super("hasMany", relatedThunk);
+    this.#options = options;
+  }
+  get foreignKey() {
+    return this.#options.foreignKey ?? guessForeignKey(this.relatedModelClass);
+  }
+  get localKey() {
+    return this.#options.localKey ?? "id";
+  }
+  query(parent) {
+    return this.relatedModelClass.query().where(this.foreignKey, "=", parent.get(this.localKey));
+  }
+  addEagerConstraints(query, models) {
+    const keys = models.map((m) => m.get(this.localKey)).filter((k) => k != null);
+    if (keys.length > 0) {
+      query.whereIn(this.foreignKey, keys);
+    }
+  }
+  match(models, results, relationName) {
+    const grouped = groupByArray(results, this.foreignKey);
+    for (const model of models) {
+      const key = String(model.get(this.localKey));
+      model.$setRelation(relationName, grouped[key] ?? []);
+    }
+  }
+  async getResults(parent) {
+    return await this.query(parent).execute();
+  }
+}
+
+class BelongsTo extends Relation {
+  #options;
+  constructor(relatedThunk, options = {}) {
+    super("belongsTo", relatedThunk);
+    this.#options = options;
+  }
+  get foreignKey() {
+    return this.#options.foreignKey ?? guessForeignKey(this.relatedModelClass);
+  }
+  get localKey() {
+    return this.#options.localKey ?? "id";
+  }
+  query(parent) {
+    return this.relatedModelClass.query().where(this.localKey, "=", parent.get(this.foreignKey));
+  }
+  addEagerConstraints(query, models) {
+    const keys = models.map((m) => m.get(this.foreignKey)).filter((k) => k != null);
+    if (keys.length > 0) {
+      query.whereIn(this.localKey, keys);
+    }
+  }
+  match(models, results, relationName) {
+    const grouped = groupByArray(results, this.localKey);
+    for (const model of models) {
+      const key = String(model.get(this.foreignKey));
+      model.$setRelation(relationName, grouped[key]?.[0] ?? null);
+    }
+  }
+  async getResults(parent) {
+    return await this.query(parent).executeTakeFirst() ?? null;
+  }
+}
+
+class HasOne extends Relation {
+  #options;
+  constructor(relatedThunk, options = {}) {
+    super("hasOne", relatedThunk);
+    this.#options = options;
+  }
+  get foreignKey() {
+    return this.#options.foreignKey ?? guessForeignKey(this.relatedModelClass);
+  }
+  get localKey() {
+    return this.#options.localKey ?? "id";
+  }
+  query(parent) {
+    return this.relatedModelClass.query().where(this.foreignKey, "=", parent.get(this.localKey));
+  }
+  addEagerConstraints(query, models) {
+    const keys = models.map((m) => m.get(this.localKey)).filter((k) => k != null);
+    if (keys.length > 0) {
+      query.whereIn(this.foreignKey, keys);
+    }
+  }
+  match(models, results, relationName) {
+    const grouped = groupByArray(results, this.foreignKey);
+    for (const model of models) {
+      const key = String(model.get(this.localKey));
+      model.$setRelation(relationName, grouped[key]?.[0] ?? null);
+    }
+  }
+  async getResults(parent) {
+    return await this.query(parent).executeTakeFirst() ?? null;
+  }
+}
+
+class ManyToMany extends Relation {
+  #options;
+  #pivotExtras;
+  constructor(relatedThunk, options) {
+    super("manyToMany", relatedThunk);
+    this.#options = options;
+    this.#pivotExtras = options.pivotExtras ?? [];
+  }
+  get foreignKey() {
+    return this.#options.foreignKey ?? guessForeignKey(this.relatedModelClass);
+  }
+  get localKey() {
+    return this.#options.localKey ?? "id";
+  }
+  get throughTable() {
+    return this.#options.through;
+  }
+  get foreignPivotKey() {
+    return this.#options.foreignPivotKey ?? snakeCase(this.foreignKey);
+  }
+  get relatedPivotKey() {
+    return this.#options.relatedPivotKey ?? snakeCase(guessForeignKey(this.relatedModelClass));
+  }
+  #hasExtras() {
+    return this.#pivotExtras.length > 0;
+  }
+  query(parent) {
+    const parentKey = parent.get(this.localKey);
+    const peta = this.relatedModelClass.peta;
+    if (!peta)
+      return this.relatedModelClass.query();
+    if (this.#hasExtras()) {
+      const _relatedTable = this.relatedModelClass.table;
+      const peta2 = this.relatedModelClass.peta;
+      if (!peta2)
+        return this.relatedModelClass.query();
+      const subQb = peta2.kysely.selectFrom(this.throughTable).select(this.relatedPivotKey).where(this.foreignPivotKey, "=", parentKey);
+      return this.relatedModelClass.query().whereIn("id", subQb);
+    }
+    const subquery = peta.kysely.selectFrom(this.throughTable).select(this.relatedPivotKey).where(this.foreignPivotKey, "=", parentKey);
+    return this.relatedModelClass.query().whereIn("id", subquery);
+  }
+  addEagerConstraints(query, models) {
+    const keys = models.map((m) => m.get(this.localKey)).filter((k) => k != null);
+    if (keys.length === 0) {
+      query.whereIn("id", []);
+      return;
+    }
+    const relatedTable = this.relatedModelClass.table;
+    query.innerJoin(this.throughTable, `${this.throughTable}.${this.relatedPivotKey}`, `${relatedTable}.${this.localKey}`);
+    query.whereIn(`${this.throughTable}.${this.foreignPivotKey}`, keys);
+  }
+  match(models, results, relationName) {
+    const grouped = groupByArray(results, `_pivot_${this.foreignPivotKey}`);
+    for (const model of models) {
+      const key = String(model.get(this.localKey));
+      const items = grouped[key] ?? [];
+      for (const item of items) {
+        const pivotData = {};
+        for (const ek of Object.keys(item.attributes ?? {})) {
+          if (ek.startsWith("_pivot_")) {
+            pivotData[ek.slice(7)] = item.get(ek);
+          }
+        }
+        if (Object.keys(pivotData).length > 0) {
+          item.$setRelation("_pivot", pivotData);
+        }
+      }
+      model.$setRelation(relationName, items);
+    }
+  }
+  async getResults(parent) {
+    return await this.query(parent).execute();
+  }
+}
+
+class HasManyThrough extends Relation {
+  #options;
+  #throughThunk;
+  constructor(relatedThunk, throughThunk, options = {}) {
+    super("hasManyThrough", relatedThunk);
+    this.#throughThunk = throughThunk;
+    this.#options = options;
+  }
+  get foreignKey() {
+    return this.#options.foreignKey ?? guessForeignKey(resolve2(this.#throughThunk));
+  }
+  get localKey() {
+    return this.#options.localKey ?? "id";
+  }
+  get throughModelClass() {
+    return resolve2(this.#throughThunk);
+  }
+  get throughForeignKey() {
+    return this.#options.throughForeignKey ?? guessForeignKey(this.relatedModelClass);
+  }
+  get throughLocalKey() {
+    return this.#options.throughLocalKey ?? guessForeignKey(this.throughModelClass);
+  }
+  query(parent) {
+    const parentKey = parent.get(this.localKey);
+    const peta = this.relatedModelClass.peta;
+    if (!peta)
+      return this.relatedModelClass.query();
+    const throughTable = this.throughModelClass.table;
+    const _relatedTable = this.relatedModelClass.table;
+    const subquery = peta.kysely.selectFrom(throughTable).select(this.throughForeignKey).where(this.foreignKey, "=", parentKey);
+    return this.relatedModelClass.query().whereIn("id", subquery);
+  }
+  addEagerConstraints(query, models) {
+    const keys = models.map((m) => m.get(this.localKey)).filter((k) => k != null);
+    if (keys.length === 0) {
+      query.whereIn("id", []);
+      return;
+    }
+    const throughTable = this.throughModelClass.table;
+    const relatedTable = this.relatedModelClass.table;
+    query.innerJoin(throughTable, `${throughTable}.${this.throughForeignKey}`, `${relatedTable}.${this.localKey}`);
+    query.whereIn(`${throughTable}.${this.foreignKey}`, keys);
+  }
+  match(models, results, relationName) {
+    const _throughTable = this.throughModelClass.table;
+    const grouped = groupByArray(results, `_through_${this.foreignKey}`);
+    for (const model of models) {
+      const key = String(model.get(this.localKey));
+      model.$setRelation(relationName, grouped[key] ?? []);
+    }
+  }
+  async getResults(parent) {
+    const parentKey = parent.get(this.localKey);
+    const peta = this.relatedModelClass.peta;
+    if (!peta)
+      return [];
+    const throughTable = this.throughModelClass.table;
+    const rows = await peta.kysely.selectFrom(throughTable).select(this.throughForeignKey).where(this.foreignKey, "=", parentKey).execute();
+    const ids = rows.map((r) => r[this.throughForeignKey]).filter(Boolean);
+    if (ids.length === 0)
+      return [];
+    return await this.relatedModelClass.query().whereIn("id", ids).execute();
+  }
+}
+function snakeCase(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1).replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
+}
+
+export { isString, isNumber, isBoolean, isNull, isDate, isBigInt, getLast, freeze, IdentifierNode, CreateTableNode, AliasNode, isOperationNodeSource, OperatorNode, RawNode, parseStringReference, ValueNode, parseValueExpression, ParensNode, preventAwait, InsertQueryNode, MergeQueryNode, QueryNode, createQueryId, WithSchemaPlugin, NOOP_QUERY_EXECUTOR, SetOperationNode, parseTable, CreateViewNode, isModelClass, Peta, HasMany, BelongsTo, HasOne, ManyToMany, HasManyThrough };

package/dist/index.js

@@ -1,7 +1,12 @@
 // @bun
 import {
+  BelongsTo,
+  HasMany,
+  HasManyThrough,
+  HasOne,
+  ManyToMany,
   Peta
-} from "./index-qwps5bne.js";
+} from "./index-gacxptb4.js";
 import {
   ArkTypeSchemaConfig,
   Collection,
@@ -609,291 +614,6 @@ class Model {
     };
   }
 }
-// src/relations/relation.ts
-var thunkCache = new WeakMap;
-function resolve(thunk) {
-  let cls = thunkCache.get(thunk);
-  if (!cls) {
-    cls = thunk();
-    thunkCache.set(thunk, cls);
-  }
-  return cls;
-}
-function guessForeignKey(modelClass) {
-  const table = modelClass.table;
-  const singular = table.endsWith("s") ? table.slice(0, -1) : table;
-  return `${singular}Id`;
-}
-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;
-}
-
-class Relation {
-  type;
-  #relatedThunk;
-  constructor(type, relatedThunk) {
-    this.type = type;
-    this.#relatedThunk = relatedThunk;
-  }
-  get relatedModelClass() {
-    return resolve(this.#relatedThunk);
-  }
-}
-
-class HasMany extends Relation {
-  #options;
-  constructor(relatedThunk, options = {}) {
-    super("hasMany", relatedThunk);
-    this.#options = options;
-  }
-  get foreignKey() {
-    return this.#options.foreignKey ?? guessForeignKey(this.relatedModelClass);
-  }
-  get localKey() {
-    return this.#options.localKey ?? "id";
-  }
-  query(parent) {
-    return this.relatedModelClass.query().where(this.foreignKey, "=", parent.get(this.localKey));
-  }
-  addEagerConstraints(query, models) {
-    const keys = models.map((m) => m.get(this.localKey)).filter((k) => k != null);
-    if (keys.length > 0) {
-      query.whereIn(this.foreignKey, keys);
-    }
-  }
-  match(models, results, relationName) {
-    const grouped = groupByArray(results, this.foreignKey);
-    for (const model of models) {
-      const key = String(model.get(this.localKey));
-      model.$setRelation(relationName, grouped[key] ?? []);
-    }
-  }
-  async getResults(parent) {
-    return await this.query(parent).execute();
-  }
-}
-
-class BelongsTo extends Relation {
-  #options;
-  constructor(relatedThunk, options = {}) {
-    super("belongsTo", relatedThunk);
-    this.#options = options;
-  }
-  get foreignKey() {
-    return this.#options.foreignKey ?? guessForeignKey(this.relatedModelClass);
-  }
-  get localKey() {
-    return this.#options.localKey ?? "id";
-  }
-  query(parent) {
-    return this.relatedModelClass.query().where(this.localKey, "=", parent.get(this.foreignKey));
-  }
-  addEagerConstraints(query, models) {
-    const keys = models.map((m) => m.get(this.foreignKey)).filter((k) => k != null);
-    if (keys.length > 0) {
-      query.whereIn(this.localKey, keys);
-    }
-  }
-  match(models, results, relationName) {
-    const grouped = groupByArray(results, this.localKey);
-    for (const model of models) {
-      const key = String(model.get(this.foreignKey));
-      model.$setRelation(relationName, grouped[key]?.[0] ?? null);
-    }
-  }
-  async getResults(parent) {
-    return await this.query(parent).executeTakeFirst() ?? null;
-  }
-}
-
-class HasOne extends Relation {
-  #options;
-  constructor(relatedThunk, options = {}) {
-    super("hasOne", relatedThunk);
-    this.#options = options;
-  }
-  get foreignKey() {
-    return this.#options.foreignKey ?? guessForeignKey(this.relatedModelClass);
-  }
-  get localKey() {
-    return this.#options.localKey ?? "id";
-  }
-  query(parent) {
-    return this.relatedModelClass.query().where(this.foreignKey, "=", parent.get(this.localKey));
-  }
-  addEagerConstraints(query, models) {
-    const keys = models.map((m) => m.get(this.localKey)).filter((k) => k != null);
-    if (keys.length > 0) {
-      query.whereIn(this.foreignKey, keys);
-    }
-  }
-  match(models, results, relationName) {
-    const grouped = groupByArray(results, this.foreignKey);
-    for (const model of models) {
-      const key = String(model.get(this.localKey));
-      model.$setRelation(relationName, grouped[key]?.[0] ?? null);
-    }
-  }
-  async getResults(parent) {
-    return await this.query(parent).executeTakeFirst() ?? null;
-  }
-}
-
-class ManyToMany extends Relation {
-  #options;
-  #pivotExtras;
-  constructor(relatedThunk, options) {
-    super("manyToMany", relatedThunk);
-    this.#options = options;
-    this.#pivotExtras = options.pivotExtras ?? [];
-  }
-  get foreignKey() {
-    return this.#options.foreignKey ?? guessForeignKey(this.relatedModelClass);
-  }
-  get localKey() {
-    return this.#options.localKey ?? "id";
-  }
-  get throughTable() {
-    return this.#options.through;
-  }
-  get foreignPivotKey() {
-    return this.#options.foreignPivotKey ?? snakeCase(this.foreignKey);
-  }
-  get relatedPivotKey() {
-    return this.#options.relatedPivotKey ?? snakeCase(guessForeignKey(this.relatedModelClass));
-  }
-  #hasExtras() {
-    return this.#pivotExtras.length > 0;
-  }
-  query(parent) {
-    const parentKey = parent.get(this.localKey);
-    const peta = this.relatedModelClass.peta;
-    if (!peta)
-      return this.relatedModelClass.query();
-    if (this.#hasExtras()) {
-      const _relatedTable = this.relatedModelClass.table;
-      const peta2 = this.relatedModelClass.peta;
-      if (!peta2)
-        return this.relatedModelClass.query();
-      const subQb = peta2.kysely.selectFrom(this.throughTable).select(this.relatedPivotKey).where(this.foreignPivotKey, "=", parentKey);
-      return this.relatedModelClass.query().whereIn("id", subQb);
-    }
-    const subquery = peta.kysely.selectFrom(this.throughTable).select(this.relatedPivotKey).where(this.foreignPivotKey, "=", parentKey);
-    return this.relatedModelClass.query().whereIn("id", subquery);
-  }
-  addEagerConstraints(query, models) {
-    const keys = models.map((m) => m.get(this.localKey)).filter((k) => k != null);
-    if (keys.length === 0) {
-      query.whereIn("id", []);
-      return;
-    }
-    const relatedTable = this.relatedModelClass.table;
-    query.innerJoin(this.throughTable, `${this.throughTable}.${this.relatedPivotKey}`, `${relatedTable}.${this.localKey}`);
-    query.whereIn(`${this.throughTable}.${this.foreignPivotKey}`, keys);
-  }
-  match(models, results, relationName) {
-    const grouped = groupByArray(results, `_pivot_${this.foreignPivotKey}`);
-    for (const model of models) {
-      const key = String(model.get(this.localKey));
-      const items = grouped[key] ?? [];
-      for (const item of items) {
-        const pivotData = {};
-        for (const ek of Object.keys(item.attributes ?? {})) {
-          if (ek.startsWith("_pivot_")) {
-            pivotData[ek.slice(7)] = item.get(ek);
-          }
-        }
-        if (Object.keys(pivotData).length > 0) {
-          item.$setRelation("_pivot", pivotData);
-        }
-      }
-      model.$setRelation(relationName, items);
-    }
-  }
-  async getResults(parent) {
-    return await this.query(parent).execute();
-  }
-}
-
-class HasManyThrough extends Relation {
-  #options;
-  #throughThunk;
-  constructor(relatedThunk, throughThunk, options = {}) {
-    super("hasManyThrough", relatedThunk);
-    this.#throughThunk = throughThunk;
-    this.#options = options;
-  }
-  get foreignKey() {
-    return this.#options.foreignKey ?? guessForeignKey(resolve(this.#throughThunk));
-  }
-  get localKey() {
-    return this.#options.localKey ?? "id";
-  }
-  get throughModelClass() {
-    return resolve(this.#throughThunk);
-  }
-  get throughForeignKey() {
-    return this.#options.throughForeignKey ?? guessForeignKey(this.relatedModelClass);
-  }
-  get throughLocalKey() {
-    return this.#options.throughLocalKey ?? guessForeignKey(this.throughModelClass);
-  }
-  query(parent) {
-    const parentKey = parent.get(this.localKey);
-    const peta = this.relatedModelClass.peta;
-    if (!peta)
-      return this.relatedModelClass.query();
-    const throughTable = this.throughModelClass.table;
-    const _relatedTable = this.relatedModelClass.table;
-    const subquery = peta.kysely.selectFrom(throughTable).select(this.throughForeignKey).where(this.foreignKey, "=", parentKey);
-    return this.relatedModelClass.query().whereIn("id", subquery);
-  }
-  addEagerConstraints(query, models) {
-    const keys = models.map((m) => m.get(this.localKey)).filter((k) => k != null);
-    if (keys.length === 0) {
-      query.whereIn("id", []);
-      return;
-    }
-    const throughTable = this.throughModelClass.table;
-    const relatedTable = this.relatedModelClass.table;
-    query.innerJoin(throughTable, `${throughTable}.${this.throughForeignKey}`, `${relatedTable}.${this.localKey}`);
-    query.whereIn(`${throughTable}.${this.foreignKey}`, keys);
-  }
-  match(models, results, relationName) {
-    const _throughTable = this.throughModelClass.table;
-    const grouped = groupByArray(results, `_through_${this.foreignKey}`);
-    for (const model of models) {
-      const key = String(model.get(this.localKey));
-      model.$setRelation(relationName, grouped[key] ?? []);
-    }
-  }
-  async getResults(parent) {
-    const parentKey = parent.get(this.localKey);
-    const peta = this.relatedModelClass.peta;
-    if (!peta)
-      return [];
-    const throughTable = this.throughModelClass.table;
-    const rows = await peta.kysely.selectFrom(throughTable).select(this.throughForeignKey).where(this.foreignKey, "=", parentKey).execute();
-    const ids = rows.map((r) => r[this.throughForeignKey]).filter(Boolean);
-    if (ids.length === 0)
-      return [];
-    return await this.relatedModelClass.query().whereIn("id", ids).execute();
-  }
-}
-function snakeCase(str) {
-  return str.charAt(0).toLowerCase() + str.slice(1).replace(/[A-Z]/g, (c) => `_${c.toLowerCase()}`);
-}
-
 // src/relations/morph.ts
 class MorphTo extends BelongsTo {
   morphType;

package/dist/migrations/cli.js

@@ -4,8 +4,8 @@ import {
   MigrationRunner,
   loadConfig,
   loadMigrationFiles
-} from "../index-zth6eamb.js";
-import"../index-qwps5bne.js";
+} from "../index-bv1vk6ec.js";
+import"../index-gacxptb4.js";
 import {
   __export
 } from "../index-k18nf2r7.js";

package/dist/migrations/generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/migrations/generator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAEhD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,qBAAa,kBAAkB;;IAC7B,wBAAwB,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,GAAE,gBAAqB,GAAG,MAAM;CAqIlG"}
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/migrations/generator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAA;AAGhD,MAAM,WAAW,gBAAgB;IAC/B,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,qBAAa,kBAAkB;;IAC7B,wBAAwB,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,UAAU,CAAC,EAAE,OAAO,GAAE,gBAAqB,GAAG,MAAM;CAyJlG"}

package/dist/migrations/index.js

@@ -5,8 +5,8 @@ import {
   defineConfig,
   loadConfig,
   loadMigrationFiles
-} from "../index-zth6eamb.js";
-import"../index-qwps5bne.js";
+} from "../index-bv1vk6ec.js";
+import"../index-gacxptb4.js";
 import"../index-k18nf2r7.js";
 export {
   loadMigrationFiles,

package/package.json

@@ -2,7 +2,7 @@
   "name": "peta-orm",
   "type": "module",
   "private": false,
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "ORM for Bun, built on Kysely",
   "license": "MIT",
   "module": "src/index.ts",