@budibase/backend-core 2.28.7 → 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));
@@ -60035,6 +60040,7 @@ __export(tenancy_exports, {
   addTenantToUrl: () => addTenantToUrl,
   getTenantDB: () => getTenantDB,
   getTenantIDFromCtx: () => getTenantIDFromCtx,
+  getTenantInfo: () => getTenantInfo,
   isUserInAppTenant: () => isUserInAppTenant,
   saveTenantInfo: () => saveTenantInfo
 });
@@ -60045,11 +60051,15 @@ function getTenantDB(tenantId) {
 }
 async function saveTenantInfo(tenantInfo) {
   const db = getTenantDB(tenantInfo.tenantId);
-  return await db.put({
+  return db.put({
     _id: "tenant_info",
     ...tenantInfo
   });
 }
+async function getTenantInfo(tenantId) {
+  const db = getTenantDB(tenantId);
+  return db.get("tenant_info");
+}
 
 // src/tenancy/tenancy.ts
 function addTenantToUrl(url) {
@@ -67491,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;
@@ -67738,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";
@@ -67753,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) {
@@ -67823,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;
@@ -67860,40 +67882,65 @@ var InternalBuilder = class {
     const parsedBody = body2.map((row) => parseBody(row));
     return query.insert(parsedBody);
   }
-  read(knex3, json, limit2) {
-    let { endpoint, resource, filters, paginate, relationships, tableAliases } = json;
-    const tableName = endpoint.entityId;
-    if (!resource) {
-      resource = { fields: [] };
+  bulkUpsert(knex3, json) {
+    const { endpoint, body: body2 } = json;
+    let query = this.knexWithAlias(knex3, endpoint);
+    if (!Array.isArray(body2)) {
+      return query;
     }
-    let selectStatement = "*";
-    if (resource.fields && resource.fields.length > 0) {
-      selectStatement = generateSelectStatement(json, knex3);
+    const parsedBody = body2.map((row) => parseBody(row));
+    if (this.client === "pg" /* POSTGRES */ || this.client === "sqlite3" /* SQL_LITE */ || this.client === "mysql2" /* MY_SQL */) {
+      const primary = json.meta.table.primary;
+      if (!primary) {
+        throw new Error("Primary key is required for upsert");
+      }
+      return query.insert(parsedBody).onConflict(primary).merge();
+    } else if (this.client === "mssql" /* MS_SQL */) {
+      return query.insert(parsedBody);
     }
-    let foundLimit = limit2 || BASE_LIMIT;
+    return query.upsert(parsedBody);
+  }
+  read(knex3, json, opts = {}) {
+    let { endpoint, filters, paginate, relationships, tableAliases } = json;
+    const { limits } = opts;
+    const counting = endpoint.operation === "COUNT" /* COUNT */;
+    const tableName = endpoint.entityId;
+    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;
       foundLimit = paginate.limit;
       foundOffset = offset;
+    } else if (paginate && paginate.offset && paginate.limit) {
+      foundLimit = paginate.limit;
+      foundOffset = paginate.offset;
     } 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(
@@ -67903,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
@@ -67940,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
@@ -67962,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);
@@ -67973,6 +68043,9 @@ var SqlQueryBuilder = class extends sqlTable_default {
       case "BULK_CREATE" /* BULK_CREATE */:
         query = builder.bulkCreate(client, json);
         break;
+      case "BULK_UPSERT" /* BULK_UPSERT */:
+        query = builder.bulkUpsert(client, json);
+        break;
       case "CREATE_TABLE" /* CREATE_TABLE */:
       case "UPDATE_TABLE" /* UPDATE_TABLE */:
       case "DELETE_TABLE" /* DELETE_TABLE */:
@@ -67980,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) {
@@ -68055,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;
     }