@vibeorm/runtime 1.1.5 → 1.1.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vibeorm/runtime",
-  "version": "1.1.5",
+  "version": "1.1.6",
   "description": "Driver-agnostic query engine and client runtime for VibeORM",
   "license": "MIT",
   "keywords": [

package/src/lateral-join-builder.ts

@@ -12,20 +12,29 @@
  *   __lat_1."__vibeorm_rel_profile"
  * FROM "User"
  * LEFT JOIN LATERAL (
- *   SELECT COALESCE(json_agg(json_build_object(
- *     'id', __rel."id", 'title', __rel."title", ...
- *   )), '[]'::json) AS "__vibeorm_rel_posts"
- *   FROM "Post" __rel WHERE __rel."authorId" = "User"."id"
+ *   SELECT COALESCE(jsonb_agg(to_jsonb("__sub".*)), '[]'::jsonb)
+ *     AS "__vibeorm_rel_posts"
+ *   FROM (
+ *     SELECT __rel."id" AS "id", __rel."title" AS "title", ...
+ *     FROM "Post" __rel WHERE __rel."authorId" = "User"."id"
+ *   ) "__sub"
  * ) __lat_0 ON true
  * LEFT JOIN LATERAL (
- *   SELECT json_build_object(
- *     'id', __rel."id", 'bio', __rel."bio", ...
- *   ) AS "__vibeorm_rel_profile"
- *   FROM "Profile" __rel WHERE __rel."userId" = "User"."id" LIMIT 1
+ *   SELECT to_jsonb("__sub".*) AS "__vibeorm_rel_profile"
+ *   FROM (
+ *     SELECT __rel."id" AS "id", __rel."bio" AS "bio", ...
+ *     FROM "Profile" __rel WHERE __rel."userId" = "User"."id"
+ *     LIMIT 1
+ *   ) "__sub"
  * ) __lat_1 ON true
  * WHERE "User"."role" = $1
  * ORDER BY "User"."id" ASC
  * LIMIT 20
+ *
+ * Uses to_jsonb() on a subselect instead of json_build_object() to avoid
+ * PostgreSQL's 100-argument function limit (models with >50 scalar fields
+ * would exceed this). Column aliases in the inner SELECT handle the
+ * dbName→tsName remapping at zero cost.
  */
 
 import type {
@@ -183,14 +192,16 @@ export function buildLateralJoinQuery(params: {
     const relatedModelMeta = modelMap.get(relationMeta.relatedModel);
     if (!relatedModelMeta) continue;
 
-    // Build json_build_object fields for the related model.
+    // Build aliased column list for the inner subquery.
+    // Uses to_jsonb("__sub".*) instead of json_build_object() to avoid
+    // PostgreSQL's 100-argument function limit on wide models.
     // Respect nested select/omit to avoid serialising columns the caller doesn't need.
     const relatedScalars = resolveRelatedScalars({
       relatedModelMeta,
       nestedArgs,
     });
-    const jsonFields = relatedScalars
-      .map((f) => `'${f.name}', ${relatedAlias}."${f.dbName}"`)
+    const columnAliases = relatedScalars
+      .map((f) => `${relatedAlias}."${f.dbName}" AS "${f.name}"`)
       .join(", ");
 
     let lateralSubquery: string;
@@ -288,22 +299,27 @@ export function buildLateralJoinQuery(params: {
         allValues.push(nestedArgs.skip);
       }
 
-      // When take or skip is specified, use a subquery to apply per-parent LIMIT/OFFSET properly
+      // Wrap in inner subquery with column aliases + to_jsonb to avoid
+      // PostgreSQL's 100-argument limit on json_build_object.
       if (nestedArgs.take !== undefined || nestedArgs.skip !== undefined) {
         lateralSubquery = `LEFT JOIN LATERAL (
-    SELECT COALESCE(jsonb_agg(json_build_object(${jsonFields})${orderBySql}), '[]'::jsonb) AS "${colAlias}"
+    SELECT COALESCE(jsonb_agg(to_jsonb("__sub".*)), '[]'::jsonb) AS "${colAlias}"
     FROM (
-      SELECT ${relatedAlias}.* FROM "${relatedModelMeta.dbName}" ${relatedAlias}
+      SELECT ${columnAliases}
+      FROM "${relatedModelMeta.dbName}" ${relatedAlias}
       ${junctionJoin}
       WHERE ${subWhere}${nestedWhereSql}${orderBySql}${limitSql}${offsetSql}
-    ) ${relatedAlias}
+    ) "__sub"
   ) ${alias} ON true`;
       } else {
         lateralSubquery = `LEFT JOIN LATERAL (
-    SELECT COALESCE(jsonb_agg(json_build_object(${jsonFields})${orderBySql}), '[]'::jsonb) AS "${colAlias}"
-    FROM "${relatedModelMeta.dbName}" ${relatedAlias}
-    ${junctionJoin}
-    WHERE ${subWhere}${nestedWhereSql}
+    SELECT COALESCE(jsonb_agg(to_jsonb("__sub".*)), '[]'::jsonb) AS "${colAlias}"
+    FROM (
+      SELECT ${columnAliases}
+      FROM "${relatedModelMeta.dbName}" ${relatedAlias}
+      ${junctionJoin}
+      WHERE ${subWhere}${nestedWhereSql}${orderBySql}
+    ) "__sub"
   ) ${alias} ON true`;
       }
 
@@ -396,24 +412,29 @@ export function buildLateralJoinQuery(params: {
           allValues.push(nestedArgs.skip);
         }
 
-        // When take or skip is specified, use a subquery to apply per-parent LIMIT/OFFSET properly
+        // Wrap in inner subquery with column aliases + to_jsonb to avoid
+        // PostgreSQL's 100-argument limit on json_build_object.
         if (nestedArgs.take !== undefined || nestedArgs.skip !== undefined) {
           lateralSubquery = `LEFT JOIN LATERAL (
-    SELECT COALESCE(jsonb_agg(json_build_object(${jsonFields})${orderBySql}), '[]'::jsonb) AS "${colAlias}"
+    SELECT COALESCE(jsonb_agg(to_jsonb("__sub".*)), '[]'::jsonb) AS "${colAlias}"
     FROM (
-      SELECT * FROM "${relatedModelMeta.dbName}" ${relatedAlias}
+      SELECT ${columnAliases}
+      FROM "${relatedModelMeta.dbName}" ${relatedAlias}
       WHERE ${subWhere}${nestedWhereSql}${orderBySql}${limitSql}${offsetSql}
-    ) ${relatedAlias}
+    ) "__sub"
   ) ${alias} ON true`;
         } else {
           lateralSubquery = `LEFT JOIN LATERAL (
-    SELECT COALESCE(jsonb_agg(json_build_object(${jsonFields})${orderBySql}), '[]'::jsonb) AS "${colAlias}"
-    FROM "${relatedModelMeta.dbName}" ${relatedAlias}
-    WHERE ${subWhere}${nestedWhereSql}
+    SELECT COALESCE(jsonb_agg(to_jsonb("__sub".*)), '[]'::jsonb) AS "${colAlias}"
+    FROM (
+      SELECT ${columnAliases}
+      FROM "${relatedModelMeta.dbName}" ${relatedAlias}
+      WHERE ${subWhere}${nestedWhereSql}${orderBySql}
+    ) "__sub"
   ) ${alias} ON true`;
         }
       } else {
-        // To-one: use json_build_object with LIMIT 1
+        // To-one: use to_jsonb on subselect with LIMIT 1
         let joinCondition: string;
 
         if (fkTable === "parent") {
@@ -432,10 +453,13 @@ export function buildLateralJoinQuery(params: {
         }
 
         lateralSubquery = `LEFT JOIN LATERAL (
-    SELECT json_build_object(${jsonFields}) AS "${colAlias}"
-    FROM "${relatedModelMeta.dbName}" ${relatedAlias}
-    WHERE ${joinCondition}
-    LIMIT 1
+    SELECT to_jsonb("__sub".*) AS "${colAlias}"
+    FROM (
+      SELECT ${columnAliases}
+      FROM "${relatedModelMeta.dbName}" ${relatedAlias}
+      WHERE ${joinCondition}
+      LIMIT 1
+    ) "__sub"
   ) ${alias} ON true`;
       }
     }
@@ -886,7 +910,7 @@ export function whereHasRelationFilter(params: {
 }
 
 /**
- * Resolve which scalar columns to include in a lateral join's json_build_object.
+ * Resolve which scalar columns to include in a lateral join's inner subquery.
  * Respects nested select/omit so we don't serialise unnecessary columns.
  * Always includes the PK so nested relation loading can stitch correctly.
  */