@budibase/backend-core 2.33.0 → 2.33.2

package/dist/index.js

@@ -75562,6 +75562,21 @@ function convertBooleans(query) {
 function isSqs(table) {
   return table.sourceType === "internal" /* INTERNAL */ || table.sourceId === INTERNAL_TABLE_SOURCE_ID;
 }
+var allowEmptyRelationships = {
+  ["equal" /* EQUAL */]: false,
+  ["notEqual" /* NOT_EQUAL */]: true,
+  ["empty" /* EMPTY */]: false,
+  ["notEmpty" /* NOT_EMPTY */]: true,
+  ["fuzzy" /* FUZZY */]: false,
+  ["string" /* STRING */]: false,
+  ["range" /* RANGE */]: false,
+  ["contains" /* CONTAINS */]: false,
+  ["notContains" /* NOT_CONTAINS */]: true,
+  ["containsAny" /* CONTAINS_ANY */]: false,
+  ["oneOf" /* ONE_OF */]: false,
+  ["$and" /* AND */]: false,
+  ["$or" /* OR */]: false
+};
 var InternalBuilder = class {
   constructor(client, knex3, query) {
     // states the various situations in which we need a full mapped select statement
@@ -75806,21 +75821,33 @@ var InternalBuilder = class {
     const document = relationship.from?.split(".")[0] || "";
     return query.andWhere(`${document}.fieldName`, "=", relationship.column);
   }
-  addRelationshipForFilter(query, filterKey, whereCb) {
+  addRelationshipForFilter(query, allowEmptyRelationships2, 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}`);
+    const matches2 = (value) => filterKey.match(new RegExp(`^${value}\\.`));
     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 matchesTableName = matches2(relatedTableName) || matches2(toAlias);
+      const matchesRelationName = matches2(relationship.column);
+      if ((matchesTableName || matchesRelationName) && relationship.to && relationship.tableName) {
+        const joinTable = mainKnex.select(mainKnex.raw(1)).from({ [toAlias]: relatedTableName });
+        let subQuery = joinTable.clone();
         const manyToMany = validateManyToMany(relationship);
+        let updatedKey;
+        if (!matchesTableName) {
+          updatedKey = filterKey.replace(
+            new RegExp(`^${relationship.column}.`),
+            `${aliases[relationship.tableName]}.`
+          );
+        } else {
+          updatedKey = filterKey;
+        }
         if (manyToMany) {
           const throughAlias = aliases?.[manyToMany.through] || relationship.through;
           let throughTable = this.tableNameWithSchema(manyToMany.through, {
@@ -75843,17 +75870,35 @@ var InternalBuilder = class {
           if (this.client === "sqlite3" /* SQL_LITE */) {
             subQuery = this.addJoinFieldCheck(subQuery, manyToMany);
           }
+          query = query.where((q2) => {
+            q2.whereExists(whereCb(updatedKey, subQuery));
+            if (allowEmptyRelationships2) {
+              q2.orWhereNotExists(
+                joinTable.clone().innerJoin(throughTable, function() {
+                  this.on(
+                    `${fromAlias}.${manyToMany.fromPrimary}`,
+                    "=",
+                    `${throughAlias}.${manyToMany.from}`
+                  );
+                })
+              );
+            }
+          });
         } else {
+          const toKey = `${toAlias}.${relationship.to}`;
+          const foreignKey = `${fromAlias}.${relationship.from}`;
           subQuery = subQuery.where(
-            `${toAlias}.${relationship.to}`,
+            toKey,
             "=",
-            mainKnex.raw(
-              this.quotedIdentifier(`${fromAlias}.${relationship.from}`)
-            )
+            mainKnex.raw(this.quotedIdentifier(foreignKey))
           );
+          query = query.where((q2) => {
+            q2.whereExists(whereCb(updatedKey, subQuery.clone()));
+            if (allowEmptyRelationships2) {
+              q2.orWhereNotExists(subQuery);
+            }
+          });
         }
-        query = query.whereExists(whereCb(subQuery));
-        break;
       }
     }
     return query;
@@ -75873,7 +75918,7 @@ var InternalBuilder = class {
       const alias = aliases?.[name];
       return alias || name;
     }
-    function iterate(structure, fn, complexKeyFn) {
+    function iterate(structure, operation, fn, complexKeyFn) {
       const handleRelationship = (q2, key, value) => {
         const [filterTableName, ...otherProperties] = key.split(".");
         const property = otherProperties.join(".");
@@ -75908,9 +75953,14 @@ var InternalBuilder = class {
           if (allOr) {
             query = query.or;
           }
-          query = builder.addRelationshipForFilter(query, updatedKey, (q2) => {
-            return handleRelationship(q2, updatedKey, value);
-          });
+          query = builder.addRelationshipForFilter(
+            query,
+            allowEmptyRelationships[operation],
+            updatedKey,
+            (updatedKey2, q2) => {
+              return handleRelationship(q2, updatedKey2, value);
+            }
+          );
         }
       }
     }
@@ -75938,7 +75988,7 @@ var InternalBuilder = class {
         return `[${value.join(",")}]`;
       }
       if (this.client === "pg" /* POSTGRES */) {
-        iterate(mode, (q2, key, value) => {
+        iterate(mode, "contains" /* CONTAINS */, (q2, key, value) => {
           const wrap = any ? "" : "'";
           const op = any ? "\\?| array" : "@>";
           const fieldNames = key.split(/\./g);
@@ -75953,7 +76003,7 @@ var InternalBuilder = class {
         });
       } else if (this.client === "mysql2" /* MY_SQL */ || this.client === "mariadb" /* MARIADB */) {
         const jsonFnc = any ? "JSON_OVERLAPS" : "JSON_CONTAINS";
-        iterate(mode, (q2, key, value) => {
+        iterate(mode, "contains" /* CONTAINS */, (q2, key, value) => {
           return q2[rawFnc](
             `${not}COALESCE(${jsonFnc}(${key}, '${stringifyArray(
               value
@@ -75962,7 +76012,7 @@ var InternalBuilder = class {
         });
       } else {
         const andOr = mode === filters?.containsAny ? " OR " : " AND ";
-        iterate(mode, (q2, key, value) => {
+        iterate(mode, "contains" /* CONTAINS */, (q2, key, value) => {
           let statement = "";
           const identifier = this.quotedIdentifier(key);
           for (let i in value) {
@@ -76009,6 +76059,7 @@ var InternalBuilder = class {
       const fnc = allOr ? "orWhereIn" : "whereIn";
       iterate(
         filters.oneOf,
+        "oneOf" /* ONE_OF */,
         (q2, key, array) => {
           if (this.client === "oracledb" /* ORACLE */) {
             key = this.convertClobs(key);
@@ -76031,7 +76082,7 @@ var InternalBuilder = class {
       );
     }
     if (filters.string) {
-      iterate(filters.string, (q2, key, value) => {
+      iterate(filters.string, "string" /* STRING */, (q2, key, value) => {
         const fnc = allOr ? "orWhere" : "where";
         if (this.client === "pg" /* POSTGRES */) {
           return q2[fnc](key, "ilike", `${value}%`);
@@ -76044,10 +76095,10 @@ var InternalBuilder = class {
       });
     }
     if (filters.fuzzy) {
-      iterate(filters.fuzzy, like);
+      iterate(filters.fuzzy, "fuzzy" /* FUZZY */, like);
     }
     if (filters.range) {
-      iterate(filters.range, (q2, key, value) => {
+      iterate(filters.range, "range" /* RANGE */, (q2, key, value) => {
         const isEmptyObject = (val) => {
           return val && Object.keys(val).length === 0 && Object.getPrototypeOf(val) === Object.prototype;
         };
@@ -76095,7 +76146,7 @@ var InternalBuilder = class {
       });
     }
     if (filters.equal) {
-      iterate(filters.equal, (q2, key, value) => {
+      iterate(filters.equal, "equal" /* EQUAL */, (q2, key, value) => {
         const fnc = allOr ? "orWhereRaw" : "whereRaw";
         if (this.client === "mssql" /* MS_SQL */) {
           return q2[fnc](
@@ -76115,7 +76166,7 @@ var InternalBuilder = class {
       });
     }
     if (filters.notEqual) {
-      iterate(filters.notEqual, (q2, key, value) => {
+      iterate(filters.notEqual, "notEqual" /* NOT_EQUAL */, (q2, key, value) => {
         const fnc = allOr ? "orWhereRaw" : "whereRaw";
         if (this.client === "mssql" /* MS_SQL */) {
           return q2[fnc](
@@ -76136,13 +76187,13 @@ var InternalBuilder = class {
       });
     }
     if (filters.empty) {
-      iterate(filters.empty, (q2, key) => {
+      iterate(filters.empty, "empty" /* EMPTY */, (q2, key) => {
         const fnc = allOr ? "orWhereNull" : "whereNull";
         return q2[fnc](key);
       });
     }
     if (filters.notEmpty) {
-      iterate(filters.notEmpty, (q2, key) => {
+      iterate(filters.notEmpty, "notEmpty" /* NOT_EMPTY */, (q2, key) => {
         const fnc = allOr ? "orWhereNotNull" : "whereNotNull";
         return q2[fnc](key);
       });