@budibase/backend-core 2.31.8 → 2.32.0

package/dist/index.js

@@ -54288,6 +54288,9 @@ var AuditedEventFriendlyName = {
   // EMAIL
   ["email:smtp:created" /* EMAIL_SMTP_CREATED */]: `Email configuration created`,
   ["email:smtp:updated" /* EMAIL_SMTP_UPDATED */]: `Email configuration updated`,
+  // AI
+  ["ai:config:created" /* AI_CONFIG_CREATED */]: `AI configuration created`,
+  ["ai:config:updated" /* AI_CONFIG_UPDATED */]: `AI configuration updated`,
   // AUTH
   ["auth:sso:created" /* AUTH_SSO_CREATED */]: `SSO configuration created`,
   ["auth:sso:updated" /* AUTH_SSO_UPDATED */]: `SSO configuration updated`,
@@ -55353,7 +55356,7 @@ function fixupFilterArrays(filters) {
   recurseLogicalOperators(filters, fixupFilterArrays);
   return filters;
 }
-var search = (docs, query) => {
+function search(docs, query) {
   let result = runQuery(docs, query.query);
   if (query.sort) {
     result = sort(result, query.sort, query.sortOrder || "ascending" /* ASCENDING */);
@@ -55367,8 +55370,8 @@ var search = (docs, query) => {
     response.totalRows = totalRows;
   }
   return response;
-};
-var runQuery = (docs, query, findInDoc = deepGet) => {
+}
+function runQuery(docs, query) {
   if (!docs || !Array.isArray(docs)) {
     return [];
   }
@@ -55382,7 +55385,7 @@ var runQuery = (docs, query, findInDoc = deepGet) => {
   }
   const match = (type, test) => (doc) => {
     for (const [key, testValue] of Object.entries(query[type] || {})) {
-      const valueToCheck = isLogicalSearchOperator(type) ? doc : findInDoc(doc, removeKeyNumbering(key));
+      const valueToCheck = isLogicalSearchOperator(type) ? doc : deepGet(doc, removeKeyNumbering(key));
       const result = test(valueToCheck, testValue);
       if (query.allOr && result) {
         return true;
@@ -55606,8 +55609,8 @@ var runQuery = (docs, query, findInDoc = deepGet) => {
     }
   };
   return docs.filter(docMatch);
-};
-var sort = (docs, sort2, sortOrder, sortType = "string" /* STRING */) => {
+}
+function sort(docs, sort2, sortOrder, sortType = "string" /* STRING */) {
   if (!sort2 || !sortOrder || !sortType) {
     return docs;
   }
@@ -55629,14 +55632,14 @@ var sort = (docs, sort2, sortOrder, sortType = "string" /* STRING */) => {
     }
     return result;
   });
-};
-var limit = (docs, limit2) => {
+}
+function limit(docs, limit2) {
   const numLimit = parseFloat(limit2);
   if (isNaN(numLimit)) {
     return docs;
   }
   return docs.slice(0, numLimit);
-};
+}
 var hasFilters = (query) => {
   if (!query) {
     return false;
@@ -56297,6 +56300,7 @@ var environment = {
   // Couch/search
   SQL_LOGGING_ENABLE: process.env.SQL_LOGGING_ENABLE,
   SQL_MAX_ROWS: process.env.SQL_MAX_ROWS,
+  SQL_MAX_RELATED_ROWS: process.env.MAX_RELATED_ROWS,
   // smtp
   SMTP_FALLBACK_ENABLED: process.env.SMTP_FALLBACK_ENABLED,
   SMTP_USER: process.env.SMTP_USER,
@@ -56788,7 +56792,8 @@ __export(utils_exports3, {
   isValidFilter: () => isValidFilter,
   isValidISODateString: () => isValidISODateString,
   isValidTime: () => isValidTime,
-  sqlLog: () => sqlLog
+  sqlLog: () => sqlLog,
+  validateManyToMany: () => validateManyToMany
 });
 
 // src/db/index.ts
@@ -59762,6 +59767,15 @@ function sqlLog(client, query, values2) {
   }
   console.log(string);
 }
+function isValidManyToManyRelationship(relationship) {
+  return !!relationship.through && !!relationship.fromPrimary && !!relationship.from && !!relationship.toPrimary && !!relationship.to;
+}
+function validateManyToMany(relationship) {
+  if (isValidManyToManyRelationship(relationship)) {
+    return relationship;
+  }
+  return void 0;
+}
 
 // src/features/index.ts
 var features_exports = {};
@@ -59953,7 +59967,9 @@ var FlagSet = class {
 };
 var flags = new FlagSet({
   DEFAULT_VALUES: Flag.boolean(environment_default.isDev()),
+  AUTOMATION_BRANCHING: Flag.boolean(environment_default.isDev()),
   SQS: Flag.boolean(environment_default.isDev()),
+  ["AI_CUSTOM_CONFIGS" /* AI_CUSTOM_CONFIGS */]: Flag.boolean(environment_default.isDev()),
   ["ENRICHED_RELATIONSHIPS" /* ENRICHED_RELATIONSHIPS */]: Flag.boolean(false)
 });
 
@@ -62307,6 +62323,7 @@ async function getAccountHolderFromUserIds(userIds) {
 var events_exports = {};
 __export(events_exports, {
   account: () => account_default,
+  ai: () => ai_default,
   analytics: () => analytics_exports,
   app: () => app_default,
   auditLog: () => auditLog_default,
@@ -63891,6 +63908,20 @@ var email_default = {
   SMTPUpdated
 };
 
+// src/events/publishers/ai.ts
+async function AIConfigCreated(timestamp) {
+  const properties = {};
+  await publishEvent("ai:config:created" /* AI_CONFIG_CREATED */, properties, timestamp);
+}
+async function AIConfigUpdated() {
+  const properties = {};
+  await publishEvent("ai:config:updated" /* AI_CONFIG_UPDATED */, properties);
+}
+var ai_default = {
+  AIConfigCreated,
+  AIConfigUpdated
+};
+
 // src/events/publishers/license.ts
 async function planChanged(account, opts) {
   const properties = {
@@ -67953,10 +67984,15 @@ var sqlTable_default = SqlTableQueryBuilder;
 
 // src/sql/sql.ts
 var import_lodash3 = require("lodash");
+var MAX_SQS_RELATIONSHIP_FIELDS = 63;
 function getBaseLimit() {
   const envLimit = environment_default.SQL_MAX_ROWS ? parseInt(environment_default.SQL_MAX_ROWS) : null;
   return envLimit || 5e3;
 }
+function getRelationshipLimit() {
+  const envLimit = environment_default.SQL_MAX_RELATED_ROWS ? parseInt(environment_default.SQL_MAX_RELATED_ROWS) : null;
+  return envLimit || 500;
+}
 function getTableName(table) {
   if (table?.sourceType === "internal" /* INTERNAL */ || table?.sourceId === INTERNAL_TABLE_SOURCE_ID) {
     return table?._id;
@@ -67981,6 +68017,15 @@ function convertBooleans(query) {
 }
 var InternalBuilder = class {
   constructor(client, knex3, query) {
+    // states the various situations in which we need a full mapped select statement
+    this.SPECIAL_SELECT_CASES = {
+      POSTGRES_MONEY: (field) => {
+        return this.client === "pg" /* POSTGRES */ && field?.externalType?.includes("money");
+      },
+      MSSQL_DATES: (field) => {
+        return this.client === "mssql" /* MS_SQL */ && field?.type === "datetime" /* DATETIME */ && field.timeOnly;
+      }
+    };
     this.client = client;
     this.query = query;
     this.knex = knex3;
@@ -68015,48 +68060,50 @@ var InternalBuilder = class {
   quotedIdentifier(key) {
     return key.split(".").map((part) => this.quote(part)).join(".");
   }
+  isFullSelectStatementRequired() {
+    const { meta } = this.query;
+    for (let column of Object.values(meta.table.schema)) {
+      if (this.SPECIAL_SELECT_CASES.POSTGRES_MONEY(column)) {
+        return true;
+      } else if (this.SPECIAL_SELECT_CASES.MSSQL_DATES(column)) {
+        return true;
+      }
+    }
+    return false;
+  }
   generateSelectStatement() {
-    const { resource, meta } = this.query;
+    const { meta, endpoint, resource, tableAliases } = this.query;
     if (!resource || !resource.fields || resource.fields.length === 0) {
       return "*";
     }
+    const alias = tableAliases?.[endpoint.entityId] ? tableAliases?.[endpoint.entityId] : endpoint.entityId;
     const schema = meta.table.schema;
+    if (!this.isFullSelectStatementRequired()) {
+      return [this.knex.raw(`${this.quote(alias)}.*`)];
+    }
     return resource.fields.map((field) => {
       const parts = field.split(/\./g);
       let table = void 0;
-      let column = void 0;
-      if (parts.length === 1) {
-        column = parts[0];
-      }
-      if (parts.length === 2) {
-        table = parts[0];
-        column = parts[1];
-      }
-      if (parts.length > 2) {
+      let column = parts[0];
+      if (parts.length > 1) {
         table = parts[0];
         column = parts.slice(1).join(".");
       }
-      if (!column) {
-        throw new Error(`Invalid field name: ${field}`);
-      }
+      return { table, column, field };
+    }).filter(({ table }) => !table || table === alias).map(({ table, column, field }) => {
       const columnSchema = schema[column];
-      if (this.client === "pg" /* POSTGRES */ && columnSchema?.externalType?.includes("money")) {
+      if (this.SPECIAL_SELECT_CASES.POSTGRES_MONEY(columnSchema)) {
         return this.knex.raw(
           `${this.quotedIdentifier(
             [table, column].join(".")
           )}::money::numeric as ${this.quote(field)}`
         );
       }
-      if (this.client === "mssql" /* MS_SQL */ && columnSchema?.type === "datetime" /* DATETIME */ && columnSchema.timeOnly) {
+      if (this.SPECIAL_SELECT_CASES.MSSQL_DATES(columnSchema)) {
         return this.knex.raw(`CONVERT(varchar, ${field}, 108) as "${field}"`);
       }
-      if (table) {
-        return this.knex.raw(
-          `${this.quote(table)}.${this.quote(column)} as ${this.quote(field)}`
-        );
-      } else {
-        return this.knex.raw(`${this.quote(field)} as ${this.quote(field)}`);
-      }
+      const quoted = table ? `${this.quote(table)}.${this.quote(column)}` : this.quote(field);
+      return this.knex.raw(quoted);
     });
   }
   // OracleDB can't use character-large-objects (CLOBs) in WHERE clauses,
@@ -68167,28 +68214,94 @@ var InternalBuilder = class {
     }
     return filters;
   }
+  addJoinFieldCheck(query, relationship) {
+    const document = relationship.from?.split(".")[0] || "";
+    return query.andWhere(`${document}.fieldName`, "=", relationship.column);
+  }
+  addRelationshipForFilter(query, filterKey, whereCb) {
+    const mainKnex = this.knex;
+    const { relationships, endpoint, tableAliases: aliases } = this.query;
+    const tableName = endpoint.entityId;
+    const fromAlias = aliases?.[tableName] || tableName;
+    const matches2 = (possibleTable) => filterKey.startsWith(`${possibleTable}`);
+    if (!relationships) {
+      return query;
+    }
+    for (const relationship of relationships) {
+      const relatedTableName = relationship.tableName;
+      const toAlias = aliases?.[relatedTableName] || relatedTableName;
+      if ((matches2(relatedTableName) || matches2(toAlias)) && relationship.to && relationship.tableName) {
+        let subQuery = mainKnex.select(mainKnex.raw(1)).from({ [toAlias]: relatedTableName });
+        const manyToMany = validateManyToMany(relationship);
+        if (manyToMany) {
+          const throughAlias = aliases?.[manyToMany.through] || relationship.through;
+          let throughTable = this.tableNameWithSchema(manyToMany.through, {
+            alias: throughAlias,
+            schema: endpoint.schema
+          });
+          subQuery = subQuery.innerJoin(throughTable, function() {
+            this.on(
+              `${toAlias}.${manyToMany.toPrimary}`,
+              "=",
+              `${throughAlias}.${manyToMany.to}`
+            );
+          }).where(
+            `${throughAlias}.${manyToMany.from}`,
+            "=",
+            mainKnex.raw(
+              this.quotedIdentifier(`${fromAlias}.${manyToMany.fromPrimary}`)
+            )
+          );
+          if (this.client === "sqlite3" /* SQL_LITE */) {
+            subQuery = this.addJoinFieldCheck(subQuery, manyToMany);
+          }
+        } else {
+          subQuery = subQuery.where(
+            `${toAlias}.${relationship.to}`,
+            "=",
+            mainKnex.raw(
+              this.quotedIdentifier(`${fromAlias}.${relationship.from}`)
+            )
+          );
+        }
+        query = query.whereExists(whereCb(subQuery));
+        break;
+      }
+    }
+    return query;
+  }
   // right now we only do filters on the specific table being queried
   addFilters(query, filters, opts) {
     if (!filters) {
       return query;
     }
+    const builder = this;
     filters = this.parseFilters({ ...filters });
     const aliases = this.query.tableAliases;
     const allOr = filters.allOr;
-    const tableName = this.client === "sqlite3" /* SQL_LITE */ ? this.table._id : this.table.name;
+    const isSqlite = this.client === "sqlite3" /* SQL_LITE */;
+    const tableName = isSqlite ? this.table._id : this.table.name;
     function getTableAlias(name) {
       const alias = aliases?.[name];
       return alias || name;
     }
     function iterate(structure, fn, complexKeyFn) {
+      const handleRelationship = (q2, key, value) => {
+        const [filterTableName, ...otherProperties] = key.split(".");
+        const property = otherProperties.join(".");
+        const alias = getTableAlias(filterTableName);
+        return fn(q2, alias ? `${alias}.${property}` : property, value);
+      };
       for (const key in structure) {
         const value = structure[key];
         const updatedKey = removeKeyNumbering2(key);
         const isRelationshipField = updatedKey.includes(".");
+        const shouldProcessRelationship = opts?.relationship && isRelationshipField;
         let castedTypeValue;
         if (key === "_complexIdOperator" /* COMPLEX_ID_OPERATOR */ && (castedTypeValue = structure[key]) && complexKeyFn) {
           const alias = getTableAlias(tableName);
-          complexKeyFn(
+          query = complexKeyFn(
+            query,
             castedTypeValue.id.map(
               (x) => alias ? `${alias}.${x}` : x
             ),
@@ -68196,23 +68309,26 @@ var InternalBuilder = class {
           );
         } else if (!isRelationshipField) {
           const alias = getTableAlias(tableName);
-          fn(alias ? `${alias}.${updatedKey}` : updatedKey, value);
-        }
-        if (opts?.relationship && isRelationshipField) {
-          const [filterTableName, property] = updatedKey.split(".");
-          const alias = getTableAlias(filterTableName);
-          fn(alias ? `${alias}.${property}` : property, value);
+          query = fn(
+            query,
+            alias ? `${alias}.${updatedKey}` : updatedKey,
+            value
+          );
+        } else if (shouldProcessRelationship) {
+          query = builder.addRelationshipForFilter(query, updatedKey, (q2) => {
+            return handleRelationship(q2, updatedKey, value);
+          });
         }
       }
     }
-    const like = (key, value) => {
+    const like = (q2, key, value) => {
       const fuzzyOr = filters?.fuzzyOr;
       const fnc = fuzzyOr || allOr ? "orWhere" : "where";
       if (this.client === "pg" /* POSTGRES */) {
-        query = query[fnc](key, "ilike", `%${value}%`);
+        return q2[fnc](key, "ilike", `%${value}%`);
       } else {
         const rawFnc = `${fnc}Raw`;
-        query = query[rawFnc](`LOWER(${this.quotedIdentifier(key)}) LIKE ?`, [
+        return q2[rawFnc](`LOWER(${this.quotedIdentifier(key)}) LIKE ?`, [
           `%${value.toLowerCase()}%`
         ]);
       }
@@ -68229,13 +68345,13 @@ var InternalBuilder = class {
         return `[${value.join(",")}]`;
       }
       if (this.client === "pg" /* POSTGRES */) {
-        iterate(mode, (key, value) => {
+        iterate(mode, (q2, key, value) => {
           const wrap = any ? "" : "'";
           const op = any ? "\\?| array" : "@>";
           const fieldNames = key.split(/\./g);
           const table = fieldNames[0];
           const col = fieldNames[1];
-          query = query[rawFnc](
+          return q2[rawFnc](
             `${not}COALESCE("${table}"."${col}"::jsonb ${op} ${wrap}${stringifyArray(
               value,
               any ? "'" : '"'
@@ -68244,8 +68360,8 @@ var InternalBuilder = class {
         });
       } else if (this.client === "mysql2" /* MY_SQL */) {
         const jsonFnc = any ? "JSON_OVERLAPS" : "JSON_CONTAINS";
-        iterate(mode, (key, value) => {
-          query = query[rawFnc](
+        iterate(mode, (q2, key, value) => {
+          return q2[rawFnc](
             `${not}COALESCE(${jsonFnc}(${key}, '${stringifyArray(
               value
             )}'), FALSE)`
@@ -68253,7 +68369,7 @@ var InternalBuilder = class {
         });
       } else {
         const andOr = mode === filters?.containsAny ? " OR " : " AND ";
-        iterate(mode, (key, value) => {
+        iterate(mode, (q2, key, value) => {
           let statement = "";
           const identifier = this.quotedIdentifier(key);
           for (let i in value) {
@@ -68265,15 +68381,15 @@ var InternalBuilder = class {
             statement += `${statement ? andOr : ""}COALESCE(LOWER(${identifier}), '') LIKE ?`;
           }
           if (statement === "") {
-            return;
+            return q2;
           }
           if (not) {
-            query = query[rawFnc](
+            return q2[rawFnc](
               `(NOT (${statement}) OR ${identifier} IS NULL)`,
               value
             );
           } else {
-            query = query[rawFnc](statement, value);
+            return q2[rawFnc](statement, value);
           }
         });
       }
@@ -68300,35 +68416,35 @@ var InternalBuilder = class {
       const fnc = allOr ? "orWhereIn" : "whereIn";
       iterate(
         filters.oneOf,
-        (key, array) => {
+        (q2, key, array) => {
           if (this.client === "oracledb" /* ORACLE */) {
             key = this.convertClobs(key);
             array = Array.isArray(array) ? array : [array];
             const binding = new Array(array.length).fill("?").join(",");
-            query = query.whereRaw(`${key} IN (${binding})`, array);
+            return q2.whereRaw(`${key} IN (${binding})`, array);
           } else {
-            query = query[fnc](key, Array.isArray(array) ? array : [array]);
+            return q2[fnc](key, Array.isArray(array) ? array : [array]);
           }
         },
-        (key, array) => {
+        (q2, key, array) => {
           if (this.client === "oracledb" /* ORACLE */) {
             const keyStr = `(${key.map((k) => this.convertClobs(k)).join(",")})`;
             const binding = `(${array.map((a) => `(${new Array(a.length).fill("?").join(",")})`).join(",")})`;
-            query = query.whereRaw(`${keyStr} IN ${binding}`, array.flat());
+            return q2.whereRaw(`${keyStr} IN ${binding}`, array.flat());
           } else {
-            query = query[fnc](key, Array.isArray(array) ? array : [array]);
+            return q2[fnc](key, Array.isArray(array) ? array : [array]);
           }
         }
       );
     }
     if (filters.string) {
-      iterate(filters.string, (key, value) => {
+      iterate(filters.string, (q2, key, value) => {
         const fnc = allOr ? "orWhere" : "where";
         if (this.client === "pg" /* POSTGRES */) {
-          query = query[fnc](key, "ilike", `${value}%`);
+          return q2[fnc](key, "ilike", `${value}%`);
         } else {
           const rawFnc = `${fnc}Raw`;
-          query = query[rawFnc](`LOWER(${this.quotedIdentifier(key)}) LIKE ?`, [
+          return q2[rawFnc](`LOWER(${this.quotedIdentifier(key)}) LIKE ?`, [
             `${value.toLowerCase()}%`
           ]);
         }
@@ -68338,7 +68454,7 @@ var InternalBuilder = class {
       iterate(filters.fuzzy, like);
     }
     if (filters.range) {
-      iterate(filters.range, (key, value) => {
+      iterate(filters.range, (q2, key, value) => {
         const isEmptyObject = (val) => {
           return val && Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
         };
@@ -68355,91 +68471,87 @@ var InternalBuilder = class {
         }
         if (lowValid && highValid) {
           if (schema?.type === "bigint" /* BIGINT */ && this.client === "sqlite3" /* SQL_LITE */) {
-            query = query.whereRaw(
+            return q2.whereRaw(
               `CAST(${key} AS INTEGER) BETWEEN CAST(? AS INTEGER) AND CAST(? AS INTEGER)`,
               [value.low, value.high]
             );
           } else {
             const fnc = allOr ? "orWhereBetween" : "whereBetween";
-            query = query[fnc](key, [value.low, value.high]);
+            return q2[fnc](key, [value.low, value.high]);
           }
         } else if (lowValid) {
           if (schema?.type === "bigint" /* BIGINT */ && this.client === "sqlite3" /* SQL_LITE */) {
-            query = query.whereRaw(
-              `CAST(${key} AS INTEGER) >= CAST(? AS INTEGER)`,
-              [value.low]
-            );
+            return q2.whereRaw(`CAST(${key} AS INTEGER) >= CAST(? AS INTEGER)`, [
+              value.low
+            ]);
           } else {
             const fnc = allOr ? "orWhere" : "where";
-            query = query[fnc](key, ">=", value.low);
+            return q2[fnc](key, ">=", value.low);
           }
         } else if (highValid) {
           if (schema?.type === "bigint" /* BIGINT */ && this.client === "sqlite3" /* SQL_LITE */) {
-            query = query.whereRaw(
-              `CAST(${key} AS INTEGER) <= CAST(? AS INTEGER)`,
-              [value.high]
-            );
+            return q2.whereRaw(`CAST(${key} AS INTEGER) <= CAST(? AS INTEGER)`, [
+              value.high
+            ]);
           } else {
             const fnc = allOr ? "orWhere" : "where";
-            query = query[fnc](key, "<=", value.high);
+            return q2[fnc](key, "<=", value.high);
           }
         }
+        return q2;
       });
     }
     if (filters.equal) {
-      iterate(filters.equal, (key, value) => {
+      iterate(filters.equal, (q2, key, value) => {
         const fnc = allOr ? "orWhereRaw" : "whereRaw";
         if (this.client === "mssql" /* MS_SQL */) {
-          query = query[fnc](
+          return q2[fnc](
             `CASE WHEN ${this.quotedIdentifier(key)} = ? THEN 1 ELSE 0 END = 1`,
             [value]
           );
         } else if (this.client === "oracledb" /* ORACLE */) {
           const identifier = this.convertClobs(key);
-          query = query[fnc](
-            `(${identifier} IS NOT NULL AND ${identifier} = ?)`,
-            [value]
-          );
+          return q2[fnc](`(${identifier} IS NOT NULL AND ${identifier} = ?)`, [
+            value
+          ]);
         } else {
-          query = query[fnc](
-            `COALESCE(${this.quotedIdentifier(key)} = ?, FALSE)`,
-            [value]
-          );
+          return q2[fnc](`COALESCE(${this.quotedIdentifier(key)} = ?, FALSE)`, [
+            value
+          ]);
         }
       });
     }
     if (filters.notEqual) {
-      iterate(filters.notEqual, (key, value) => {
+      iterate(filters.notEqual, (q2, key, value) => {
         const fnc = allOr ? "orWhereRaw" : "whereRaw";
         if (this.client === "mssql" /* MS_SQL */) {
-          query = query[fnc](
+          return q2[fnc](
             `CASE WHEN ${this.quotedIdentifier(key)} = ? THEN 1 ELSE 0 END = 0`,
             [value]
           );
         } else if (this.client === "oracledb" /* ORACLE */) {
           const identifier = this.convertClobs(key);
-          query = query[fnc](
+          return q2[fnc](
             `(${identifier} IS NOT NULL AND ${identifier} != ?) OR ${identifier} IS NULL`,
             [value]
           );
         } else {
-          query = query[fnc](
-            `COALESCE(${this.quotedIdentifier(key)} != ?, TRUE)`,
-            [value]
-          );
+          return q2[fnc](`COALESCE(${this.quotedIdentifier(key)} != ?, TRUE)`, [
+            value
+          ]);
         }
       });
     }
     if (filters.empty) {
-      iterate(filters.empty, (key) => {
+      iterate(filters.empty, (q2, key) => {
         const fnc = allOr ? "orWhereNull" : "whereNull";
-        query = query[fnc](key);
+        return q2[fnc](key);
       });
     }
     if (filters.notEmpty) {
-      iterate(filters.notEmpty, (key) => {
+      iterate(filters.notEmpty, (q2, key) => {
         const fnc = allOr ? "orWhereNotNull" : "whereNotNull";
-        query = query[fnc](key);
+        return q2[fnc](key);
       });
     }
     if (filters.contains) {
@@ -68507,10 +68619,166 @@ var InternalBuilder = class {
     }
     return withSchema;
   }
-  addRelationships(query, fromTable, relationships, schema, aliases) {
-    if (!relationships) {
-      return query;
+  addJsonRelationships(query, fromTable, relationships) {
+    const sqlClient = this.client;
+    const knex3 = this.knex;
+    const { resource, tableAliases: aliases, endpoint } = this.query;
+    const fields = resource?.fields || [];
+    const jsonField = (field) => {
+      const parts = field.split(".");
+      let tableField, unaliased;
+      if (parts.length > 1) {
+        const alias = parts.shift();
+        unaliased = parts.join(".");
+        tableField = `${this.quote(alias)}.${this.quote(unaliased)}`;
+      } else {
+        unaliased = parts.join(".");
+        tableField = this.quote(unaliased);
+      }
+      let separator = ",";
+      switch (sqlClient) {
+        case "oracledb" /* ORACLE */:
+          separator = " VALUE ";
+          break;
+        case "mssql" /* MS_SQL */:
+          separator = ":";
+      }
+      return `'${unaliased}'${separator}${tableField}`;
+    };
+    for (let relationship of relationships) {
+      const {
+        tableName: toTable,
+        through: throughTable,
+        to: toKey,
+        from: fromKey,
+        fromPrimary,
+        toPrimary
+      } = relationship;
+      if (!toTable || !fromTable) {
+        continue;
+      }
+      const toAlias = aliases?.[toTable] || toTable, fromAlias = aliases?.[fromTable] || fromTable;
+      let toTableWithSchema = this.tableNameWithSchema(toTable, {
+        alias: toAlias,
+        schema: endpoint.schema
+      });
+      let relationshipFields = fields.filter(
+        (field) => field.split(".")[0] === toAlias
+      );
+      if (this.client === "sqlite3" /* SQL_LITE */) {
+        relationshipFields = relationshipFields.slice(
+          0,
+          MAX_SQS_RELATIONSHIP_FIELDS
+        );
+      }
+      const fieldList = relationshipFields.map((field) => jsonField(field)).join(",");
+      const primaryKey = `${toAlias}.${toPrimary || toKey}`;
+      let subQuery = knex3.from(toTableWithSchema).limit(getRelationshipLimit()).orderBy(primaryKey);
+      if (throughTable && toPrimary && fromPrimary) {
+        const throughAlias = aliases?.[throughTable] || throughTable;
+        let throughTableWithSchema = this.tableNameWithSchema(throughTable, {
+          alias: throughAlias,
+          schema: endpoint.schema
+        });
+        subQuery = subQuery.join(throughTableWithSchema, function() {
+          this.on(`${toAlias}.${toPrimary}`, "=", `${throughAlias}.${toKey}`);
+        }).where(
+          `${throughAlias}.${fromKey}`,
+          "=",
+          knex3.raw(this.quotedIdentifier(`${fromAlias}.${fromPrimary}`))
+        );
+      } else {
+        subQuery = subQuery.where(
+          `${toAlias}.${toKey}`,
+          "=",
+          knex3.raw(this.quotedIdentifier(`${fromAlias}.${fromKey}`))
+        );
+      }
+      const standardWrap = (select) => {
+        subQuery = subQuery.select(`${toAlias}.*`);
+        return knex3.select(knex3.raw(select)).from({
+          [toAlias]: subQuery
+        });
+      };
+      let wrapperQuery;
+      switch (sqlClient) {
+        case "sqlite3" /* SQL_LITE */:
+          subQuery = this.addJoinFieldCheck(subQuery, relationship);
+          wrapperQuery = standardWrap(
+            `json_group_array(json_object(${fieldList}))`
+          );
+          break;
+        case "pg" /* POSTGRES */:
+          wrapperQuery = standardWrap(
+            `json_agg(json_build_object(${fieldList}))`
+          );
+          break;
+        case "mysql2" /* MY_SQL */:
+          wrapperQuery = subQuery.select(
+            knex3.raw(`json_arrayagg(json_object(${fieldList}))`)
+          );
+          break;
+        case "oracledb" /* ORACLE */:
+          wrapperQuery = standardWrap(
+            `json_arrayagg(json_object(${fieldList}))`
+          );
+          break;
+        case "mssql" /* MS_SQL */:
+          wrapperQuery = knex3.raw(
+            `(SELECT ${this.quote(toAlias)} = (${knex3.select(`${fromAlias}.*`).from({
+              [fromAlias]: subQuery.select(`${toAlias}.*`)
+            })} FOR JSON PATH))`
+          );
+          break;
+        default:
+          throw new Error(`JSON relationships not implement for ${sqlClient}`);
+      }
+      query = query.select({ [relationship.column]: wrapperQuery });
     }
+    return query;
+  }
+  addJoin(query, tables, columns) {
+    const { tableAliases: aliases, endpoint } = this.query;
+    const schema = endpoint.schema;
+    const toTable = tables.to, fromTable = tables.from, throughTable = tables.through;
+    const toAlias = aliases?.[toTable] || toTable, throughAlias = throughTable && aliases?.[throughTable] || throughTable, fromAlias = aliases?.[fromTable] || fromTable;
+    let toTableWithSchema = this.tableNameWithSchema(toTable, {
+      alias: toAlias,
+      schema
+    });
+    let throughTableWithSchema = throughTable ? this.tableNameWithSchema(throughTable, {
+      alias: throughAlias,
+      schema
+    }) : void 0;
+    if (!throughTable) {
+      query = query.leftJoin(toTableWithSchema, function() {
+        for (let relationship of columns) {
+          const from = relationship.from, to = relationship.to;
+          this.orOn(`${fromAlias}.${from}`, "=", `${toAlias}.${to}`);
+        }
+      });
+    } else {
+      query = query.leftJoin(throughTableWithSchema, function() {
+        for (let relationship of columns) {
+          const fromPrimary = relationship.fromPrimary;
+          const from = relationship.from;
+          this.orOn(
+            `${fromAlias}.${fromPrimary}`,
+            "=",
+            `${throughAlias}.${from}`
+          );
+        }
+      }).leftJoin(toTableWithSchema, function() {
+        for (let relationship of columns) {
+          const toPrimary = relationship.toPrimary;
+          const to = relationship.to;
+          this.orOn(`${toAlias}.${toPrimary}`, `${throughAlias}.${to}`);
+        }
+      });
+    }
+    return query;
+  }
+  addRelationships(query, fromTable, relationships) {
     const tableSets = {};
     for (let relationship of relationships) {
       const keyObj = {
@@ -68529,41 +68797,15 @@ var InternalBuilder = class {
     }
     for (let [key, relationships2] of Object.entries(tableSets)) {
       const { toTable, throughTable } = JSON.parse(key);
-      const toAlias = aliases?.[toTable] || toTable, throughAlias = aliases?.[throughTable] || throughTable, fromAlias = aliases?.[fromTable] || fromTable;
-      let toTableWithSchema = this.tableNameWithSchema(toTable, {
-        alias: toAlias,
-        schema
-      });
-      let throughTableWithSchema = this.tableNameWithSchema(throughTable, {
-        alias: throughAlias,
-        schema
-      });
-      if (!throughTable) {
-        query = query.leftJoin(toTableWithSchema, function() {
-          for (let relationship of relationships2) {
-            const from = relationship.from, to = relationship.to;
-            this.orOn(`${fromAlias}.${from}`, "=", `${toAlias}.${to}`);
-          }
-        });
-      } else {
-        query = query.leftJoin(throughTableWithSchema, function() {
-          for (let relationship of relationships2) {
-            const fromPrimary = relationship.fromPrimary;
-            const from = relationship.from;
-            this.orOn(
-              `${fromAlias}.${fromPrimary}`,
-              "=",
-              `${throughAlias}.${from}`
-            );
-          }
-        }).leftJoin(toTableWithSchema, function() {
-          for (let relationship of relationships2) {
-            const toPrimary = relationship.toPrimary;
-            const to = relationship.to;
-            this.orOn(`${toAlias}.${toPrimary}`, `${throughAlias}.${to}`);
-          }
-        });
-      }
+      query = this.addJoin(
+        query,
+        {
+          from: fromTable,
+          to: toTable,
+          through: throughTable
+        },
+        relationships2
+      );
     }
     return query;
   }
@@ -68639,7 +68881,7 @@ var InternalBuilder = class {
     return query.upsert(parsedBody);
   }
   read(opts = {}) {
-    let { endpoint, filters, paginate, relationships, tableAliases } = this.query;
+    let { endpoint, filters, paginate, relationships } = this.query;
     const { limits } = opts;
     const counting = endpoint.operation === "COUNT" /* COUNT */;
     const tableName = endpoint.entityId;
@@ -68664,30 +68906,13 @@ var InternalBuilder = class {
       if (foundOffset != null) {
         query = query.offset(foundOffset);
       }
-      query = this.addSorting(query);
     }
-    query = this.addFilters(query, filters);
-    const alias = tableAliases?.[tableName] || tableName;
-    let preQuery = this.knex({
-      // the typescript definition for the knex constructor doesn't support this
-      // syntax, but it is the only way to alias a pre-query result as part of
-      // a query - there is an alias dictionary type, but it assumes it can only
-      // be a table name, not a pre-query
-      [alias]: query
-    });
-    preQuery = !counting ? preQuery.select(this.generateSelectStatement()) : this.addDistinctCount(preQuery);
-    if (this.client !== "mssql" /* MS_SQL */ && !counting) {
-      preQuery = this.addSorting(preQuery);
+    query = !counting ? query.select(this.generateSelectStatement()) : this.addDistinctCount(query);
+    if (!counting) {
+      query = this.addSorting(query);
     }
-    query = this.addRelationships(
-      preQuery,
-      tableName,
-      relationships,
-      endpoint.schema,
-      tableAliases
-    );
-    if (limits?.base) {
-      query = query.limit(limits.base);
+    if (relationships) {
+      query = this.addJsonRelationships(query, tableName, relationships);
     }
     return this.addFilters(query, filters, { relationship: true });
   }