@getstrata/core 0.5.100 → 0.7.3

package/dist/entries/database/model.js

@@ -23,11 +23,12 @@ function pivotTableName(leftTable, rightTable) {
 }
 
 // ../../src/core/database/query.ts
+import { currentSqlDialect } from "@getstrata/core/database/dialect";
 function quoteIdentifier(identifier) {
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
-    throw new Error(`Invalid SQL identifier: ${identifier}`);
-  }
-  return `"${identifier}"`;
+  return currentSqlDialect().quoteIdentifier(identifier);
+}
+function returningSuffix(columns) {
+  return currentSqlDialect().returningClause(columns);
 }
 function qualifyColumn(tableName, column) {
   return `${quoteIdentifier(tableName)}.${quoteIdentifier(column)}`;
@@ -57,7 +58,7 @@ function isQueryOperator(value) {
 }
 function pushParam(values, value) {
   values.push(value);
-  return `$${values.length}`;
+  return currentSqlDialect().placeholder(values.length);
 }
 function buildInClause(column, values, params) {
   if (values.length === 0) {
@@ -97,9 +98,12 @@ function buildOperatorClauses(column, operator, params) {
     clauses.push(`${column} <= ${pushParam(params, operator.lte)}`);
   }
   if (operator.ilike !== undefined) {
-    clauses.push(`${column} ILIKE ${pushParam(params, operator.ilike)}`);
+    clauses.push(`${column} ${currentSqlDialect().ilikeOperator()} ${pushParam(params, operator.ilike)}`);
   }
   if (operator.tsMatch !== undefined) {
+    if (currentSqlDialect().driver !== "pgsql") {
+      throw new Error("Full-text search (tsMatch) is only available on PostgreSQL.");
+    }
     clauses.push(`${column} @@ plainto_tsquery('english', ${pushParam(params, operator.tsMatch)})`);
   }
   return clauses;
@@ -298,7 +302,7 @@ function buildSelectList(table, select, params = []) {
       return item.as ? `${column2} AS ${quoteIdentifier(item.as)}` : column2;
     }
     if (item.kind === "literalText") {
-      return `${pushParam(params, item.value)}::text AS ${quoteIdentifier(item.as)}`;
+      return `${currentSqlDialect().castToText(pushParam(params, item.value))} AS ${quoteIdentifier(item.as)}`;
     }
     const column = qualifyColumn(item.table, item.column);
     const placeholder = pushParam(params, item.query);
@@ -390,7 +394,7 @@ function buildInsertQuery(table, values) {
   const placeholders = entries.map(([, value]) => pushParam(params, value)).join(", ");
   const returningColumns = buildReturningColumns(table);
   return {
-    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders}) RETURNING ${returningColumns}`,
+    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${returningSuffix(returningColumns)}`,
     params
   };
 }
@@ -409,7 +413,7 @@ function buildUpdateQuery(table, id, changes) {
   appendSoftDeleteScope(table, {}, scopeClauses);
   const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
   return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${setClause} WHERE ${quoteIdentifier(table.primaryKey)} = ${primaryKeyPlaceholder}${scopeSuffix} RETURNING ${returningColumns}`,
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${setClause} WHERE ${quoteIdentifier(table.primaryKey)} = ${primaryKeyPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
     params
   };
 }
@@ -422,9 +426,12 @@ function buildSoftDeleteByIdQuery(table, id, deletedAt) {
   const scopeClauses = [];
   appendSoftDeleteScope(table, {}, scopeClauses);
   const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
+  const params = [];
+  const deletedAtPlaceholder = pushParam(params, deletedAt);
+  const idPlaceholder = pushParam(params, id);
   return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = $1 WHERE ${quoteIdentifier(table.primaryKey)} = $2${scopeSuffix} RETURNING ${returningColumns}`,
-    params: [deletedAt, id]
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
+    params
   };
 }
 function buildRestoreByIdQuery(table, id) {
@@ -433,15 +440,21 @@ function buildRestoreByIdQuery(table, id) {
     throw new Error(`Table ${table.name} does not support soft deletes.`);
   }
   const returningColumns = buildReturningColumns(table);
+  const params = [];
+  const deletedAtPlaceholder = pushParam(params, null);
+  const idPlaceholder = pushParam(params, id);
   return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = $1 WHERE ${quoteIdentifier(table.primaryKey)} = $2 AND ${qualifyColumn(table.name, deletedAtColumn)} IS NOT NULL RETURNING ${returningColumns}`,
-    params: [null, id]
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder} AND ${qualifyColumn(table.name, deletedAtColumn)} IS NOT NULL${returningSuffix(returningColumns)}`,
+    params
   };
 }
 function buildDeleteByIdQuery(table, id) {
+  const params = [];
+  const idPlaceholder = pushParam(params, id);
+  const returning = returningSuffix(`${quoteIdentifier(table.primaryKey)} AS ${quoteIdentifier("deleted_id")}`);
   return {
-    text: `DELETE FROM ${quoteIdentifier(table.name)} WHERE ${quoteIdentifier(table.primaryKey)} = $1 RETURNING ${quoteIdentifier(table.primaryKey)} AS ${quoteIdentifier("deleted_id")}`,
-    params: [id]
+    text: `DELETE FROM ${quoteIdentifier(table.name)} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${returning}`,
+    params
   };
 }
 
@@ -547,11 +560,7 @@ class HasManyRelationQuery {
     return this.create(related);
   }
   async createMany(records) {
-    const created = [];
-    for (const attributes of records) {
-      created.push(await this.create(attributes));
-    }
-    return created;
+    return Promise.all(records.map((attributes) => this.create(attributes)));
   }
 }
 
@@ -775,7 +784,8 @@ class BelongsToManyRelationQuery {
       return;
     }
     const list = Array.isArray(ids) ? ids : [ids];
-    await this.connection().unsafe(`DELETE FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1 AND ${String(this.relation.relatedPivotKey)} = ANY($2)`, [parentId, list]);
+    const placeholders = list.map((_, index) => `$${index + 2}`).join(", ");
+    await this.connection().unsafe(`DELETE FROM ${this.relation.pivotTable} WHERE ${String(this.relation.foreignPivotKey)} = $1 AND ${String(this.relation.relatedPivotKey)} IN (${placeholders})`, [parentId, ...list]);
   }
   async sync(ids) {
     await this.detach();
@@ -957,6 +967,65 @@ class MorphToRelationQuery {
   }
 }
 
+class HasManyThroughRelationQuery {
+  parent;
+  related;
+  relation;
+  kind = "hasManyThrough";
+  extraWhere = {};
+  extraOptions = {};
+  constructor(parent, related, relation) {
+    this.parent = parent;
+    this.related = related;
+    this.relation = relation;
+  }
+  where(where) {
+    this.extraWhere = { ...this.extraWhere, ...where };
+    return this;
+  }
+  orderBy(orderBy) {
+    this.extraOptions = { ...this.extraOptions, orderBy };
+    return this;
+  }
+  limit(limit) {
+    this.extraOptions = { ...this.extraOptions, limit };
+    return this;
+  }
+  applyEagerLoad(query, alias) {
+    query.withHasManyThrough(alias, this.relation, this.related.repository(), this.extraOptions);
+  }
+  hydrateEager(row, alias) {
+    const value = row[alias] ?? [];
+    const rows = Array.isArray(value) ? value : [];
+    return rows.map((item) => this.related.newFromRecord(item));
+  }
+  toExistsClause(parentTable) {
+    const farTable = this.related.repository().getTable().name;
+    const extra = buildAdvancedWhereClause(farTable, this.extraWhere, [], []);
+    const extraSql = extra.clause.replace(/^ WHERE /, "");
+    const sql = `SELECT 1 FROM ${quoteIdentifier(farTable)} INNER JOIN ${quoteIdentifier(this.relation.throughTable)} ON ${qualifyColumn(this.relation.throughTable, this.relation.secondLocalKey)} = ${qualifyColumn(farTable, this.relation.secondKey)} WHERE ${qualifyColumn(this.relation.throughTable, this.relation.firstKey)} = ${qualifyColumn(parentTable, this.relation.localKey)}${extraSql ? ` AND ${extraSql}` : ""}`;
+    return { sql, params: extra.params };
+  }
+  async get() {
+    const rows = await this.related.repository().withConnection(this.parent.getRepository().getConnection()).findHasManyThrough(this.parent.get(this.relation.localKey), this.relation, {
+      ...this.extraOptions,
+      where: this.extraWhere
+    });
+    return rows.map((row) => this.related.newFromRecord(row));
+  }
+  async first() {
+    const rows = await this.limit(1).get();
+    return rows[0] ?? null;
+  }
+  async count() {
+    const rows = await this.get();
+    return rows.length;
+  }
+  then(onfulfilled, onrejected) {
+    return thenGet(() => this.get(), onfulfilled, onrejected);
+  }
+}
+
 // ../../src/core/database/relationships.ts
 function hasMany(definition) {
   return {
@@ -976,6 +1045,13 @@ function belongsTo(definition) {
     ...definition
   };
 }
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
 function belongsToMany(definition) {
   return {
     type: "belongsToMany",
@@ -997,6 +1073,19 @@ function relationMatchKey(value) {
   }
   return String(value);
 }
+var relationLookupCache = new WeakMap;
+function indexedRelationLookup(map) {
+  const cached = relationLookupCache.get(map);
+  if (cached) {
+    return cached;
+  }
+  const indexed = new Map;
+  for (const [existing, value] of map) {
+    indexed.set(relationMatchKey(existing), value);
+  }
+  relationLookupCache.set(map, indexed);
+  return indexed;
+}
 function getByRelationKey(map, key) {
   if (map.has(key)) {
     return map.get(key);
@@ -1005,12 +1094,7 @@ function getByRelationKey(map, key) {
   if (want === "") {
     return;
   }
-  for (const [existing, value] of map) {
-    if (relationMatchKey(existing) === want) {
-      return value;
-    }
-  }
-  return;
+  return indexedRelationLookup(map).get(want);
 }
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
@@ -1149,6 +1233,26 @@ function indexMorphOneRelation(parents, children, relation) {
   }
   return result;
 }
+function indexHasManyThroughRelation(parents, children, relation) {
+  const throughKey = relation.throughParentKey ?? "__through_parent_id";
+  const grouped = new Map;
+  for (const child of children) {
+    const key = relationMatchKey(child[throughKey]);
+    if (key === "") {
+      continue;
+    }
+    const existing = grouped.get(key) ?? [];
+    const { [throughKey]: _through, ...far } = child;
+    existing.push(far);
+    grouped.set(key, existing);
+  }
+  const result = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    result.set(parent[relation.localKey], grouped.get(key) ?? []);
+  }
+  return result;
+}
 function indexMorphToRelation(children, parentsByType, relation) {
   const result = new Map;
   for (const child of children) {
@@ -1205,12 +1309,12 @@ async function eagerLoadOnModels(models, paths) {
     }
     grouped.set(head, existing);
   }
-  for (const [head, nested] of grouped) {
+  await Promise.all([...grouped.entries()].map(async ([head, nested]) => {
     const unloaded = models.filter((model) => model.loaded(head) === undefined);
     if (unloaded.length > 0) {
       const first = unloaded[0];
       if (!first) {
-        continue;
+        return;
       }
       const method = first[head];
       if (typeof method !== "function") {
@@ -1226,14 +1330,14 @@ async function eagerLoadOnModels(models, paths) {
       }
     }
     if (nested.length === 0) {
-      continue;
+      return;
     }
     const children = models.flatMap((model) => {
       const loaded = model.loaded(head);
       return Array.isArray(loaded) ? loaded : loaded ? [loaded] : [];
     });
     await eagerLoadOnModels(children.filter(isLoadableModel), nested);
-  }
+  }));
 }
 async function loadNested(model, path) {
   await eagerLoadOnModels([model], [path]);
@@ -1493,18 +1597,30 @@ class ModelQuery {
     this.query.withMorphTo(...args);
     return this;
   }
+  withHasManyThrough(...args) {
+    this.query.withHasManyThrough(...args);
+    return this;
+  }
+  withTrashed() {
+    this.query.withTrashed();
+    return this;
+  }
+  onlyTrashed() {
+    this.query.onlyTrashed();
+    return this;
+  }
   async get() {
     const statics = modelStatics(this.modelClass);
     const rows = await this.query.get();
     const models = [];
     for (const row of rows) {
       const model = statics.newFromRecord(row, true);
-      await runObservers(model, "retrieved");
       for (const { name, relationQuery } of this.eager) {
         model.setLoaded(name, relationQuery.hydrateEager(row, name));
       }
       models.push(model);
     }
+    await Promise.all(models.map((model) => runObservers(model, "retrieved")));
     const nested = this.eager.filter((item) => item.path.includes(".")).map((item) => item.path);
     await eagerLoadOnModels(models.filter(isLoadableModel), nested);
     return models;
@@ -1700,6 +1816,31 @@ class Model {
   static with(...relations) {
     return Model.query.call(this).with(...relations);
   }
+  static withTrashed() {
+    return Model.query.call(this).withTrashed();
+  }
+  static onlyTrashed() {
+    return Model.query.call(this).onlyTrashed();
+  }
+  static async chunk(count, callback) {
+    const statics = modelStatics(this);
+    ensureBooted(this);
+    await resolveModelRepository(this).chunk(count, async (rows) => {
+      return await callback(rows.map((row) => statics.newFromRecord(row, true)));
+    });
+  }
+  static async cursorPaginate(options) {
+    const statics = modelStatics(this);
+    ensureBooted(this);
+    const page = await resolveModelRepository(this).cursorPaginate({
+      perPage: options.perPage,
+      cursor: options.cursor
+    });
+    return {
+      data: page.data.map((row) => statics.newFromRecord(row, true)),
+      meta: page.meta
+    };
+  }
   static whereHas(name, constrain) {
     return Model.query.call(this).whereHas(name, constrain);
   }
@@ -1884,6 +2025,20 @@ class Model {
       ownerKey: ownerKey ?? relatedTable.primaryKey
     }));
   }
+  hasManyThrough(related, through, firstKey, secondKey, localKey, secondLocalKey) {
+    const table = this.repository.getTable();
+    const relatedClass = resolveRelated(related);
+    const throughClass = resolveRelated(through);
+    const throughTable = throughClass.repository().getTable();
+    return new HasManyThroughRelationQuery(this, relatedClass, hasManyThrough({
+      name: relatedClass.repository().getTable().name,
+      throughTable: throughTable.name,
+      localKey: localKey ?? table.primaryKey,
+      firstKey: firstKey ?? foreignKeyFromTable(table.name),
+      secondLocalKey: secondLocalKey ?? throughTable.primaryKey,
+      secondKey: secondKey ?? foreignKeyFromTable(throughTable.name)
+    }));
+  }
   belongsToMany(related, pivotTable, foreignPivotKey, relatedPivotKey) {
     const table = this.repository.getTable();
     const relatedClass = resolveRelated(related);
@@ -1922,7 +2077,7 @@ class Model {
   morphTo(relatedByType, morphName, typeKey, idKey) {
     const resolvedName = morphName ?? inferRelationMethodName("morphTo");
     if (!resolvedName) {
-      throw new Error(`${this.constructor.name}.morphTo() needs an explicit morph name (Laravel infers it from the relation method).`);
+      throw new Error(`${this.constructor.name}.morphTo() needs an explicit morph name (the calling method name is not available at runtime).`);
     }
     const resolvedMap = Object.fromEntries(Object.entries(relatedByType).map(([type, related]) => [type, resolveRelated(related)]));
     return new MorphToRelationQuery(this, resolvedMap, morphTo({
@@ -1975,6 +2130,7 @@ export {
   BelongsToManyRelationQuery,
   BelongsToRelationQuery,
   HasManyRelationQuery,
+  HasManyThroughRelationQuery,
   HasOneRelationQuery,
   Model,
   ModelQuery,

package/dist/entries/database/mysqlConnection.js

@@ -0,0 +1,35 @@
+// @bun
+// ../../src/core/database/mysqlConnection.ts
+import mysql from "mysql2/promise";
+function rowsFromResult(result) {
+  if (Array.isArray(result)) {
+    return result;
+  }
+  if (result && typeof result === "object") {
+    return [result];
+  }
+  return [];
+}
+function createMysqlConnectionFromPool(pool) {
+  return {
+    async unsafe(query, params = []) {
+      const [result] = await pool.execute(query, [...params]);
+      return rowsFromResult(result);
+    },
+    async close() {
+      if (typeof pool.end === "function") {
+        await pool.end();
+      }
+    }
+  };
+}
+function createMysqlConnection(url) {
+  if (!url.trim()) {
+    throw new Error("MYSQL_URL is not configured. Set url before creating a MySQL pool.");
+  }
+  return createMysqlConnectionFromPool(mysql.createPool(url));
+}
+export {
+  createMysqlConnection,
+  createMysqlConnectionFromPool
+};

package/dist/entries/database/namedConnections.js

@@ -0,0 +1 @@
+export * from "../../index.js";

package/dist/entries/database/query.js

@@ -1,10 +1,11 @@
 // @bun
 // ../../src/core/database/query.ts
+import { currentSqlDialect } from "@getstrata/core/database/dialect";
 function quoteIdentifier(identifier) {
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(identifier)) {
-    throw new Error(`Invalid SQL identifier: ${identifier}`);
-  }
-  return `"${identifier}"`;
+  return currentSqlDialect().quoteIdentifier(identifier);
+}
+function returningSuffix(columns) {
+  return currentSqlDialect().returningClause(columns);
 }
 function qualifyColumn(tableName, column) {
   return `${quoteIdentifier(tableName)}.${quoteIdentifier(column)}`;
@@ -34,7 +35,7 @@ function isQueryOperator(value) {
 }
 function pushParam(values, value) {
   values.push(value);
-  return `$${values.length}`;
+  return currentSqlDialect().placeholder(values.length);
 }
 function buildInClause(column, values, params) {
   if (values.length === 0) {
@@ -74,9 +75,12 @@ function buildOperatorClauses(column, operator, params) {
     clauses.push(`${column} <= ${pushParam(params, operator.lte)}`);
   }
   if (operator.ilike !== undefined) {
-    clauses.push(`${column} ILIKE ${pushParam(params, operator.ilike)}`);
+    clauses.push(`${column} ${currentSqlDialect().ilikeOperator()} ${pushParam(params, operator.ilike)}`);
   }
   if (operator.tsMatch !== undefined) {
+    if (currentSqlDialect().driver !== "pgsql") {
+      throw new Error("Full-text search (tsMatch) is only available on PostgreSQL.");
+    }
     clauses.push(`${column} @@ plainto_tsquery('english', ${pushParam(params, operator.tsMatch)})`);
   }
   return clauses;
@@ -275,7 +279,7 @@ function buildSelectList(table, select, params = []) {
       return item.as ? `${column2} AS ${quoteIdentifier(item.as)}` : column2;
     }
     if (item.kind === "literalText") {
-      return `${pushParam(params, item.value)}::text AS ${quoteIdentifier(item.as)}`;
+      return `${currentSqlDialect().castToText(pushParam(params, item.value))} AS ${quoteIdentifier(item.as)}`;
     }
     const column = qualifyColumn(item.table, item.column);
     const placeholder = pushParam(params, item.query);
@@ -367,7 +371,7 @@ function buildInsertQuery(table, values) {
   const placeholders = entries.map(([, value]) => pushParam(params, value)).join(", ");
   const returningColumns = buildReturningColumns(table);
   return {
-    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders}) RETURNING ${returningColumns}`,
+    text: `INSERT INTO ${quoteIdentifier(table.name)} (${columns}) VALUES (${placeholders})${returningSuffix(returningColumns)}`,
     params
   };
 }
@@ -386,7 +390,7 @@ function buildUpdateQuery(table, id, changes) {
   appendSoftDeleteScope(table, {}, scopeClauses);
   const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
   return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${setClause} WHERE ${quoteIdentifier(table.primaryKey)} = ${primaryKeyPlaceholder}${scopeSuffix} RETURNING ${returningColumns}`,
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${setClause} WHERE ${quoteIdentifier(table.primaryKey)} = ${primaryKeyPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
     params
   };
 }
@@ -399,9 +403,12 @@ function buildSoftDeleteByIdQuery(table, id, deletedAt) {
   const scopeClauses = [];
   appendSoftDeleteScope(table, {}, scopeClauses);
   const scopeSuffix = scopeClauses.length > 0 ? ` AND ${scopeClauses.join(" AND ")}` : "";
+  const params = [];
+  const deletedAtPlaceholder = pushParam(params, deletedAt);
+  const idPlaceholder = pushParam(params, id);
   return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = $1 WHERE ${quoteIdentifier(table.primaryKey)} = $2${scopeSuffix} RETURNING ${returningColumns}`,
-    params: [deletedAt, id]
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${scopeSuffix}${returningSuffix(returningColumns)}`,
+    params
   };
 }
 function buildRestoreByIdQuery(table, id) {
@@ -410,15 +417,21 @@ function buildRestoreByIdQuery(table, id) {
     throw new Error(`Table ${table.name} does not support soft deletes.`);
   }
   const returningColumns = buildReturningColumns(table);
+  const params = [];
+  const deletedAtPlaceholder = pushParam(params, null);
+  const idPlaceholder = pushParam(params, id);
   return {
-    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = $1 WHERE ${quoteIdentifier(table.primaryKey)} = $2 AND ${qualifyColumn(table.name, deletedAtColumn)} IS NOT NULL RETURNING ${returningColumns}`,
-    params: [null, id]
+    text: `UPDATE ${quoteIdentifier(table.name)} SET ${quoteIdentifier(deletedAtColumn)} = ${deletedAtPlaceholder} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder} AND ${qualifyColumn(table.name, deletedAtColumn)} IS NOT NULL${returningSuffix(returningColumns)}`,
+    params
   };
 }
 function buildDeleteByIdQuery(table, id) {
+  const params = [];
+  const idPlaceholder = pushParam(params, id);
+  const returning = returningSuffix(`${quoteIdentifier(table.primaryKey)} AS ${quoteIdentifier("deleted_id")}`);
   return {
-    text: `DELETE FROM ${quoteIdentifier(table.name)} WHERE ${quoteIdentifier(table.primaryKey)} = $1 RETURNING ${quoteIdentifier(table.primaryKey)} AS ${quoteIdentifier("deleted_id")}`,
-    params: [id]
+    text: `DELETE FROM ${quoteIdentifier(table.name)} WHERE ${quoteIdentifier(table.primaryKey)} = ${idPlaceholder}${returning}`,
+    params
   };
 }
 export {

package/dist/entries/database/relationships.js

@@ -18,6 +18,13 @@ function belongsTo(definition) {
     ...definition
   };
 }
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
 function belongsToMany(definition) {
   return {
     type: "belongsToMany",
@@ -39,6 +46,19 @@ function relationMatchKey(value) {
   }
   return String(value);
 }
+var relationLookupCache = new WeakMap;
+function indexedRelationLookup(map) {
+  const cached = relationLookupCache.get(map);
+  if (cached) {
+    return cached;
+  }
+  const indexed = new Map;
+  for (const [existing, value] of map) {
+    indexed.set(relationMatchKey(existing), value);
+  }
+  relationLookupCache.set(map, indexed);
+  return indexed;
+}
 function getByRelationKey(map, key) {
   if (map.has(key)) {
     return map.get(key);
@@ -47,12 +67,7 @@ function getByRelationKey(map, key) {
   if (want === "") {
     return;
   }
-  for (const [existing, value] of map) {
-    if (relationMatchKey(existing) === want) {
-      return value;
-    }
-  }
-  return;
+  return indexedRelationLookup(map).get(want);
 }
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
@@ -191,6 +206,26 @@ function indexMorphOneRelation(parents, children, relation) {
   }
   return result;
 }
+function indexHasManyThroughRelation(parents, children, relation) {
+  const throughKey = relation.throughParentKey ?? "__through_parent_id";
+  const grouped = new Map;
+  for (const child of children) {
+    const key = relationMatchKey(child[throughKey]);
+    if (key === "") {
+      continue;
+    }
+    const existing = grouped.get(key) ?? [];
+    const { [throughKey]: _through, ...far } = child;
+    existing.push(far);
+    grouped.set(key, existing);
+  }
+  const result = new Map;
+  for (const parent of parents) {
+    const key = relationMatchKey(parent[relation.localKey]);
+    result.set(parent[relation.localKey], grouped.get(key) ?? []);
+  }
+  return result;
+}
 function indexMorphToRelation(children, parentsByType, relation) {
   const result = new Map;
   for (const child of children) {
@@ -211,10 +246,12 @@ export {
   belongsToMany,
   getByRelationKey,
   hasMany,
+  hasManyThrough,
   hasOne,
   indexBelongsToManyRelation,
   indexBelongsToRelation,
   indexHasManyRelation,
+  indexHasManyThroughRelation,
   indexHasOneRelation,
   indexMorphManyRelation,
   indexMorphOneRelation,