@budibase/backend-core 2.29.0 → 2.29.1

package/dist/index.js

@@ -54802,6 +54802,20 @@ var SWITCHABLE_TYPES = {
   ["number" /* NUMBER */]: ["number" /* NUMBER */, "boolean" /* BOOLEAN */]
 };
 
+// ../shared-core/src/constants/rows.ts
+var CONSTANT_INTERNAL_ROW_COLS = [
+  "_id",
+  "_rev",
+  "type",
+  "createdAt",
+  "updatedAt",
+  "tableId"
+];
+var CONSTANT_EXTERNAL_ROW_COLS = ["_id", "_rev", "tableId"];
+function isInternalColumnName(name) {
+  return CONSTANT_INTERNAL_ROW_COLS.includes(name);
+}
+
 // ../shared-core/src/constants/index.ts
 var OperatorOptions = {
   Equals: {
@@ -55217,10 +55231,15 @@ var search = (docs, query) => {
   if (query.sort) {
     result = sort(result, query.sort, query.sortOrder || "ascending" /* ASCENDING */);
   }
+  let totalRows = result.length;
   if (query.limit) {
     result = limit(result, query.limit.toString());
   }
-  return result;
+  const response = { rows: result };
+  if (query.countRows) {
+    response.totalRows = totalRows;
+  }
+  return response;
 };
 var runQuery = (docs, query) => {
   if (!docs || !Array.isArray(docs)) {
@@ -56728,20 +56747,6 @@ var DatabaseImpl = class _DatabaseImpl {
   }
 };
 
-// src/db/constants.ts
-var CONSTANT_INTERNAL_ROW_COLS = [
-  "_id",
-  "_rev",
-  "type",
-  "createdAt",
-  "updatedAt",
-  "tableId"
-];
-var CONSTANT_EXTERNAL_ROW_COLS = ["_id", "_rev", "tableId"];
-function isInternalColumnName(name) {
-  return CONSTANT_INTERNAL_ROW_COLS.includes(name);
-}
-
 // src/db/db.ts
 function getDB(dbName, opts) {
   return new DDInstrumentedDatabase(new DatabaseImpl(dbName, opts));
@@ -67496,7 +67501,7 @@ function parseFilters(filters) {
 }
 function generateSelectStatement(json, knex3) {
   const { resource, meta } = json;
-  if (!resource) {
+  if (!resource || !resource.fields || resource.fields.length === 0) {
     return "*";
   }
   const schema = meta?.table?.schema;
@@ -67743,12 +67748,26 @@ var InternalBuilder = class {
     }
     return query;
   }
+  addDistinctCount(query, json) {
+    const table = json.meta.table;
+    const primary = table.primary;
+    const aliases = json.tableAliases;
+    const aliased = table.name && aliases?.[table.name] ? aliases[table.name] : table.name;
+    if (!primary) {
+      throw new Error("SQL counting requires primary key to be supplied");
+    }
+    return query.countDistinct(`${aliased}.${primary[0]} as total`);
+  }
   addSorting(query, json) {
-    let { sort: sort2, paginate } = json;
+    let { sort: sort2 } = json;
     const table = json.meta.table;
+    const primaryKey = table.primary;
     const tableName = getTableName(table);
     const aliases = json.tableAliases;
     const aliased = tableName && aliases?.[tableName] ? aliases[tableName] : table?.name;
+    if (!Array.isArray(primaryKey)) {
+      throw new Error("Sorting requires primary key to be specified for table");
+    }
     if (sort2 && Object.keys(sort2 || {}).length > 0) {
       for (let [key, value] of Object.entries(sort2)) {
         const direction = value.direction === "ascending" /* ASCENDING */ ? "asc" : "desc";
@@ -67758,9 +67777,8 @@ var InternalBuilder = class {
         }
         query = query.orderBy(`${aliased}.${key}`, direction, nulls);
       }
-    } else if (this.client === "mssql" /* MS_SQL */ && paginate?.limit) {
-      query = query.orderBy(`${aliased}.${table?.primary[0]}`);
     }
+    query = query.orderBy(`${aliased}.${primaryKey[0]}`);
     return query;
   }
   tableNameWithSchema(tableName, opts) {
@@ -67828,18 +67846,17 @@ var InternalBuilder = class {
         });
       }
     }
-    return query.limit(BASE_LIMIT);
+    return query;
   }
   knexWithAlias(knex3, endpoint, aliases) {
     const tableName = endpoint.entityId;
     const tableAlias = aliases?.[tableName];
-    const query = knex3(
+    return knex3(
       this.tableNameWithSchema(tableName, {
         alias: tableAlias,
         schema: endpoint.schema
       })
     );
-    return query;
   }
   create(knex3, json, opts) {
     const { endpoint, body: body2 } = json;
@@ -67883,18 +67900,14 @@ var InternalBuilder = class {
     }
     return query.upsert(parsedBody);
   }
-  read(knex3, json, limit2) {
-    let { endpoint, resource, filters, paginate, relationships, tableAliases } = json;
+  read(knex3, json, opts = {}) {
+    let { endpoint, filters, paginate, relationships, tableAliases } = json;
+    const { limits } = opts;
+    const counting = endpoint.operation === "COUNT" /* COUNT */;
     const tableName = endpoint.entityId;
-    if (!resource) {
-      resource = { fields: [] };
-    }
-    let selectStatement = "*";
-    if (resource.fields && resource.fields.length > 0) {
-      selectStatement = generateSelectStatement(json, knex3);
-    }
-    let foundLimit = limit2 || BASE_LIMIT;
+    let query = this.knexWithAlias(knex3, endpoint, tableAliases);
     let foundOffset = null;
+    let foundLimit = limits?.query || limits?.base;
     if (paginate && paginate.page && paginate.limit) {
       const page = paginate.page <= 1 ? 0 : paginate.page - 1;
       const offset = page * paginate.limit;
@@ -67906,20 +67919,28 @@ var InternalBuilder = class {
     } else if (paginate && paginate.limit) {
       foundLimit = paginate.limit;
     }
-    let query = this.knexWithAlias(knex3, endpoint, tableAliases);
-    query = query.limit(foundLimit);
-    if (foundOffset) {
-      query = query.offset(foundOffset);
+    if (!counting) {
+      if (foundLimit != null) {
+        query = query.limit(foundLimit);
+      }
+      if (foundOffset != null) {
+        query = query.offset(foundOffset);
+      }
+      query = this.addSorting(query, json);
     }
     query = this.addFilters(query, filters, json.meta.table, {
       aliases: tableAliases
     });
-    query = this.addSorting(query, json);
     const alias = tableAliases?.[tableName] || tableName;
     let preQuery = knex3({
+      // 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
-    }).select(selectStatement);
-    if (this.client !== "mssql" /* MS_SQL */) {
+    });
+    preQuery = !counting ? preQuery.select(generateSelectStatement(json, knex3)) : this.addDistinctCount(preQuery, json);
+    if (this.client !== "mssql" /* MS_SQL */ && !counting) {
       preQuery = this.addSorting(preQuery, json);
     }
     query = this.addRelationships(
@@ -67929,6 +67950,9 @@ var InternalBuilder = class {
       endpoint.schema,
       tableAliases
     );
+    if (limits?.base) {
+      query = query.limit(limits.base);
+    }
     return this.addFilters(query, filters, json.meta.table, {
       relationship: true,
       aliases: tableAliases
@@ -67966,6 +67990,18 @@ var SqlQueryBuilder = class extends sqlTable_default {
     super(client);
     this.limit = limit2;
   }
+  convertToNative(query, opts = {}) {
+    const sqlClient = this.getSqlClient();
+    if (opts?.disableBindings) {
+      return { sql: query.toString() };
+    } else {
+      let native = getNativeSql(query);
+      if (sqlClient === "sqlite3" /* SQL_LITE */) {
+        native = convertBooleans(native);
+      }
+      return native;
+    }
+  }
   /**
    * @param json The JSON query DSL which is to be converted to SQL.
    * @param opts extra options which are to be passed into the query builder, e.g. disableReturning
@@ -67988,7 +68024,15 @@ var SqlQueryBuilder = class extends sqlTable_default {
         query = builder.create(client, json, opts);
         break;
       case "READ" /* READ */:
-        query = builder.read(client, json, this.limit);
+        query = builder.read(client, json, {
+          limits: {
+            query: this.limit,
+            base: BASE_LIMIT
+          }
+        });
+        break;
+      case "COUNT" /* COUNT */:
+        query = builder.read(client, json);
         break;
       case "UPDATE" /* UPDATE */:
         query = builder.update(client, json, opts);
@@ -68009,15 +68053,7 @@ var SqlQueryBuilder = class extends sqlTable_default {
       default:
         throw `Operation type is not supported by SQL query builder`;
     }
-    if (opts?.disableBindings) {
-      return { sql: query.toString() };
-    } else {
-      let native = getNativeSql(query);
-      if (sqlClient === "sqlite3" /* SQL_LITE */) {
-        native = convertBooleans(native);
-      }
-      return native;
-    }
+    return this.convertToNative(query, opts);
   }
   async getReturningRow(queryFn, json) {
     if (!json.extra || !json.extra.idFilter) {
@@ -68084,6 +68120,9 @@ var SqlQueryBuilder = class extends sqlTable_default {
         await this.getReturningRow(queryFn, this.checkLookupKeys(id, json))
       );
     }
+    if (operation === "COUNT" /* COUNT */) {
+      return results;
+    }
     if (operation !== "READ" /* READ */) {
       return row;
     }