bun-query-builder 0.1.35 → 0.1.37

package/dist/bin/cli.js

@@ -15036,7 +15036,7 @@ function createQueryBuilder(state) {
         return ensureBuilt().values();
       },
       toParams() {
-        return ensureBuilt().values?.() ?? [];
+        return [...whereParams];
       },
       __rawState() {
         return { sql: reorderSelectClauses(text), params: [...whereParams] };
@@ -15133,265 +15133,247 @@ function createQueryBuilder(state) {
           throw new Error(`[query-builder] selectFromSub(...).${methodName}() is not supported. ` + `Apply ${methodName}() to the underlying subquery BEFORE passing it to selectFromSub, ` + `or use the regular selectFrom(...) builder. This previously silently returned without ` + `affecting the SQL, producing wrong results \u2014 see stacksjs/stacks#1862 #11.`);
         };
       }
-      const sql = _sql;
-      const q = _sql`SELECT * FROM (${sub.toSQL()}) AS ${_sql(alias)}`;
-      const base = {
-        distinct() {
-          const rest = String(q).replace(/^SELECT\s+/i, "");
-          const newQ = sql`SELECT DISTINCT ${sql``}${sql(rest)}`;
-          return createSubQueryBuilder(newQ);
-        },
-        distinctOn(...columns) {
-          const match = /^SELECT\s+(\S+)\s+FROM/i.exec(String(q));
-          const body = match ? `${match[1]} FROM` : String(q);
-          const newQ = sql`SELECT DISTINCT ON (${sql(columns)}) ${sql``}${sql(body)}`;
-          return createSubQueryBuilder(newQ);
-        },
-        selectRaw(fragment) {
-          const newQ = sql`${q} , ${fragment}`;
-          return createSubQueryBuilder(newQ);
-        },
-        where(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "WHERE");
-          return createSubQueryBuilder(newQ);
-        },
-        andWhere(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "AND");
-          return createSubQueryBuilder(newQ);
-        },
-        orWhere(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "OR");
-          return createSubQueryBuilder(newQ);
-        },
-        orderBy(column, direction = "asc") {
-          const dir = direction === "asc" ? "ASC" : "DESC";
-          const current = String(q);
-          const newQ = SQL_PATTERNS.ORDER_BY.test(current) ? sql.unsafe(`${current}, ${column} ${dir}`) : sql`${q} ORDER BY ${sql(column)} ${direction === "asc" ? sql`ASC` : sql`DESC`}`;
-          return createSubQueryBuilder(newQ);
-        },
-        limit(n) {
-          const current = String(q);
-          const newQ = SQL_PATTERNS.LIMIT.test(current) ? sql.unsafe(current.replace(SQL_PATTERNS.LIMIT, ` LIMIT ${n}`)) : sql`${q} LIMIT ${n}`;
-          return createSubQueryBuilder(newQ);
-        },
-        offset(n) {
-          const current = String(q);
-          const newQ = SQL_PATTERNS.OFFSET.test(current) ? sql.unsafe(current.replace(SQL_PATTERNS.OFFSET, ` OFFSET ${n}`)) : sql`${q} OFFSET ${n}`;
-          return createSubQueryBuilder(newQ);
-        },
-        toSQL() {
-          return makeExecutableQuery(q);
-        },
-        async execute() {
-          return runWithHooks(q, "select");
-        },
-        async executeTakeFirst() {
-          const rows = await runWithHooks(q, "select");
-          return Array.isArray(rows) ? rows[0] : rows;
-        },
-        async executeTakeFirstOrThrow() {
-          const rows = await runWithHooks(q, "select");
-          const first = Array.isArray(rows) ? rows[0] : rows;
-          if (!first)
-            throw new Error("Record not found");
-          return first;
-        },
-        async get() {
-          return runWithHooks(q, "select");
-        },
-        async first() {
-          const rows = await runWithHooks(q, "select");
-          return Array.isArray(rows) ? rows[0] : rows;
-        },
-        async firstOrFail() {
-          const rows = await runWithHooks(q, "select");
-          const first = Array.isArray(rows) ? rows[0] : rows;
-          if (!first)
-            throw new Error("No rows found");
-          return first;
-        },
-        async exists() {
-          const countQ = sql`SELECT EXISTS(${q}) as exists`;
-          const result = await runWithHooks(countQ, "select");
-          return result?.[0]?.exists === true;
-        },
-        async doesntExist() {
-          const exists = await this.exists();
-          return !exists;
-        },
-        values() {
-          return q.values();
-        },
-        raw() {
-          return q.raw();
-        },
-        cancel() {
-          try {
-            q.cancel();
-          } catch {}
-        },
-        whereRaw: subqueryNotSupported("whereRaw"),
-        whereColumn: subqueryNotSupported("whereColumn"),
-        orWhereColumn: subqueryNotSupported("orWhereColumn"),
-        whereIn: subqueryNotSupported("whereIn"),
-        orWhereIn: subqueryNotSupported("orWhereIn"),
-        whereNotIn: subqueryNotSupported("whereNotIn"),
-        orWhereNotIn: subqueryNotSupported("orWhereNotIn"),
-        whereLike: subqueryNotSupported("whereLike"),
-        whereILike: subqueryNotSupported("whereILike"),
-        orWhereLike: subqueryNotSupported("orWhereLike"),
-        orWhereILike: subqueryNotSupported("orWhereILike"),
-        whereNotLike: subqueryNotSupported("whereNotLike"),
-        whereNotILike: subqueryNotSupported("whereNotILike"),
-        orWhereNotLike: subqueryNotSupported("orWhereNotLike"),
-        orWhereNotILike: subqueryNotSupported("orWhereNotILike"),
-        whereAny: subqueryNotSupported("whereAny"),
-        whereAll: subqueryNotSupported("whereAll"),
-        whereNone: subqueryNotSupported("whereNone"),
-        whereNested: subqueryNotSupported("whereNested"),
-        orWhereNested: subqueryNotSupported("orWhereNested"),
-        whereDate: subqueryNotSupported("whereDate"),
-        whereBetween: subqueryNotSupported("whereBetween"),
-        whereNotBetween: subqueryNotSupported("whereNotBetween"),
-        whereJsonContains: subqueryNotSupported("whereJsonContains"),
-        whereJsonPath: subqueryNotSupported("whereJsonPath"),
-        whereNull: subqueryNotSupported("whereNull"),
-        whereNotNull: subqueryNotSupported("whereNotNull"),
-        whereExists: subqueryNotSupported("whereExists"),
-        whereJsonDoesntContain: subqueryNotSupported("whereJsonDoesntContain"),
-        whereJsonContainsKey: subqueryNotSupported("whereJsonContainsKey"),
-        whereJsonDoesntContainKey: subqueryNotSupported("whereJsonDoesntContainKey"),
-        whereJsonLength: subqueryNotSupported("whereJsonLength"),
-        join: subqueryNotSupported("join"),
-        joinSub: subqueryNotSupported("joinSub"),
-        innerJoin: subqueryNotSupported("innerJoin"),
-        leftJoin: subqueryNotSupported("leftJoin"),
-        leftJoinSub: subqueryNotSupported("leftJoinSub"),
-        rightJoin: subqueryNotSupported("rightJoin"),
-        crossJoin: subqueryNotSupported("crossJoin"),
-        crossJoinSub: subqueryNotSupported("crossJoinSub"),
-        groupBy: subqueryNotSupported("groupBy"),
-        groupByRaw: subqueryNotSupported("groupByRaw"),
-        having: subqueryNotSupported("having"),
-        havingRaw: subqueryNotSupported("havingRaw"),
-        addSelect: subqueryNotSupported("addSelect"),
-        select: subqueryNotSupported("select"),
-        selectAll: subqueryNotSupported("selectAll"),
-        orderByDesc: subqueryNotSupported("orderByDesc"),
-        inRandomOrder: subqueryNotSupported("inRandomOrder"),
-        reorder: subqueryNotSupported("reorder"),
-        orderByRaw: subqueryNotSupported("orderByRaw"),
-        union: subqueryNotSupported("union"),
-        unionAll: subqueryNotSupported("unionAll"),
-        forPage: subqueryNotSupported("forPage"),
-        selectAllRelations: subqueryNotSupported("selectAllRelations"),
-        with: subqueryNotSupported("with"),
-        value: subqueryNotSupported("value"),
-        pluck: subqueryNotSupported("pluck"),
-        cursorPaginate: subqueryNotSupported("cursorPaginate"),
-        paginate: subqueryNotSupported("paginate"),
-        simplePaginate: subqueryNotSupported("simplePaginate"),
-        chunk: subqueryNotSupported("chunk"),
-        chunkById: subqueryNotSupported("chunkById"),
-        eachById: subqueryNotSupported("eachById"),
-        count: subqueryNotSupported("count"),
-        avg: subqueryNotSupported("avg"),
-        sum: subqueryNotSupported("sum"),
-        max: subqueryNotSupported("max"),
-        min: subqueryNotSupported("min"),
-        find: subqueryNotSupported("find"),
-        findOrFail: subqueryNotSupported("findOrFail"),
-        findMany: subqueryNotSupported("findMany"),
-        latest: subqueryNotSupported("latest"),
-        oldest: subqueryNotSupported("oldest"),
-        lazy: subqueryNotSupported("lazy"),
-        lazyById: subqueryNotSupported("lazyById"),
-        pipe: (fn) => fn(this),
-        when: subqueryNotSupported("when"),
-        tap: () => this,
-        dump: () => this,
-        dd: () => {
-          throw new Error("Dump and Die");
-        },
-        explain: () => Promise.resolve([]),
-        simple: () => q.simple(),
-        toText: () => String(q),
-        toParams: () => q.values?.() ?? [],
-        withTimeout: () => this,
-        abort: () => this,
-        lockForUpdate: () => this,
-        sharedLock: () => this,
-        withCTE: () => this,
-        withRecursive: () => this,
-        cache: () => this,
-        clone: () => this,
-        withTrashed: () => this,
-        onlyTrashed: () => this,
-        scope: () => this,
-        get rows() {
-          return [];
-        },
-        get row() {
-          return;
-        }
+      validateIdentifier(String(alias), "selectFromSub(alias)");
+      const rawState = typeof sub.__rawState === "function" ? sub.__rawState() : null;
+      const subExec = sub.toSQL();
+      const subText = rawState?.sql ?? (typeof subExec === "string" ? subExec : subExec?.sql ?? String(subExec));
+      const subParams = rawState?.params ?? (Array.isArray(subExec?.values) ? subExec.values : []);
+      const baseText = `SELECT * FROM (${subText}) AS ${String(alias)}`;
+      const appendWhere = (text, params, hasWhere, expr, op, value, connector) => {
+        const kw = !hasWhere ? "WHERE" : connector === "WHERE" ? "AND" : connector;
+        const out = [...params];
+        const cmp = (col, operator, val) => {
+          validateIdentifier(col, "selectFromSub where(column)");
+          const o = assertSafeWhereOperator(operator, "selectFromSub where(operator)");
+          if (o === "in" || o === "not in") {
+            const vals = Array.isArray(val) ? val : [val];
+            const phs = getPlaceholders(vals.length, out.length + 1);
+            out.push(...vals);
+            return `${col} ${o.toUpperCase()} (${phs})`;
+          }
+          const ph = getPlaceholder(out.length + 1);
+          out.push(val);
+          return `${col} ${o} ${ph}`;
+        };
+        let clause;
+        if (typeof expr === "string" && op !== undefined)
+          clause = cmp(expr, op, value);
+        else if (Array.isArray(expr) && expr.length === 3)
+          clause = cmp(expr[0], expr[1], expr[2]);
+        else if (expr && typeof expr === "object")
+          clause = Object.entries(expr).map(([k, v]) => cmp(k, "=", v)).join(" AND ");
+        else
+          return { text, params };
+        return { text: `${text} ${kw} ${clause}`, params: out };
       };
-      function createSubQueryBuilder(newQ) {
-        return {
-          ...base,
-          toSQL: () => makeExecutableQuery(newQ),
-          execute: () => runWithHooks(newQ, "select"),
-          get: () => runWithHooks(newQ, "select"),
-          first: async () => {
-            const rows = await runWithHooks(newQ, "select");
+      function makeSub(text, params, hasWhere = false) {
+        const build = () => params.length > 0 ? _sql.unsafe(text, params) : _sql.unsafe(text);
+        const base = {
+          distinct() {
+            return makeSub(text.replace(/^SELECT\s+/i, "SELECT DISTINCT "), params, hasWhere);
+          },
+          distinctOn(...columns) {
+            const cols = columns.map(String).join(", ");
+            return makeSub(text.replace(/^SELECT\s+/i, `SELECT DISTINCT ON (${cols}) `), params, hasWhere);
+          },
+          selectRaw(fragment) {
+            const frag = renderRawFragment(fragment, "selectFromSub.selectRaw(fragment)");
+            const fromIdx = text.indexOf(" FROM ");
+            const newText = fromIdx !== -1 ? `${text.slice(0, fromIdx)}, ${frag}${text.slice(fromIdx)}` : `${text}, ${frag}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          where(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "WHERE");
+            return makeSub(r.text, r.params, true);
+          },
+          andWhere(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "AND");
+            return makeSub(r.text, r.params, true);
+          },
+          orWhere(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "OR");
+            return makeSub(r.text, r.params, true);
+          },
+          orderBy(column, direction = "asc") {
+            validateIdentifier(String(column), "selectFromSub.orderBy(column)");
+            const dir = direction === "asc" ? "ASC" : "DESC";
+            const newText = SQL_PATTERNS.ORDER_BY.test(text) ? `${text}, ${column} ${dir}` : `${text} ORDER BY ${column} ${dir}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          limit(n) {
+            if (!Number.isInteger(n) || n < 0)
+              throw new TypeError(`[query-builder] selectFromSub.limit(n): expected non-negative integer, got ${n}`);
+            const newText = SQL_PATTERNS.LIMIT.test(text) ? text.replace(SQL_PATTERNS.LIMIT, ` LIMIT ${n}`) : `${text} LIMIT ${n}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          offset(n) {
+            if (!Number.isInteger(n) || n < 0)
+              throw new TypeError(`[query-builder] selectFromSub.offset(n): expected non-negative integer, got ${n}`);
+            const newText = SQL_PATTERNS.OFFSET.test(text) ? text.replace(SQL_PATTERNS.OFFSET, ` OFFSET ${n}`) : `${text} OFFSET ${n}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          toSQL() {
+            return makeExecutableQuery(build(), text);
+          },
+          async execute() {
+            return runWithHooks(build(), "select");
+          },
+          async executeTakeFirst() {
+            const rows = await runWithHooks(build(), "select");
             return Array.isArray(rows) ? rows[0] : rows;
           },
-          firstOrFail: async () => {
-            const rows = await runWithHooks(newQ, "select");
+          async executeTakeFirstOrThrow() {
+            const rows = await runWithHooks(build(), "select");
+            const first = Array.isArray(rows) ? rows[0] : rows;
+            if (!first)
+              throw new Error("Record not found");
+            return first;
+          },
+          async get() {
+            return runWithHooks(build(), "select");
+          },
+          async first() {
+            const rows = await runWithHooks(build(), "select");
+            return Array.isArray(rows) ? rows[0] : rows;
+          },
+          async firstOrFail() {
+            const rows = await runWithHooks(build(), "select");
             const first = Array.isArray(rows) ? rows[0] : rows;
             if (!first)
               throw new Error("No rows found");
             return first;
           },
-          exists: async () => {
-            const countQ = sql`SELECT EXISTS(${newQ}) as exists`;
-            const result = await runWithHooks(countQ, "select");
-            return result?.[0]?.exists === true;
+          async count() {
+            const q = params.length > 0 ? _sql.unsafe(`SELECT COUNT(*) as c FROM (${text}) as sub`, params) : _sql.unsafe(`SELECT COUNT(*) as c FROM (${text}) as sub`);
+            const rows = await runWithHooks(q, "select");
+            return Number(rows?.[0]?.c ?? 0);
+          },
+          async exists() {
+            const q = params.length > 0 ? _sql.unsafe(`SELECT EXISTS(${text}) as e`, params) : _sql.unsafe(`SELECT EXISTS(${text}) as e`);
+            const result = await runWithHooks(q, "select");
+            return Boolean(result?.[0]?.e);
           },
-          doesntExist: async () => {
-            const exists = await base.exists();
-            return !exists;
+          async doesntExist() {
+            return !await base.exists();
           },
-          values: () => newQ.values(),
-          raw: () => newQ.raw(),
-          cancel: () => {
+          values() {
+            return build().values();
+          },
+          raw() {
+            return build().raw();
+          },
+          cancel() {
             try {
-              newQ.cancel();
+              build().cancel();
             } catch {}
           },
-          simple: () => newQ.simple(),
-          toText: () => String(newQ),
-          toParams: () => newQ.values?.() ?? []
+          whereRaw: subqueryNotSupported("whereRaw"),
+          whereColumn: subqueryNotSupported("whereColumn"),
+          orWhereColumn: subqueryNotSupported("orWhereColumn"),
+          whereIn: subqueryNotSupported("whereIn"),
+          orWhereIn: subqueryNotSupported("orWhereIn"),
+          whereNotIn: subqueryNotSupported("whereNotIn"),
+          orWhereNotIn: subqueryNotSupported("orWhereNotIn"),
+          whereLike: subqueryNotSupported("whereLike"),
+          whereILike: subqueryNotSupported("whereILike"),
+          orWhereLike: subqueryNotSupported("orWhereLike"),
+          orWhereILike: subqueryNotSupported("orWhereILike"),
+          whereNotLike: subqueryNotSupported("whereNotLike"),
+          whereNotILike: subqueryNotSupported("whereNotILike"),
+          orWhereNotLike: subqueryNotSupported("orWhereNotLike"),
+          orWhereNotILike: subqueryNotSupported("orWhereNotILike"),
+          whereAny: subqueryNotSupported("whereAny"),
+          whereAll: subqueryNotSupported("whereAll"),
+          whereNone: subqueryNotSupported("whereNone"),
+          whereNested: subqueryNotSupported("whereNested"),
+          orWhereNested: subqueryNotSupported("orWhereNested"),
+          whereDate: subqueryNotSupported("whereDate"),
+          whereBetween: subqueryNotSupported("whereBetween"),
+          whereNotBetween: subqueryNotSupported("whereNotBetween"),
+          whereJsonContains: subqueryNotSupported("whereJsonContains"),
+          whereJsonPath: subqueryNotSupported("whereJsonPath"),
+          whereNull: subqueryNotSupported("whereNull"),
+          whereNotNull: subqueryNotSupported("whereNotNull"),
+          whereExists: subqueryNotSupported("whereExists"),
+          whereJsonDoesntContain: subqueryNotSupported("whereJsonDoesntContain"),
+          whereJsonContainsKey: subqueryNotSupported("whereJsonContainsKey"),
+          whereJsonDoesntContainKey: subqueryNotSupported("whereJsonDoesntContainKey"),
+          whereJsonLength: subqueryNotSupported("whereJsonLength"),
+          join: subqueryNotSupported("join"),
+          joinSub: subqueryNotSupported("joinSub"),
+          innerJoin: subqueryNotSupported("innerJoin"),
+          leftJoin: subqueryNotSupported("leftJoin"),
+          leftJoinSub: subqueryNotSupported("leftJoinSub"),
+          rightJoin: subqueryNotSupported("rightJoin"),
+          crossJoin: subqueryNotSupported("crossJoin"),
+          crossJoinSub: subqueryNotSupported("crossJoinSub"),
+          groupBy: subqueryNotSupported("groupBy"),
+          groupByRaw: subqueryNotSupported("groupByRaw"),
+          having: subqueryNotSupported("having"),
+          havingRaw: subqueryNotSupported("havingRaw"),
+          addSelect: subqueryNotSupported("addSelect"),
+          select: subqueryNotSupported("select"),
+          selectAll: subqueryNotSupported("selectAll"),
+          orderByDesc: subqueryNotSupported("orderByDesc"),
+          inRandomOrder: subqueryNotSupported("inRandomOrder"),
+          reorder: subqueryNotSupported("reorder"),
+          orderByRaw: subqueryNotSupported("orderByRaw"),
+          union: subqueryNotSupported("union"),
+          unionAll: subqueryNotSupported("unionAll"),
+          forPage: subqueryNotSupported("forPage"),
+          selectAllRelations: subqueryNotSupported("selectAllRelations"),
+          with: subqueryNotSupported("with"),
+          value: subqueryNotSupported("value"),
+          pluck: subqueryNotSupported("pluck"),
+          cursorPaginate: subqueryNotSupported("cursorPaginate"),
+          paginate: subqueryNotSupported("paginate"),
+          simplePaginate: subqueryNotSupported("simplePaginate"),
+          chunk: subqueryNotSupported("chunk"),
+          chunkById: subqueryNotSupported("chunkById"),
+          eachById: subqueryNotSupported("eachById"),
+          avg: subqueryNotSupported("avg"),
+          sum: subqueryNotSupported("sum"),
+          max: subqueryNotSupported("max"),
+          min: subqueryNotSupported("min"),
+          find: subqueryNotSupported("find"),
+          findOrFail: subqueryNotSupported("findOrFail"),
+          findMany: subqueryNotSupported("findMany"),
+          latest: subqueryNotSupported("latest"),
+          oldest: subqueryNotSupported("oldest"),
+          lazy: subqueryNotSupported("lazy"),
+          lazyById: subqueryNotSupported("lazyById"),
+          pipe: (fn) => fn(base),
+          when: subqueryNotSupported("when"),
+          tap: () => base,
+          dump: () => base,
+          dd: () => {
+            throw new Error("Dump and Die");
+          },
+          explain: () => Promise.resolve([]),
+          simple: () => build().simple(),
+          toText: () => text,
+          toParams: () => [...params],
+          withTimeout: () => base,
+          abort: () => base,
+          lockForUpdate: () => base,
+          sharedLock: () => base,
+          withCTE: () => base,
+          withRecursive: () => base,
+          cache: () => base,
+          clone: () => base,
+          withTrashed: () => base,
+          onlyTrashed: () => base,
+          scope: () => base,
+          get rows() {
+            return [];
+          },
+          get row() {
+            return;
+          }
         };
+        return base;
       }
-      function applyWhereCondition(query, expr, op, value, prefix = "WHERE") {
-        if (typeof expr === "string" && op !== undefined) {
-          const clause = Array.isArray(value) ? `${expr} IN (?)` : `${expr} ${op} ?`;
-          return sql`${query} ${sql(prefix)} ${sql(clause)}`;
-        } else if (Array.isArray(expr) && expr.length === 3) {
-          const [column, operator, val] = expr;
-          const clause = Array.isArray(val) ? `${column} IN (?)` : `${column} ${operator} ?`;
-          return sql`${query} ${sql(prefix)} ${sql(clause)}`;
-        } else if (typeof expr === "object" && expr !== null) {
-          const conditions = Object.entries(expr).map(([key, val]) => {
-            const clause = Array.isArray(val) ? `${key} IN (?)` : `${key} = ?`;
-            return sql`${sql(clause)}`;
-          });
-          const combined = conditions.reduce((acc, cond, i) => i === 0 ? cond : sql`${acc} AND ${cond}`);
-          return sql`${query} ${sql(prefix)} ${combined}`;
-        }
-        return query;
-      }
-      return base;
+      return makeSub(baseText, subParams);
     },
     insertInto(table) {
       let built;
@@ -24639,8 +24621,45 @@ function resolveRelation(definition, relationName) {
       pivotTimestamps: Boolean(config6?.pivot?.timestamps)
     };
   }
+  const resolveThrough = (field, type) => {
+    if (!field || typeof field !== "object" || Array.isArray(field))
+      return null;
+    const entry = field[relationName] ?? field[Object.keys(field).find((k2) => k2.toLowerCase() === relationName.toLowerCase()) ?? ""];
+    if (!entry || typeof entry !== "object")
+      return null;
+    const throughModelName = entry.through;
+    const targetModelName = entry.target;
+    if (!throughModelName || !targetModelName)
+      return null;
+    const throughModel = getModelFromRegistry(throughModelName);
+    const throughDef = throughModel?.getDefinition?.() || throughModel?.definition;
+    const throughTable = throughModel?.getTable?.() || throughDef?.table || toTableName(throughModelName);
+    const throughPk = throughDef?.primaryKey || "id";
+    const targetModel = getModelFromRegistry(targetModelName);
+    const targetTable = targetModel?.getTable?.() || toTableName(targetModelName);
+    return {
+      type,
+      relatedModelName: targetModelName,
+      relatedTable: targetTable,
+      foreignKey: `${toSnakeCase(parentName)}_id`,
+      localKey: parentPk,
+      throughTable,
+      throughForeignKey: `${toSnakeCase(parentName)}_id`,
+      throughLocalKey: throughPk,
+      targetForeignKey: `${singularizeWord(throughTable)}_id`
+    };
+  };
+  const hmt = resolveThrough(definition.hasManyThrough, "hasManyThrough");
+  if (hmt)
+    return hmt;
+  const hot = resolveThrough(definition.hasOneThrough, "hasOneThrough");
+  if (hot)
+    return hot;
   return null;
 }
+function singularizeWord(table) {
+  return table.endsWith("s") ? table.slice(0, -1) : table;
+}
 
 class BelongsToManyRelationBuilder {
   _parent;
@@ -25277,6 +25296,40 @@ class ModelQueryBuilder {
           instance.setRelation(relationName, relatedInstances);
         }
       }
+      if (rel.type === "hasManyThrough" || rel.type === "hasOneThrough") {
+        const parentIds = instances.map((i2) => i2.get(pk)).filter((id) => id != null);
+        if (parentIds.length === 0)
+          continue;
+        const throughPk = rel.throughLocalKey || "id";
+        const throughPh = parentIds.map(() => "?").join(", ");
+        const throughRows = await exec.all(`SELECT ${throughPk}, ${rel.throughForeignKey} FROM ${rel.throughTable} WHERE ${rel.throughForeignKey} IN (${throughPh})`, parentIds);
+        if (throughRows.length === 0) {
+          for (const instance of instances)
+            instance.setRelation(relationName, rel.type === "hasManyThrough" ? [] : null);
+          continue;
+        }
+        const throughToParent = new Map;
+        for (const t2 of throughRows)
+          throughToParent.set(t2[throughPk], t2[rel.throughForeignKey]);
+        const throughIds = [...new Set(throughRows.map((t2) => t2[throughPk]))];
+        const targetPh = throughIds.map(() => "?").join(", ");
+        const targetRows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.targetForeignKey} IN (${targetPh})`, throughIds);
+        const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
+        const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
+        const byParent = new Map;
+        for (const row of targetRows) {
+          const parentVal = throughToParent.get(row[rel.targetForeignKey]);
+          if (parentVal == null)
+            continue;
+          if (!byParent.has(parentVal))
+            byParent.set(parentVal, []);
+          byParent.get(parentVal).push(new ModelInstance(relDef, row));
+        }
+        for (const instance of instances) {
+          const group = byParent.get(instance.get(pk)) || [];
+          instance.setRelation(relationName, rel.type === "hasManyThrough" ? group : group[0] ?? null);
+        }
+      }
     }
   }
   async get() {
@@ -30153,7 +30206,7 @@ function getPrefix() {
 }
 var prefix = getPrefix();
 // package.json
-var version2 = "0.1.35";
+var version2 = "0.1.37";
 
 // bin/cli.ts
 init_actions();

package/dist/orm.d.ts

@@ -163,11 +163,15 @@ declare interface OrmExecutor {
  * populated only for `belongsToMany` relations.
  */
 declare interface ResolvedRelation {
-  type: 'hasMany' | 'hasOne' | 'belongsTo' | 'belongsToMany'
+  type: 'hasMany' | 'hasOne' | 'belongsTo' | 'belongsToMany' | 'hasManyThrough' | 'hasOneThrough'
   relatedModelName: string
   relatedTable: string
   foreignKey: string
   localKey: string
+  throughTable?: string
+  throughForeignKey?: string
+  throughLocalKey?: string
+  targetForeignKey?: string
   pivotTable?: string
   pivotFkParent?: string
   pivotFkRelated?: string

package/dist/src/index.js

@@ -15036,7 +15036,7 @@ function createQueryBuilder(state) {
         return ensureBuilt().values();
       },
       toParams() {
-        return ensureBuilt().values?.() ?? [];
+        return [...whereParams];
       },
       __rawState() {
         return { sql: reorderSelectClauses(text), params: [...whereParams] };
@@ -15133,265 +15133,247 @@ function createQueryBuilder(state) {
           throw new Error(`[query-builder] selectFromSub(...).${methodName}() is not supported. ` + `Apply ${methodName}() to the underlying subquery BEFORE passing it to selectFromSub, ` + `or use the regular selectFrom(...) builder. This previously silently returned without ` + `affecting the SQL, producing wrong results \u2014 see stacksjs/stacks#1862 #11.`);
         };
       }
-      const sql = _sql;
-      const q = _sql`SELECT * FROM (${sub.toSQL()}) AS ${_sql(alias)}`;
-      const base = {
-        distinct() {
-          const rest = String(q).replace(/^SELECT\s+/i, "");
-          const newQ = sql`SELECT DISTINCT ${sql``}${sql(rest)}`;
-          return createSubQueryBuilder(newQ);
-        },
-        distinctOn(...columns) {
-          const match = /^SELECT\s+(\S+)\s+FROM/i.exec(String(q));
-          const body = match ? `${match[1]} FROM` : String(q);
-          const newQ = sql`SELECT DISTINCT ON (${sql(columns)}) ${sql``}${sql(body)}`;
-          return createSubQueryBuilder(newQ);
-        },
-        selectRaw(fragment) {
-          const newQ = sql`${q} , ${fragment}`;
-          return createSubQueryBuilder(newQ);
-        },
-        where(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "WHERE");
-          return createSubQueryBuilder(newQ);
-        },
-        andWhere(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "AND");
-          return createSubQueryBuilder(newQ);
-        },
-        orWhere(expr, op, value) {
-          const newQ = applyWhereCondition(q, expr, op, value, "OR");
-          return createSubQueryBuilder(newQ);
-        },
-        orderBy(column, direction = "asc") {
-          const dir = direction === "asc" ? "ASC" : "DESC";
-          const current = String(q);
-          const newQ = SQL_PATTERNS.ORDER_BY.test(current) ? sql.unsafe(`${current}, ${column} ${dir}`) : sql`${q} ORDER BY ${sql(column)} ${direction === "asc" ? sql`ASC` : sql`DESC`}`;
-          return createSubQueryBuilder(newQ);
-        },
-        limit(n) {
-          const current = String(q);
-          const newQ = SQL_PATTERNS.LIMIT.test(current) ? sql.unsafe(current.replace(SQL_PATTERNS.LIMIT, ` LIMIT ${n}`)) : sql`${q} LIMIT ${n}`;
-          return createSubQueryBuilder(newQ);
-        },
-        offset(n) {
-          const current = String(q);
-          const newQ = SQL_PATTERNS.OFFSET.test(current) ? sql.unsafe(current.replace(SQL_PATTERNS.OFFSET, ` OFFSET ${n}`)) : sql`${q} OFFSET ${n}`;
-          return createSubQueryBuilder(newQ);
-        },
-        toSQL() {
-          return makeExecutableQuery(q);
-        },
-        async execute() {
-          return runWithHooks(q, "select");
-        },
-        async executeTakeFirst() {
-          const rows = await runWithHooks(q, "select");
-          return Array.isArray(rows) ? rows[0] : rows;
-        },
-        async executeTakeFirstOrThrow() {
-          const rows = await runWithHooks(q, "select");
-          const first = Array.isArray(rows) ? rows[0] : rows;
-          if (!first)
-            throw new Error("Record not found");
-          return first;
-        },
-        async get() {
-          return runWithHooks(q, "select");
-        },
-        async first() {
-          const rows = await runWithHooks(q, "select");
-          return Array.isArray(rows) ? rows[0] : rows;
-        },
-        async firstOrFail() {
-          const rows = await runWithHooks(q, "select");
-          const first = Array.isArray(rows) ? rows[0] : rows;
-          if (!first)
-            throw new Error("No rows found");
-          return first;
-        },
-        async exists() {
-          const countQ = sql`SELECT EXISTS(${q}) as exists`;
-          const result = await runWithHooks(countQ, "select");
-          return result?.[0]?.exists === true;
-        },
-        async doesntExist() {
-          const exists = await this.exists();
-          return !exists;
-        },
-        values() {
-          return q.values();
-        },
-        raw() {
-          return q.raw();
-        },
-        cancel() {
-          try {
-            q.cancel();
-          } catch {}
-        },
-        whereRaw: subqueryNotSupported("whereRaw"),
-        whereColumn: subqueryNotSupported("whereColumn"),
-        orWhereColumn: subqueryNotSupported("orWhereColumn"),
-        whereIn: subqueryNotSupported("whereIn"),
-        orWhereIn: subqueryNotSupported("orWhereIn"),
-        whereNotIn: subqueryNotSupported("whereNotIn"),
-        orWhereNotIn: subqueryNotSupported("orWhereNotIn"),
-        whereLike: subqueryNotSupported("whereLike"),
-        whereILike: subqueryNotSupported("whereILike"),
-        orWhereLike: subqueryNotSupported("orWhereLike"),
-        orWhereILike: subqueryNotSupported("orWhereILike"),
-        whereNotLike: subqueryNotSupported("whereNotLike"),
-        whereNotILike: subqueryNotSupported("whereNotILike"),
-        orWhereNotLike: subqueryNotSupported("orWhereNotLike"),
-        orWhereNotILike: subqueryNotSupported("orWhereNotILike"),
-        whereAny: subqueryNotSupported("whereAny"),
-        whereAll: subqueryNotSupported("whereAll"),
-        whereNone: subqueryNotSupported("whereNone"),
-        whereNested: subqueryNotSupported("whereNested"),
-        orWhereNested: subqueryNotSupported("orWhereNested"),
-        whereDate: subqueryNotSupported("whereDate"),
-        whereBetween: subqueryNotSupported("whereBetween"),
-        whereNotBetween: subqueryNotSupported("whereNotBetween"),
-        whereJsonContains: subqueryNotSupported("whereJsonContains"),
-        whereJsonPath: subqueryNotSupported("whereJsonPath"),
-        whereNull: subqueryNotSupported("whereNull"),
-        whereNotNull: subqueryNotSupported("whereNotNull"),
-        whereExists: subqueryNotSupported("whereExists"),
-        whereJsonDoesntContain: subqueryNotSupported("whereJsonDoesntContain"),
-        whereJsonContainsKey: subqueryNotSupported("whereJsonContainsKey"),
-        whereJsonDoesntContainKey: subqueryNotSupported("whereJsonDoesntContainKey"),
-        whereJsonLength: subqueryNotSupported("whereJsonLength"),
-        join: subqueryNotSupported("join"),
-        joinSub: subqueryNotSupported("joinSub"),
-        innerJoin: subqueryNotSupported("innerJoin"),
-        leftJoin: subqueryNotSupported("leftJoin"),
-        leftJoinSub: subqueryNotSupported("leftJoinSub"),
-        rightJoin: subqueryNotSupported("rightJoin"),
-        crossJoin: subqueryNotSupported("crossJoin"),
-        crossJoinSub: subqueryNotSupported("crossJoinSub"),
-        groupBy: subqueryNotSupported("groupBy"),
-        groupByRaw: subqueryNotSupported("groupByRaw"),
-        having: subqueryNotSupported("having"),
-        havingRaw: subqueryNotSupported("havingRaw"),
-        addSelect: subqueryNotSupported("addSelect"),
-        select: subqueryNotSupported("select"),
-        selectAll: subqueryNotSupported("selectAll"),
-        orderByDesc: subqueryNotSupported("orderByDesc"),
-        inRandomOrder: subqueryNotSupported("inRandomOrder"),
-        reorder: subqueryNotSupported("reorder"),
-        orderByRaw: subqueryNotSupported("orderByRaw"),
-        union: subqueryNotSupported("union"),
-        unionAll: subqueryNotSupported("unionAll"),
-        forPage: subqueryNotSupported("forPage"),
-        selectAllRelations: subqueryNotSupported("selectAllRelations"),
-        with: subqueryNotSupported("with"),
-        value: subqueryNotSupported("value"),
-        pluck: subqueryNotSupported("pluck"),
-        cursorPaginate: subqueryNotSupported("cursorPaginate"),
-        paginate: subqueryNotSupported("paginate"),
-        simplePaginate: subqueryNotSupported("simplePaginate"),
-        chunk: subqueryNotSupported("chunk"),
-        chunkById: subqueryNotSupported("chunkById"),
-        eachById: subqueryNotSupported("eachById"),
-        count: subqueryNotSupported("count"),
-        avg: subqueryNotSupported("avg"),
-        sum: subqueryNotSupported("sum"),
-        max: subqueryNotSupported("max"),
-        min: subqueryNotSupported("min"),
-        find: subqueryNotSupported("find"),
-        findOrFail: subqueryNotSupported("findOrFail"),
-        findMany: subqueryNotSupported("findMany"),
-        latest: subqueryNotSupported("latest"),
-        oldest: subqueryNotSupported("oldest"),
-        lazy: subqueryNotSupported("lazy"),
-        lazyById: subqueryNotSupported("lazyById"),
-        pipe: (fn) => fn(this),
-        when: subqueryNotSupported("when"),
-        tap: () => this,
-        dump: () => this,
-        dd: () => {
-          throw new Error("Dump and Die");
-        },
-        explain: () => Promise.resolve([]),
-        simple: () => q.simple(),
-        toText: () => String(q),
-        toParams: () => q.values?.() ?? [],
-        withTimeout: () => this,
-        abort: () => this,
-        lockForUpdate: () => this,
-        sharedLock: () => this,
-        withCTE: () => this,
-        withRecursive: () => this,
-        cache: () => this,
-        clone: () => this,
-        withTrashed: () => this,
-        onlyTrashed: () => this,
-        scope: () => this,
-        get rows() {
-          return [];
-        },
-        get row() {
-          return;
-        }
+      validateIdentifier(String(alias), "selectFromSub(alias)");
+      const rawState = typeof sub.__rawState === "function" ? sub.__rawState() : null;
+      const subExec = sub.toSQL();
+      const subText = rawState?.sql ?? (typeof subExec === "string" ? subExec : subExec?.sql ?? String(subExec));
+      const subParams = rawState?.params ?? (Array.isArray(subExec?.values) ? subExec.values : []);
+      const baseText = `SELECT * FROM (${subText}) AS ${String(alias)}`;
+      const appendWhere = (text, params, hasWhere, expr, op, value, connector) => {
+        const kw = !hasWhere ? "WHERE" : connector === "WHERE" ? "AND" : connector;
+        const out = [...params];
+        const cmp = (col, operator, val) => {
+          validateIdentifier(col, "selectFromSub where(column)");
+          const o = assertSafeWhereOperator(operator, "selectFromSub where(operator)");
+          if (o === "in" || o === "not in") {
+            const vals = Array.isArray(val) ? val : [val];
+            const phs = getPlaceholders(vals.length, out.length + 1);
+            out.push(...vals);
+            return `${col} ${o.toUpperCase()} (${phs})`;
+          }
+          const ph = getPlaceholder(out.length + 1);
+          out.push(val);
+          return `${col} ${o} ${ph}`;
+        };
+        let clause;
+        if (typeof expr === "string" && op !== undefined)
+          clause = cmp(expr, op, value);
+        else if (Array.isArray(expr) && expr.length === 3)
+          clause = cmp(expr[0], expr[1], expr[2]);
+        else if (expr && typeof expr === "object")
+          clause = Object.entries(expr).map(([k, v]) => cmp(k, "=", v)).join(" AND ");
+        else
+          return { text, params };
+        return { text: `${text} ${kw} ${clause}`, params: out };
       };
-      function createSubQueryBuilder(newQ) {
-        return {
-          ...base,
-          toSQL: () => makeExecutableQuery(newQ),
-          execute: () => runWithHooks(newQ, "select"),
-          get: () => runWithHooks(newQ, "select"),
-          first: async () => {
-            const rows = await runWithHooks(newQ, "select");
+      function makeSub(text, params, hasWhere = false) {
+        const build = () => params.length > 0 ? _sql.unsafe(text, params) : _sql.unsafe(text);
+        const base = {
+          distinct() {
+            return makeSub(text.replace(/^SELECT\s+/i, "SELECT DISTINCT "), params, hasWhere);
+          },
+          distinctOn(...columns) {
+            const cols = columns.map(String).join(", ");
+            return makeSub(text.replace(/^SELECT\s+/i, `SELECT DISTINCT ON (${cols}) `), params, hasWhere);
+          },
+          selectRaw(fragment) {
+            const frag = renderRawFragment(fragment, "selectFromSub.selectRaw(fragment)");
+            const fromIdx = text.indexOf(" FROM ");
+            const newText = fromIdx !== -1 ? `${text.slice(0, fromIdx)}, ${frag}${text.slice(fromIdx)}` : `${text}, ${frag}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          where(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "WHERE");
+            return makeSub(r.text, r.params, true);
+          },
+          andWhere(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "AND");
+            return makeSub(r.text, r.params, true);
+          },
+          orWhere(expr, op, value) {
+            const r = appendWhere(text, params, hasWhere, expr, op, value, "OR");
+            return makeSub(r.text, r.params, true);
+          },
+          orderBy(column, direction = "asc") {
+            validateIdentifier(String(column), "selectFromSub.orderBy(column)");
+            const dir = direction === "asc" ? "ASC" : "DESC";
+            const newText = SQL_PATTERNS.ORDER_BY.test(text) ? `${text}, ${column} ${dir}` : `${text} ORDER BY ${column} ${dir}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          limit(n) {
+            if (!Number.isInteger(n) || n < 0)
+              throw new TypeError(`[query-builder] selectFromSub.limit(n): expected non-negative integer, got ${n}`);
+            const newText = SQL_PATTERNS.LIMIT.test(text) ? text.replace(SQL_PATTERNS.LIMIT, ` LIMIT ${n}`) : `${text} LIMIT ${n}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          offset(n) {
+            if (!Number.isInteger(n) || n < 0)
+              throw new TypeError(`[query-builder] selectFromSub.offset(n): expected non-negative integer, got ${n}`);
+            const newText = SQL_PATTERNS.OFFSET.test(text) ? text.replace(SQL_PATTERNS.OFFSET, ` OFFSET ${n}`) : `${text} OFFSET ${n}`;
+            return makeSub(newText, params, hasWhere);
+          },
+          toSQL() {
+            return makeExecutableQuery(build(), text);
+          },
+          async execute() {
+            return runWithHooks(build(), "select");
+          },
+          async executeTakeFirst() {
+            const rows = await runWithHooks(build(), "select");
             return Array.isArray(rows) ? rows[0] : rows;
           },
-          firstOrFail: async () => {
-            const rows = await runWithHooks(newQ, "select");
+          async executeTakeFirstOrThrow() {
+            const rows = await runWithHooks(build(), "select");
+            const first = Array.isArray(rows) ? rows[0] : rows;
+            if (!first)
+              throw new Error("Record not found");
+            return first;
+          },
+          async get() {
+            return runWithHooks(build(), "select");
+          },
+          async first() {
+            const rows = await runWithHooks(build(), "select");
+            return Array.isArray(rows) ? rows[0] : rows;
+          },
+          async firstOrFail() {
+            const rows = await runWithHooks(build(), "select");
             const first = Array.isArray(rows) ? rows[0] : rows;
             if (!first)
               throw new Error("No rows found");
             return first;
           },
-          exists: async () => {
-            const countQ = sql`SELECT EXISTS(${newQ}) as exists`;
-            const result = await runWithHooks(countQ, "select");
-            return result?.[0]?.exists === true;
+          async count() {
+            const q = params.length > 0 ? _sql.unsafe(`SELECT COUNT(*) as c FROM (${text}) as sub`, params) : _sql.unsafe(`SELECT COUNT(*) as c FROM (${text}) as sub`);
+            const rows = await runWithHooks(q, "select");
+            return Number(rows?.[0]?.c ?? 0);
+          },
+          async exists() {
+            const q = params.length > 0 ? _sql.unsafe(`SELECT EXISTS(${text}) as e`, params) : _sql.unsafe(`SELECT EXISTS(${text}) as e`);
+            const result = await runWithHooks(q, "select");
+            return Boolean(result?.[0]?.e);
           },
-          doesntExist: async () => {
-            const exists = await base.exists();
-            return !exists;
+          async doesntExist() {
+            return !await base.exists();
           },
-          values: () => newQ.values(),
-          raw: () => newQ.raw(),
-          cancel: () => {
+          values() {
+            return build().values();
+          },
+          raw() {
+            return build().raw();
+          },
+          cancel() {
             try {
-              newQ.cancel();
+              build().cancel();
             } catch {}
           },
-          simple: () => newQ.simple(),
-          toText: () => String(newQ),
-          toParams: () => newQ.values?.() ?? []
+          whereRaw: subqueryNotSupported("whereRaw"),
+          whereColumn: subqueryNotSupported("whereColumn"),
+          orWhereColumn: subqueryNotSupported("orWhereColumn"),
+          whereIn: subqueryNotSupported("whereIn"),
+          orWhereIn: subqueryNotSupported("orWhereIn"),
+          whereNotIn: subqueryNotSupported("whereNotIn"),
+          orWhereNotIn: subqueryNotSupported("orWhereNotIn"),
+          whereLike: subqueryNotSupported("whereLike"),
+          whereILike: subqueryNotSupported("whereILike"),
+          orWhereLike: subqueryNotSupported("orWhereLike"),
+          orWhereILike: subqueryNotSupported("orWhereILike"),
+          whereNotLike: subqueryNotSupported("whereNotLike"),
+          whereNotILike: subqueryNotSupported("whereNotILike"),
+          orWhereNotLike: subqueryNotSupported("orWhereNotLike"),
+          orWhereNotILike: subqueryNotSupported("orWhereNotILike"),
+          whereAny: subqueryNotSupported("whereAny"),
+          whereAll: subqueryNotSupported("whereAll"),
+          whereNone: subqueryNotSupported("whereNone"),
+          whereNested: subqueryNotSupported("whereNested"),
+          orWhereNested: subqueryNotSupported("orWhereNested"),
+          whereDate: subqueryNotSupported("whereDate"),
+          whereBetween: subqueryNotSupported("whereBetween"),
+          whereNotBetween: subqueryNotSupported("whereNotBetween"),
+          whereJsonContains: subqueryNotSupported("whereJsonContains"),
+          whereJsonPath: subqueryNotSupported("whereJsonPath"),
+          whereNull: subqueryNotSupported("whereNull"),
+          whereNotNull: subqueryNotSupported("whereNotNull"),
+          whereExists: subqueryNotSupported("whereExists"),
+          whereJsonDoesntContain: subqueryNotSupported("whereJsonDoesntContain"),
+          whereJsonContainsKey: subqueryNotSupported("whereJsonContainsKey"),
+          whereJsonDoesntContainKey: subqueryNotSupported("whereJsonDoesntContainKey"),
+          whereJsonLength: subqueryNotSupported("whereJsonLength"),
+          join: subqueryNotSupported("join"),
+          joinSub: subqueryNotSupported("joinSub"),
+          innerJoin: subqueryNotSupported("innerJoin"),
+          leftJoin: subqueryNotSupported("leftJoin"),
+          leftJoinSub: subqueryNotSupported("leftJoinSub"),
+          rightJoin: subqueryNotSupported("rightJoin"),
+          crossJoin: subqueryNotSupported("crossJoin"),
+          crossJoinSub: subqueryNotSupported("crossJoinSub"),
+          groupBy: subqueryNotSupported("groupBy"),
+          groupByRaw: subqueryNotSupported("groupByRaw"),
+          having: subqueryNotSupported("having"),
+          havingRaw: subqueryNotSupported("havingRaw"),
+          addSelect: subqueryNotSupported("addSelect"),
+          select: subqueryNotSupported("select"),
+          selectAll: subqueryNotSupported("selectAll"),
+          orderByDesc: subqueryNotSupported("orderByDesc"),
+          inRandomOrder: subqueryNotSupported("inRandomOrder"),
+          reorder: subqueryNotSupported("reorder"),
+          orderByRaw: subqueryNotSupported("orderByRaw"),
+          union: subqueryNotSupported("union"),
+          unionAll: subqueryNotSupported("unionAll"),
+          forPage: subqueryNotSupported("forPage"),
+          selectAllRelations: subqueryNotSupported("selectAllRelations"),
+          with: subqueryNotSupported("with"),
+          value: subqueryNotSupported("value"),
+          pluck: subqueryNotSupported("pluck"),
+          cursorPaginate: subqueryNotSupported("cursorPaginate"),
+          paginate: subqueryNotSupported("paginate"),
+          simplePaginate: subqueryNotSupported("simplePaginate"),
+          chunk: subqueryNotSupported("chunk"),
+          chunkById: subqueryNotSupported("chunkById"),
+          eachById: subqueryNotSupported("eachById"),
+          avg: subqueryNotSupported("avg"),
+          sum: subqueryNotSupported("sum"),
+          max: subqueryNotSupported("max"),
+          min: subqueryNotSupported("min"),
+          find: subqueryNotSupported("find"),
+          findOrFail: subqueryNotSupported("findOrFail"),
+          findMany: subqueryNotSupported("findMany"),
+          latest: subqueryNotSupported("latest"),
+          oldest: subqueryNotSupported("oldest"),
+          lazy: subqueryNotSupported("lazy"),
+          lazyById: subqueryNotSupported("lazyById"),
+          pipe: (fn) => fn(base),
+          when: subqueryNotSupported("when"),
+          tap: () => base,
+          dump: () => base,
+          dd: () => {
+            throw new Error("Dump and Die");
+          },
+          explain: () => Promise.resolve([]),
+          simple: () => build().simple(),
+          toText: () => text,
+          toParams: () => [...params],
+          withTimeout: () => base,
+          abort: () => base,
+          lockForUpdate: () => base,
+          sharedLock: () => base,
+          withCTE: () => base,
+          withRecursive: () => base,
+          cache: () => base,
+          clone: () => base,
+          withTrashed: () => base,
+          onlyTrashed: () => base,
+          scope: () => base,
+          get rows() {
+            return [];
+          },
+          get row() {
+            return;
+          }
         };
+        return base;
       }
-      function applyWhereCondition(query, expr, op, value, prefix = "WHERE") {
-        if (typeof expr === "string" && op !== undefined) {
-          const clause = Array.isArray(value) ? `${expr} IN (?)` : `${expr} ${op} ?`;
-          return sql`${query} ${sql(prefix)} ${sql(clause)}`;
-        } else if (Array.isArray(expr) && expr.length === 3) {
-          const [column, operator, val] = expr;
-          const clause = Array.isArray(val) ? `${column} IN (?)` : `${column} ${operator} ?`;
-          return sql`${query} ${sql(prefix)} ${sql(clause)}`;
-        } else if (typeof expr === "object" && expr !== null) {
-          const conditions = Object.entries(expr).map(([key, val]) => {
-            const clause = Array.isArray(val) ? `${key} IN (?)` : `${key} = ?`;
-            return sql`${sql(clause)}`;
-          });
-          const combined = conditions.reduce((acc, cond, i) => i === 0 ? cond : sql`${acc} AND ${cond}`);
-          return sql`${query} ${sql(prefix)} ${combined}`;
-        }
-        return query;
-      }
-      return base;
+      return makeSub(baseText, subParams);
     },
     insertInto(table) {
       let built;
@@ -24639,8 +24621,45 @@ function resolveRelation(definition, relationName) {
       pivotTimestamps: Boolean(config6?.pivot?.timestamps)
     };
   }
+  const resolveThrough = (field, type) => {
+    if (!field || typeof field !== "object" || Array.isArray(field))
+      return null;
+    const entry = field[relationName] ?? field[Object.keys(field).find((k2) => k2.toLowerCase() === relationName.toLowerCase()) ?? ""];
+    if (!entry || typeof entry !== "object")
+      return null;
+    const throughModelName = entry.through;
+    const targetModelName = entry.target;
+    if (!throughModelName || !targetModelName)
+      return null;
+    const throughModel = getModelFromRegistry(throughModelName);
+    const throughDef = throughModel?.getDefinition?.() || throughModel?.definition;
+    const throughTable = throughModel?.getTable?.() || throughDef?.table || toTableName(throughModelName);
+    const throughPk = throughDef?.primaryKey || "id";
+    const targetModel = getModelFromRegistry(targetModelName);
+    const targetTable = targetModel?.getTable?.() || toTableName(targetModelName);
+    return {
+      type,
+      relatedModelName: targetModelName,
+      relatedTable: targetTable,
+      foreignKey: `${toSnakeCase(parentName)}_id`,
+      localKey: parentPk,
+      throughTable,
+      throughForeignKey: `${toSnakeCase(parentName)}_id`,
+      throughLocalKey: throughPk,
+      targetForeignKey: `${singularizeWord(throughTable)}_id`
+    };
+  };
+  const hmt = resolveThrough(definition.hasManyThrough, "hasManyThrough");
+  if (hmt)
+    return hmt;
+  const hot = resolveThrough(definition.hasOneThrough, "hasOneThrough");
+  if (hot)
+    return hot;
   return null;
 }
+function singularizeWord(table) {
+  return table.endsWith("s") ? table.slice(0, -1) : table;
+}
 
 class BelongsToManyRelationBuilder {
   _parent;
@@ -25277,6 +25296,40 @@ class ModelQueryBuilder {
           instance.setRelation(relationName, relatedInstances);
         }
       }
+      if (rel.type === "hasManyThrough" || rel.type === "hasOneThrough") {
+        const parentIds = instances.map((i2) => i2.get(pk)).filter((id) => id != null);
+        if (parentIds.length === 0)
+          continue;
+        const throughPk = rel.throughLocalKey || "id";
+        const throughPh = parentIds.map(() => "?").join(", ");
+        const throughRows = await exec.all(`SELECT ${throughPk}, ${rel.throughForeignKey} FROM ${rel.throughTable} WHERE ${rel.throughForeignKey} IN (${throughPh})`, parentIds);
+        if (throughRows.length === 0) {
+          for (const instance of instances)
+            instance.setRelation(relationName, rel.type === "hasManyThrough" ? [] : null);
+          continue;
+        }
+        const throughToParent = new Map;
+        for (const t2 of throughRows)
+          throughToParent.set(t2[throughPk], t2[rel.throughForeignKey]);
+        const throughIds = [...new Set(throughRows.map((t2) => t2[throughPk]))];
+        const targetPh = throughIds.map(() => "?").join(", ");
+        const targetRows = await exec.all(`SELECT * FROM ${rel.relatedTable} WHERE ${rel.targetForeignKey} IN (${targetPh})`, throughIds);
+        const relatedModelDef = getModelFromRegistry(rel.relatedModelName);
+        const relDef = relatedModelDef?.getDefinition?.() || relatedModelDef?.definition || this._definition;
+        const byParent = new Map;
+        for (const row of targetRows) {
+          const parentVal = throughToParent.get(row[rel.targetForeignKey]);
+          if (parentVal == null)
+            continue;
+          if (!byParent.has(parentVal))
+            byParent.set(parentVal, []);
+          byParent.get(parentVal).push(new ModelInstance(relDef, row));
+        }
+        for (const instance of instances) {
+          const group = byParent.get(instance.get(pk)) || [];
+          instance.setRelation(relationName, rel.type === "hasManyThrough" ? group : group[0] ?? null);
+        }
+      }
     }
   }
   async get() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bun-query-builder",
   "type": "module",
-  "version": "0.1.35",
+  "version": "0.1.37",
   "description": "A simple yet performant query builder for TypeScript. Built with Bun.",
   "author": "Chris Breuer <chris@stacksjs.org>",
   "license": "MIT",