@budibase/backend-core 2.31.8 → 2.32.1

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`,
@@ -55065,6 +55068,12 @@ function decodeNonAscii(str) {
 // ../shared-core/src/filters.ts
 var import_lodash = require("lodash");
 var HBS_REGEX = /{{([^{].*?)}}/g;
+var LOGICAL_OPERATORS = Object.values(LogicalOperator);
+var SEARCH_OPERATORS = [
+  ...Object.values(BasicOperator),
+  ...Object.values(ArrayOperator),
+  ...Object.values(RangeOperator)
+];
 var getValidOperatorsForType = (fieldType, field, datasource2) => {
   const Op = OperatorOptions;
   const stringOps = [
@@ -55125,7 +55134,7 @@ var NoEmptyFilterStrings = [
   OperatorOptions.In.value
 ];
 function recurseLogicalOperators(filters, fn) {
-  for (const logical of Object.values(LogicalOperator)) {
+  for (const logical of LOGICAL_OPERATORS) {
     if (filters[logical]) {
       filters[logical].conditions = filters[logical].conditions.map(
         (condition) => fn(condition)
@@ -55136,7 +55145,7 @@ function recurseLogicalOperators(filters, fn) {
 }
 function recurseSearchFilters(filters, processFn) {
   filters = processFn(filters);
-  for (const logical of Object.values(LogicalOperator)) {
+  for (const logical of LOGICAL_OPERATORS) {
     if (filters[logical]) {
       filters[logical].conditions = filters[logical].conditions.map(
         (condition) => recurseSearchFilters(condition, processFn)
@@ -55353,7 +55362,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 +55376,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 +55391,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;
@@ -55599,15 +55608,17 @@ var runQuery = (docs, query, findInDoc = deepGet) => {
     ).map(([key]) => {
       return filterFunctions[key]?.(doc) ?? false;
     });
-    if (query.allOr) {
+    if (!hasFilters(query)) {
+      return true;
+    } else if (query.allOr) {
       return results.some((result) => result === true);
     } else {
       return results.every((result) => result === true);
     }
   };
   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,28 +55640,45 @@ 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;
   }
-  const skipped = ["allOr", "onEmptyFilter"];
-  for (let [key, value] of Object.entries(query)) {
-    if (skipped.includes(key) || typeof value !== "object") {
-      continue;
+  const check = (filters) => {
+    for (const logical of LOGICAL_OPERATORS) {
+      if (filters[logical]) {
+        for (const condition of filters[logical]?.conditions || []) {
+          const result = check(condition);
+          if (result) {
+            return result;
+          }
+        }
+      }
     }
-    if (Object.keys(value || {}).length !== 0) {
-      return true;
+    for (const search2 of SEARCH_OPERATORS) {
+      const searchValue = filters[search2];
+      if (!searchValue || typeof searchValue !== "object") {
+        continue;
+      }
+      const filtered2 = Object.entries(searchValue).filter((entry2) => {
+        const valueDefined = entry2[1] !== void 0 || entry2[1] !== null || entry2[1] !== "";
+        return search2 === "notEmpty" /* NOT_EMPTY */ || valueDefined;
+      });
+      if (filtered2.length !== 0) {
+        return true;
+      }
     }
-  }
-  return false;
+    return false;
+  };
+  return check(query);
 };
 
 // ../shared-core/src/utils.ts
@@ -56297,6 +56325,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 +56817,8 @@ __export(utils_exports3, {
   isValidFilter: () => isValidFilter,
   isValidISODateString: () => isValidISODateString,
   isValidTime: () => isValidTime,
-  sqlLog: () => sqlLog
+  sqlLog: () => sqlLog,
+  validateManyToMany: () => validateManyToMany
 });
 
 // src/db/index.ts
@@ -59762,6 +59792,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 +59992,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 +62348,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,
@@ -62327,6 +62369,7 @@ __export(events_exports, {
   org: () => org_default,
   plugin: () => plugin_default,
   processors: () => processors_exports,
+  publishEvent: () => publishEvent,
   query: () => query_default,
   role: () => role_default,
   rows: () => rows_default,
@@ -63891,6 +63934,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 = {
@@ -65677,7 +65734,12 @@ async function populateUsersFromDB(userIds) {
   }
   return { users };
 }
-async function getUser(userId, tenantId, populateUser) {
+async function getUser({
+  userId,
+  tenantId,
+  email,
+  populateUser
+}) {
   if (!populateUser) {
     populateUser = populateFromDB2;
   }
@@ -65691,7 +65753,7 @@ async function getUser(userId, tenantId, populateUser) {
   const client = await getUserClient();
   let user = await client.get(userId);
   if (!user) {
-    user = await populateUser(userId, tenantId);
+    user = await populateUser(userId, tenantId, email);
     await client.store(userId, user, EXPIRY_SECONDS3);
   }
   if (user && !user.tenantId && tenantId) {
@@ -66922,7 +66984,11 @@ async function checkApiKey(apiKey, populateUser) {
     if (userId) {
       return {
         valid: true,
-        user: await getUser(userId, tenantId, populateUser)
+        user: await getUser({
+          userId,
+          tenantId,
+          populateUser
+        })
       };
     } else {
       throw new InvalidAPIKeyError();
@@ -66956,13 +67022,18 @@ function authenticated_default(noAuthPatterns = [], opts = {
         try {
           session = await getSession(userId, sessionId);
           if (opts && opts.populateUser) {
-            user = await getUser(
+            user = await getUser({
               userId,
-              session.tenantId,
-              opts.populateUser(ctx)
-            );
+              tenantId: session.tenantId,
+              email: session.email,
+              populateUser: opts.populateUser(ctx)
+            });
           } else {
-            user = await getUser(userId, session.tenantId);
+            user = await getUser({
+              userId,
+              tenantId: session.tenantId,
+              email: session.email
+            });
           }
           user.csrfToken = session.csrfToken;
           if (session?.lastAccessedAt < timeMinusOneMinute()) {
@@ -67953,10 +68024,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 +68057,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 +68100,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 +68254,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 +68349,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 +68385,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 +68400,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 +68409,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 +68421,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 +68456,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 +68494,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 +68511,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,63 +68659,155 @@ var InternalBuilder = class {
     }
     return withSchema;
   }
-  addRelationships(query, fromTable, relationships, schema, aliases) {
-    if (!relationships) {
-      return query;
+  buildJsonField(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);
     }
-    const tableSets = {};
+    const separator = this.client === "oracledb" /* ORACLE */ ? " VALUE " : ",";
+    return `'${unaliased}'${separator}${tableField}`;
+  }
+  addJsonRelationships(query, fromTable, relationships) {
+    const sqlClient = this.client;
+    const knex3 = this.knex;
+    const { resource, tableAliases: aliases, endpoint } = this.query;
+    const fields = resource?.fields || [];
     for (let relationship of relationships) {
-      const keyObj = {
-        toTable: relationship.tableName,
-        throughTable: void 0
-      };
-      if (relationship.through) {
-        keyObj.throughTable = relationship.through;
-      }
-      const key = JSON.stringify(keyObj);
-      if (tableSets[key]) {
-        tableSets[key].push(relationship);
-      } else {
-        tableSets[key] = [relationship];
+      const {
+        tableName: toTable,
+        through: throughTable,
+        to: toKey,
+        from: fromKey,
+        fromPrimary,
+        toPrimary
+      } = relationship;
+      if (!toTable || !fromTable) {
+        continue;
       }
-    }
-    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;
+      const toAlias = aliases?.[toTable] || toTable, fromAlias = aliases?.[fromTable] || fromTable;
       let toTableWithSchema = this.tableNameWithSchema(toTable, {
         alias: toAlias,
-        schema
-      });
-      let throughTableWithSchema = this.tableNameWithSchema(throughTable, {
-        alias: throughAlias,
-        schema
+        schema: endpoint.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}`);
-          }
+      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) => this.buildJsonField(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 {
-        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}`);
-          }
+        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;
   }
@@ -68631,15 +68875,14 @@ var InternalBuilder = class {
       if (!primary) {
         throw new Error("Primary key is required for upsert");
       }
-      const ret = query.insert(parsedBody).onConflict(primary).merge();
-      return ret;
+      return query.insert(parsedBody).onConflict(primary).merge();
     } else if (this.client === "mssql" /* MS_SQL */ || this.client === "oracledb" /* ORACLE */) {
       return query.insert(parsedBody);
     }
     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,32 +68907,23 @@ 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);
+    query = this.addFilters(query, filters, { relationship: true });
+    if (relationships?.length) {
+      const mainTable = this.query.tableAliases?.[this.query.endpoint.entityId] || this.query.endpoint.entityId;
+      const cte = this.addSorting(
+        this.knex.with("paginated", query).select(this.generateSelectStatement()).from({
+          [mainTable]: "paginated"
+        })
+      );
+      return this.addJsonRelationships(cte, tableName, relationships);
+    } else {
+      return query;
     }
-    return this.addFilters(query, filters, { relationship: true });
   }
   update(opts) {
     const { body: body2, filters } = this.query;