@getstrata/core 0.5.99 → 0.5.101

package/dist/index.js

@@ -2078,32 +2078,80 @@ function belongsTo(definition) {
     ...definition
   };
 }
+function hasManyThrough(definition) {
+  return {
+    type: "hasManyThrough",
+    throughParentKey: "__through_parent_id",
+    ...definition
+  };
+}
 function belongsToMany(definition) {
   return {
     type: "belongsToMany",
     ...definition
   };
 }
+function relationMatchKey(value) {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  if (typeof value === "bigint") {
+    return value.toString();
+  }
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(value);
+  }
+  if (typeof value === "string" && /^-?\d+$/.test(value)) {
+    return BigInt(value).toString();
+  }
+  return String(value);
+}
+function getByRelationKey(map, key) {
+  if (map.has(key)) {
+    return map.get(key);
+  }
+  const want = relationMatchKey(key);
+  if (want === "") {
+    return;
+  }
+  for (const [existing, value] of map) {
+    if (relationMatchKey(existing) === want) {
+      return value;
+    }
+  }
+  return;
+}
 function indexHasManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
-    const key = child[relation.foreignKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.foreignKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexHasOneRelation(parents, children, relation) {
   const grouped = indexHasManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   return result;
@@ -2111,12 +2159,12 @@ function indexHasOneRelation(parents, children, relation) {
 function indexBelongsToRelation(children, parents, relation) {
   const parentsById = new Map;
   for (const parent of parents) {
-    parentsById.set(parent[relation.ownerKey], parent);
+    parentsById.set(relationMatchKey(parent[relation.ownerKey]), parent);
   }
   const result = new Map;
   for (const child of children) {
     const foreignKey = child[relation.foreignKey];
-    const parent = parentsById.get(foreignKey);
+    const parent = parentsById.get(relationMatchKey(foreignKey));
     if (parent) {
       result.set(foreignKey, parent);
     }
@@ -2126,23 +2174,33 @@ function indexBelongsToRelation(children, parents, relation) {
 function indexBelongsToManyRelation(parents, pivotRows, relatedRows, relation) {
   const relatedById = new Map;
   for (const related of relatedRows) {
-    relatedById.set(related[relation.relatedKey], related);
+    relatedById.set(relationMatchKey(related[relation.relatedKey]), related);
   }
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.parentKey], []);
+    const key = relationMatchKey(parent[relation.parentKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.parentKey]);
+    }
   }
   for (const pivot of pivotRows) {
-    const parentId = pivot[relation.foreignPivotKey];
-    const relatedId = pivot[relation.relatedPivotKey];
-    const group = groups.get(parentId);
-    const related = relatedById.get(relatedId);
+    const group = groups.get(relationMatchKey(pivot[relation.foreignPivotKey]));
+    const related = relatedById.get(relationMatchKey(pivot[relation.relatedPivotKey]));
     if (!group || !related) {
       continue;
     }
     group.push(related);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function morphMany(definition) {
   return {
@@ -2164,31 +2222,62 @@ function morphTo(definition) {
 }
 function indexMorphManyRelation(parents, children, relation) {
   const groups = new Map;
+  const originalKeys = new Map;
   for (const parent of parents) {
-    groups.set(parent[relation.localKey], []);
+    const key = relationMatchKey(parent[relation.localKey]);
+    if (!groups.has(key)) {
+      groups.set(key, []);
+      originalKeys.set(key, parent[relation.localKey]);
+    }
   }
   for (const child of children) {
     if (child[relation.morphTypeKey] !== relation.morphType) {
       continue;
     }
-    const key = child[relation.morphIdKey];
-    const group = groups.get(key);
+    const group = groups.get(relationMatchKey(child[relation.morphIdKey]));
     if (!group) {
       continue;
     }
     group.push(child);
   }
-  return groups;
+  const result = new Map;
+  for (const [key, group] of groups) {
+    const original = originalKeys.get(key);
+    if (original !== undefined) {
+      result.set(original, group);
+    }
+  }
+  return result;
 }
 function indexMorphOneRelation(parents, children, relation) {
   const grouped = indexMorphManyRelation(parents, children, relation);
   const result = new Map;
   for (const parent of parents) {
-    const matches = grouped.get(parent[relation.localKey]) ?? [];
+    const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
     result.set(parent[relation.localKey], matches[0]);
   }
   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) {
@@ -2197,7 +2286,7 @@ function indexMorphToRelation(children, parentsByType, relation) {
     if (!parents) {
       continue;
     }
-    const parent = parents.get(child[relation.morphIdKey]);
+    const parent = getByRelationKey(parents, child[relation.morphIdKey]);
     if (parent) {
       result.set(child[relation.morphIdKey], parent);
     }
@@ -2372,6 +2461,24 @@ class RepositoryQuery {
     });
     return this;
   }
+  withHasManyThrough(as, relation, farRepository, options = {}) {
+    this.eagerLoads.push({
+      kind: "hasManyThrough",
+      as,
+      relation,
+      repository: farRepository,
+      options
+    });
+    return this;
+  }
+  withTrashed() {
+    this.queryOptions = { ...this.queryOptions, withTrashed: true };
+    return this;
+  }
+  onlyTrashed() {
+    this.queryOptions = { ...this.queryOptions, onlyTrashed: true };
+    return this;
+  }
   async get() {
     const rows = await this.repository.findAll(this.buildOptions());
     return await this.attach(rows);
@@ -2435,7 +2542,7 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
         }));
         continue;
       }
@@ -2444,7 +2551,7 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphManyForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
         }));
         continue;
       }
@@ -2453,7 +2560,16 @@ class RepositoryQuery {
         const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadMorphOneForParents(rows, relation2, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.localKey])
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey])
+        }));
+        continue;
+      }
+      if (load.kind === "hasManyThrough") {
+        const relation2 = load.relation;
+        const grouped2 = await load.repository.withConnection(this.repository.getConnection()).loadHasManyThroughForParents(rows, relation2, load.options);
+        result = result.map((row) => ({
+          ...row,
+          [load.as]: getByRelationKey(grouped2, row[relation2.localKey]) ?? []
         }));
         continue;
       }
@@ -2462,7 +2578,7 @@ class RepositoryQuery {
         const grouped2 = await this.repository.loadBelongsToManyForParents(rows, relation2, load.repository, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.parentKey]) ?? []
+          [load.as]: getByRelationKey(grouped2, row[relation2.parentKey]) ?? []
         }));
         continue;
       }
@@ -2471,7 +2587,7 @@ class RepositoryQuery {
         const grouped2 = await this.repository.loadMorphToForChildren(rows, relation2, load.morphRepositories ?? new Map, load.options);
         result = result.map((row) => ({
           ...row,
-          [load.as]: grouped2.get(row[relation2.morphIdKey])
+          [load.as]: getByRelationKey(grouped2, row[relation2.morphIdKey])
         }));
         continue;
       }
@@ -2479,7 +2595,7 @@ class RepositoryQuery {
       const grouped = await this.repository.loadBelongsToForParents(rows, relation, load.repository, load.options);
       result = result.map((row) => ({
         ...row,
-        [load.as]: grouped.get(row[relation.foreignKey])
+        [load.as]: getByRelationKey(grouped, row[relation.foreignKey])
       }));
     }
     return result;
@@ -2745,6 +2861,55 @@ class BaseRepository {
     }, options);
     return indexHasManyRelation(parents, children, relation);
   }
+  async findHasManyThrough(parentId, relation, options = {}) {
+    const grouped = await this.loadHasManyThroughForParents([{ [relation.localKey]: parentId }], relation, options);
+    return getByRelationKey(grouped, parentId) ?? [];
+  }
+  async loadHasManyThroughForParents(parents, relation, options = {}) {
+    if (parents.length === 0) {
+      return indexHasManyThroughRelation(parents, [], relation);
+    }
+    const parentIds = [...new Set(parents.map((parent) => parent[relation.localKey]))];
+    const throughParentKey = relation.throughParentKey ?? "__through_parent_id";
+    const farTable = this.table.name;
+    const columns = this.table.columns.map((column) => `${qualifyColumn(farTable, column)}`).join(", ");
+    const placeholders = parentIds.map((_, index) => `$${index + 1}`).join(", ");
+    const { text: extraWhere, params: extraParams } = this.buildThroughWhere(options, parentIds.length);
+    const softDelete = this.throughSoftDeleteClause(options);
+    const sql = `SELECT ${columns}, ${qualifyColumn(relation.throughTable, relation.firstKey)} AS ${throughParentKey} FROM ${quoteIdentifier(farTable)} INNER JOIN ${quoteIdentifier(relation.throughTable)} ON ${qualifyColumn(relation.throughTable, relation.secondLocalKey)} = ${qualifyColumn(farTable, relation.secondKey)} WHERE ${qualifyColumn(relation.throughTable, relation.firstKey)} IN (${placeholders})${softDelete}${extraWhere}`;
+    const children = await this.connection.unsafe(sql, [
+      ...parentIds,
+      ...extraParams
+    ]);
+    return indexHasManyThroughRelation(parents, children, relation);
+  }
+  throughSoftDeleteClause(options) {
+    const column = resolveSoftDeleteColumn(this.table);
+    if (!column) {
+      return "";
+    }
+    const qualified = qualifyColumn(this.table.name, column);
+    if (options.onlyTrashed) {
+      return ` AND ${qualified} IS NOT NULL`;
+    }
+    if (options.withTrashed) {
+      return "";
+    }
+    return ` AND ${qualified} IS NULL`;
+  }
+  buildThroughWhere(options, paramOffset = 1) {
+    const where = options.where ?? {};
+    const entries = Object.entries(where);
+    if (entries.length === 0) {
+      return { text: "", params: [] };
+    }
+    const params = [];
+    const clauses = entries.map(([column, value], index) => {
+      params.push(value);
+      return `${qualifyColumn(this.table.name, column)} = $${paramOffset + index + 1}`;
+    });
+    return { text: ` AND ${clauses.join(" AND ")}`, params };
+  }
   async loadBelongsToForParents(children, relation, parentRepository, options = {}) {
     if (children.length === 0) {
       return new Map;
@@ -2770,7 +2935,7 @@ class BaseRepository {
     const grouped = await this.loadMorphManyForParents(parents, relation, options);
     const result = new Map;
     for (const parent of parents) {
-      const matches = grouped.get(parent[relation.localKey]) ?? [];
+      const matches = getByRelationKey(grouped, parent[relation.localKey]) ?? [];
       result.set(parent[relation.localKey], matches[0]);
     }
     return result;
@@ -2799,7 +2964,7 @@ class BaseRepository {
       }, options);
       const indexed = new Map;
       for (const parent of parents) {
-        indexed.set(parent[ownerKey], parent);
+        indexed.set(relationMatchKey(parent[ownerKey]), parent);
       }
       parentsByType.set(morphType, indexed);
     }
@@ -2810,7 +2975,8 @@ class BaseRepository {
       return indexBelongsToManyRelation(parents, [], [], relation);
     }
     const parentIds = [...new Set(parents.map((parent) => parent[relation.parentKey]))];
-    const pivotRows = await this.connection.unsafe(`SELECT * FROM ${relation.pivotTable} WHERE ${String(relation.foreignPivotKey)} = ANY($1)`, [parentIds]);
+    const placeholders = parentIds.map((_, index) => `$${index + 1}`).join(", ");
+    const pivotRows = await this.connection.unsafe(`SELECT * FROM ${relation.pivotTable} WHERE ${String(relation.foreignPivotKey)} IN (${placeholders})`, parentIds);
     if (pivotRows.length === 0) {
       return indexBelongsToManyRelation(parents, [], [], relation);
     }
@@ -3472,7 +3638,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();
@@ -3654,6 +3821,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/model.ts
 var modelRepositories = new WeakMap;
 var namedModels = new Map;
@@ -3982,6 +4208,18 @@ 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();
@@ -4189,6 +4427,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);
   }
@@ -4313,7 +4576,7 @@ class Model {
   }
   async loadHasMany(as, relation, childRepository, options = {}) {
     const grouped = await childRepository.withConnection(this.repository.getConnection()).loadHasManyForParents([this.attributes], relation, options);
-    const loaded = grouped.get(this.attributes[relation.localKey]) ?? [];
+    const loaded = getByRelationKey(grouped, this.attributes[relation.localKey]) ?? [];
     return Object.assign(this, { [as]: loaded });
   }
   async loadHasOne(as, relation, childRepository, options = {}) {
@@ -4323,7 +4586,7 @@ class Model {
   }
   async loadBelongsTo(as, relation, parentRepository, options = {}) {
     const grouped = await this.repository.loadBelongsToForParents([this.attributes], relation, parentRepository, options);
-    const loaded = grouped.get(this.attributes[relation.foreignKey]);
+    const loaded = getByRelationKey(grouped, this.attributes[relation.foreignKey]);
     return Object.assign(this, { [as]: loaded });
   }
   async loadBelongsToMany(as, relation, relatedRepository, options = {}) {
@@ -4343,7 +4606,7 @@ class Model {
       }
     });
     const grouped = indexBelongsToManyRelation([this.attributes], pivotRows, relatedRows, relation);
-    const loaded = grouped.get(parentId) ?? [];
+    const loaded = getByRelationKey(grouped, parentId) ?? [];
     return Object.assign(this, { [as]: loaded });
   }
   hasMany(related, foreignKey, localKey) {
@@ -4373,6 +4636,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);
@@ -8014,17 +8291,33 @@ async function resolveTenantForRequest(request) {
         if (Number.isInteger(parsedHeader) && parsedHeader > 0 && parsedHeader !== userTenantId) {
           throw new ForbiddenError("Tenant header does not match your account.");
         }
-        return await resolveTenant(userTenantId) ?? DEFAULT_TENANT;
+        const memberTenant = await resolveTenant(userTenantId);
+        if (memberTenant) {
+          return memberTenant;
+        }
+        return DEFAULT_TENANT;
       }
       if (Number.isInteger(parsedHeader) && parsedHeader > 0) {
-        return await resolveTenant(parsedHeader) ?? DEFAULT_TENANT;
+        const headerTenant = await resolveTenant(parsedHeader);
+        if (headerTenant) {
+          return headerTenant;
+        }
+        return DEFAULT_TENANT;
       }
-      return await resolveTenant(userTenantId) ?? DEFAULT_TENANT;
+      const adminTenant = await resolveTenant(userTenantId);
+      if (adminTenant) {
+        return adminTenant;
+      }
+      return DEFAULT_TENANT;
     }
   }
   const headerTenantId = Number.isInteger(parsedHeader) && parsedHeader > 0 ? parsedHeader : null;
   const tenantId = isPublicReadsEnabled() && headerTenantId !== null ? headerTenantId : DEFAULT_TENANT.id;
-  return await resolveTenant(tenantId) ?? DEFAULT_TENANT;
+  const guestTenant = await resolveTenant(tenantId);
+  if (guestTenant) {
+    return guestTenant;
+  }
+  return DEFAULT_TENANT;
 }
 function createTenantMiddleware() {
   return async (request, next) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@getstrata/core",
-  "version": "0.5.99",
+  "version": "0.5.101",
   "description": "Strata — Laravel-inspired Bun framework public API",
   "type": "module",
   "license": "MIT",