@budibase/server 2.7.20-alpha.0 → 2.7.20

package/dist/index.js

@@ -838,7 +838,6 @@ var init_automation2 = __esm({
       AutomationIOType2["NUMBER"] = "number";
       AutomationIOType2["ARRAY"] = "array";
       AutomationIOType2["JSON"] = "json";
-      AutomationIOType2["DATE"] = "date";
       return AutomationIOType2;
     })(AutomationIOType || {});
     AutomationCustomIOType = /* @__PURE__ */ ((AutomationCustomIOType2) => {
@@ -5401,11 +5400,11 @@ function makeCacheItem(doc2, lastWrite = null) {
   return { doc: doc2, lastWrite: lastWrite || Date.now() };
 }
 async function put(db2, doc2, writeRateMs = DEFAULT_WRITE_RATE_MS) {
-  const cache3 = await getCache();
+  const cache2 = await getCache();
   const key = doc2._id;
   let cacheItem;
   if (key) {
-    cacheItem = await cache3.get(makeCacheKey(db2, key));
+    cacheItem = await cache2.get(makeCacheKey(db2, key));
   }
   const updateDb = !cacheItem || cacheItem.lastWrite < Date.now() - writeRateMs;
   let output = doc2;
@@ -5443,30 +5442,30 @@ async function put(db2, doc2, writeRateMs = DEFAULT_WRITE_RATE_MS) {
   }
   cacheItem = makeCacheItem(output, updateDb ? null : cacheItem == null ? void 0 : cacheItem.lastWrite);
   if (output._id) {
-    await cache3.store(makeCacheKey(db2, output._id), cacheItem);
+    await cache2.store(makeCacheKey(db2, output._id), cacheItem);
   }
   return { ok: true, id: output._id, rev: output._rev };
 }
 async function get2(db2, id) {
-  const cache3 = await getCache();
+  const cache2 = await getCache();
   const cacheKey = makeCacheKey(db2, id);
-  let cacheItem = await cache3.get(cacheKey);
+  let cacheItem = await cache2.get(cacheKey);
   if (!cacheItem) {
     const doc2 = await db2.get(id);
     cacheItem = makeCacheItem(doc2);
-    await cache3.store(cacheKey, cacheItem);
+    await cache2.store(cacheKey, cacheItem);
   }
   return cacheItem.doc;
 }
 async function remove(db2, docOrId, rev2) {
-  const cache3 = await getCache();
+  const cache2 = await getCache();
   if (!docOrId) {
     throw new Error("No ID/Rev provided.");
   }
   const id = typeof docOrId === "string" ? docOrId : docOrId._id;
   rev2 = typeof docOrId === "string" ? rev2 : docOrId._rev;
   try {
-    await cache3.delete(makeCacheKey(db2, id));
+    await cache2.delete(makeCacheKey(db2, id));
   } finally {
     await db2.remove(id, rev2);
   }
@@ -9308,7 +9307,7 @@ function lowerBuiltinRoleID(roleId1, roleId2) {
   }
   return builtinRoleToNumber(roleId1) > builtinRoleToNumber(roleId2) ? roleId2 : roleId1;
 }
-async function getRole(roleId, opts) {
+async function getRole(roleId) {
   if (!roleId) {
     return void 0;
   }
@@ -9324,9 +9323,6 @@ async function getRole(roleId, opts) {
     role = Object.assign(role, dbRole);
     role._id = getExternalRoleID(role._id);
   } catch (err) {
-    if (!isBuiltin(roleId) && (opts == null ? void 0 : opts.defaultPublic)) {
-      return cloneDeep2(BUILTIN_ROLES.PUBLIC);
-    }
     if (Object.keys(role).length === 0) {
       throw err;
     }
@@ -10067,8 +10063,8 @@ async function preAuth(passport2, ctx, next) {
     callbackUrl,
     ssoSaveUserNoOp
   );
-  if (!ctx.query.appId) {
-    ctx.throw(400, "appId query param not present.");
+  if (!ctx.query.appId || !ctx.query.datasourceId) {
+    ctx.throw(400, "appId and datasourceId query params not present.");
   }
   return passport2.authenticate(strategy, {
     scope: ["profile", "email", "https://www.googleapis.com/auth/spreadsheets"],
@@ -10088,7 +10084,7 @@ async function postAuth(passport2, ctx, next) {
         clientSecret: config.clientSecret,
         callbackURL: callbackUrl
       },
-      (accessToken, refreshToken, _profile, done) => {
+      (accessToken, refreshToken, profile, done) => {
         clearCookie(ctx, "budibase:datasourceauth" /* DatasourceAuth */);
         done(null, { accessToken, refreshToken });
       }
@@ -10096,14 +10092,22 @@ async function postAuth(passport2, ctx, next) {
     { successRedirect: "/", failureRedirect: "/error" },
     async (err, tokens) => {
       const baseUrl = `/builder/app/${authStateCookie.appId}/data`;
-      const id = newid();
-      await store(
-        `datasource:creation:${authStateCookie.appId}:google:${id}`,
-        {
-          tokens
+      await doWithDB(authStateCookie.appId, async (db2) => {
+        let datasource2;
+        try {
+          datasource2 = await db2.get(authStateCookie.datasourceId);
+        } catch (err2) {
+          if (err2.status === 404) {
+            ctx.redirect(baseUrl);
+          }
         }
-      );
-      ctx.redirect(`${baseUrl}/new?continue_google_setup=${id}`);
+        if (!datasource2.config) {
+          datasource2.config = {};
+        }
+        datasource2.config.auth = { type: "google", ...tokens };
+        await db2.put(datasource2);
+        ctx.redirect(`${baseUrl}/datasource/${authStateCookie.datasourceId}`);
+      });
     }
   )(ctx, next);
 }
@@ -10112,9 +10116,9 @@ var init_google2 = __esm({
   "../backend-core/src/middleware/passport/datasource/google.ts"() {
     init_google();
     init_constants2();
-    init_configs3();
-    init_cache();
     init_utils5();
+    init_db5();
+    init_configs3();
     init_sso2();
     GoogleStrategy2 = require("passport-google-oauth").OAuth2Strategy;
   }
@@ -10164,9 +10168,7 @@ var encryption_exports = {};
 __export(encryption_exports, {
   SecretOption: () => SecretOption,
   decrypt: () => decrypt,
-  decryptFile: () => decryptFile,
   encrypt: () => encrypt,
-  encryptFile: () => encryptFile,
   getSecret: () => getSecret
 });
 function getSecret(secretOption) {
@@ -10187,11 +10189,11 @@ function getSecret(secretOption) {
   }
   return secret;
 }
-function stretchString(secret, salt) {
-  return import_crypto.default.pbkdf2Sync(secret, salt, ITERATIONS, STRETCH_LENGTH, "sha512");
+function stretchString(string, salt) {
+  return import_crypto.default.pbkdf2Sync(string, salt, ITERATIONS, STRETCH_LENGTH, "sha512");
 }
 function encrypt(input, secretOption = "api" /* API */) {
-  const salt = import_crypto.default.randomBytes(SALT_LENGTH);
+  const salt = import_crypto.default.randomBytes(RANDOM_BYTES);
   const stretched = stretchString(getSecret(secretOption), salt);
   const cipher = import_crypto.default.createCipheriv(ALGO, stretched, salt);
   const base = cipher.update(input);
@@ -10208,101 +10210,16 @@ function decrypt(input, secretOption = "api" /* API */) {
   const final = decipher.final();
   return Buffer.concat([base, final]).toString();
 }
-async function encryptFile({ dir, filename }, secret) {
-  const outputFileName = `${filename}.enc`;
-  const filePath = (0, import_path.join)(dir, filename);
-  const inputFile = import_fs2.default.createReadStream(filePath);
-  const outputFile = import_fs2.default.createWriteStream((0, import_path.join)(dir, outputFileName));
-  const salt = import_crypto.default.randomBytes(SALT_LENGTH);
-  const iv = import_crypto.default.randomBytes(IV_LENGTH);
-  const stretched = stretchString(secret, salt);
-  const cipher = import_crypto.default.createCipheriv(ALGO, stretched, iv);
-  outputFile.write(salt);
-  outputFile.write(iv);
-  inputFile.pipe(import_zlib.default.createGzip()).pipe(cipher).pipe(outputFile);
-  return new Promise((r) => {
-    outputFile.on("finish", () => {
-      r({
-        filename: outputFileName,
-        dir
-      });
-    });
-  });
-}
-async function getSaltAndIV(path5) {
-  const fileStream = import_fs2.default.createReadStream(path5);
-  const salt = await readBytes(fileStream, SALT_LENGTH);
-  const iv = await readBytes(fileStream, IV_LENGTH);
-  fileStream.close();
-  return { salt, iv };
-}
-async function decryptFile(inputPath, outputPath, secret) {
-  const { salt, iv } = await getSaltAndIV(inputPath);
-  const inputFile = import_fs2.default.createReadStream(inputPath, {
-    start: SALT_LENGTH + IV_LENGTH
-  });
-  const outputFile = import_fs2.default.createWriteStream(outputPath);
-  const stretched = stretchString(secret, salt);
-  const decipher = import_crypto.default.createDecipheriv(ALGO, stretched, iv);
-  const unzip = import_zlib.default.createGunzip();
-  inputFile.pipe(decipher).pipe(unzip).pipe(outputFile);
-  return new Promise((res, rej) => {
-    outputFile.on("finish", () => {
-      outputFile.close();
-      res();
-    });
-    inputFile.on("error", (e) => {
-      outputFile.close();
-      rej(e);
-    });
-    decipher.on("error", (e) => {
-      outputFile.close();
-      rej(e);
-    });
-    unzip.on("error", (e) => {
-      outputFile.close();
-      rej(e);
-    });
-    outputFile.on("error", (e) => {
-      outputFile.close();
-      rej(e);
-    });
-  });
-}
-function readBytes(stream3, length) {
-  return new Promise((resolve3, reject) => {
-    let bytesRead = 0;
-    const data2 = [];
-    stream3.on("readable", () => {
-      let chunk;
-      while ((chunk = stream3.read(length - bytesRead)) !== null) {
-        data2.push(chunk);
-        bytesRead += chunk.length;
-      }
-      resolve3(Buffer.concat(data2));
-    });
-    stream3.on("end", () => {
-      reject(new Error("Insufficient data in the stream."));
-    });
-    stream3.on("error", (error2) => {
-      reject(error2);
-    });
-  });
-}
-var import_crypto, import_fs2, import_zlib, import_path, ALGO, SEPARATOR3, ITERATIONS, STRETCH_LENGTH, SALT_LENGTH, IV_LENGTH, SecretOption;
+var import_crypto, ALGO, SEPARATOR3, ITERATIONS, RANDOM_BYTES, STRETCH_LENGTH, SecretOption;
 var init_encryption = __esm({
   "../backend-core/src/security/encryption.ts"() {
     import_crypto = __toESM(require("crypto"));
-    import_fs2 = __toESM(require("fs"));
-    import_zlib = __toESM(require("zlib"));
     init_environment2();
-    import_path = require("path");
     ALGO = "aes-256-ctr";
     SEPARATOR3 = "-";
     ITERATIONS = 1e4;
+    RANDOM_BYTES = 16;
     STRETCH_LENGTH = 32;
-    SALT_LENGTH = 16;
-    IV_LENGTH = 16;
     SecretOption = /* @__PURE__ */ ((SecretOption2) => {
       SecretOption2["API"] = "api";
       SecretOption2["ENCRYPTION"] = "encryption";
@@ -11213,12 +11130,12 @@ var init_plugin4 = __esm({
 function budibaseTempDir() {
   return bbTmp;
 }
-var import_path2, import_os, import_fs3, ObjectStoreBuckets, bbTmp;
+var import_path, import_os, import_fs2, ObjectStoreBuckets, bbTmp;
 var init_utils8 = __esm({
   "../backend-core/src/objectStore/utils.ts"() {
-    import_path2 = require("path");
+    import_path = require("path");
     import_os = require("os");
-    import_fs3 = __toESM(require("fs"));
+    import_fs2 = __toESM(require("fs"));
     init_environment2();
     ObjectStoreBuckets = {
       BACKUPS: environment_default.BACKUPS_BUCKET_NAME,
@@ -11227,9 +11144,9 @@ var init_utils8 = __esm({
       GLOBAL: environment_default.GLOBAL_BUCKET_NAME,
       PLUGINS: environment_default.PLUGIN_BUCKET_NAME
     };
-    bbTmp = (0, import_path2.join)((0, import_os.tmpdir)(), ".budibase");
-    if (!import_fs3.default.existsSync(bbTmp)) {
-      import_fs3.default.mkdirSync(bbTmp);
+    bbTmp = (0, import_path.join)((0, import_os.tmpdir)(), ".budibase");
+    if (!import_fs2.default.existsSync(bbTmp)) {
+      import_fs2.default.mkdirSync(bbTmp);
     }
   }
 });
@@ -11241,17 +11158,17 @@ function sanitizeKey(input) {
 function sanitizeBucket(input) {
   return input.replace(new RegExp(APP_DEV_PREFIX, "g"), APP_PREFIX);
 }
-var import_aws_sdk, import_stream, import_node_fetch6, import_tar_fs, import_zlib2, import_util, import_path3, import_fs4, import_uuid3, sanitize, streamPipeline, STATE, CONTENT_TYPE_MAP, STRING_CONTENT_TYPES, ObjectStore, makeSureBucketExists, upload, streamUpload, retrieve, listAllObjects, getPresignedUrl, retrieveToTmp, retrieveDirectory, deleteFile, deleteFiles, deleteFolder, uploadDirectory, downloadTarballDirect, downloadTarball;
+var import_aws_sdk, import_stream, import_node_fetch6, import_tar_fs, import_zlib, import_util, import_path2, import_fs3, import_uuid3, sanitize, streamPipeline, STATE, CONTENT_TYPE_MAP, STRING_CONTENT_TYPES, ObjectStore, makeSureBucketExists, upload, streamUpload, retrieve, listAllObjects, getPresignedUrl, retrieveToTmp, retrieveDirectory, deleteFile, deleteFiles, deleteFolder, uploadDirectory, downloadTarballDirect, downloadTarball;
 var init_objectStore = __esm({
   "../backend-core/src/objectStore/objectStore.ts"() {
     import_aws_sdk = __toESM(require("aws-sdk"));
     import_stream = __toESM(require("stream"));
     import_node_fetch6 = __toESM(require("node-fetch"));
     import_tar_fs = __toESM(require("tar-fs"));
-    import_zlib2 = __toESM(require("zlib"));
+    import_zlib = __toESM(require("zlib"));
     import_util = require("util");
-    import_path3 = require("path");
-    import_fs4 = __toESM(require("fs"));
+    import_path2 = require("path");
+    import_fs3 = __toESM(require("fs"));
     init_environment2();
     init_utils8();
     import_uuid3 = require("uuid");
@@ -11330,7 +11247,7 @@ var init_objectStore = __esm({
       metadata: metadata2
     }) => {
       const extension = filename.split(".").pop();
-      const fileBytes = import_fs4.default.readFileSync(path5);
+      const fileBytes = import_fs3.default.readFileSync(path5);
       const objectStore = ObjectStore(bucketName);
       await makeSureBucketExists(objectStore, bucketName);
       let contentType = type;
@@ -11432,13 +11349,13 @@ var init_objectStore = __esm({
       bucketName = sanitizeBucket(bucketName);
       filepath = sanitizeKey(filepath);
       const data2 = await retrieve(bucketName, filepath);
-      const outputPath = (0, import_path3.join)(budibaseTempDir(), (0, import_uuid3.v4)());
-      import_fs4.default.writeFileSync(outputPath, data2);
+      const outputPath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid3.v4)());
+      import_fs3.default.writeFileSync(outputPath, data2);
       return outputPath;
     };
     retrieveDirectory = async (bucketName, path5) => {
-      let writePath = (0, import_path3.join)(budibaseTempDir(), (0, import_uuid3.v4)());
-      import_fs4.default.mkdirSync(writePath);
+      let writePath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid3.v4)());
+      import_fs3.default.mkdirSync(writePath);
       const objects = await listAllObjects(bucketName, path5);
       let fullObjects = await Promise.all(
         objects.map((obj) => retrieve(bucketName, obj.Key))
@@ -11450,9 +11367,9 @@ var init_objectStore = __esm({
         const possiblePath = filename.split("/");
         if (possiblePath.length > 1) {
           const dirs = possiblePath.slice(0, possiblePath.length - 1);
-          import_fs4.default.mkdirSync((0, import_path3.join)(writePath, ...dirs), { recursive: true });
+          import_fs3.default.mkdirSync((0, import_path2.join)(writePath, ...dirs), { recursive: true });
         }
-        import_fs4.default.writeFileSync((0, import_path3.join)(writePath, ...possiblePath), data2);
+        import_fs3.default.writeFileSync((0, import_path2.join)(writePath, ...possiblePath), data2);
       }
       return writePath;
     };
@@ -11506,14 +11423,14 @@ var init_objectStore = __esm({
     uploadDirectory = async (bucketName, localPath, bucketPath2) => {
       bucketName = sanitizeBucket(bucketName);
       let uploads = [];
-      const files2 = import_fs4.default.readdirSync(localPath, { withFileTypes: true });
+      const files2 = import_fs3.default.readdirSync(localPath, { withFileTypes: true });
       for (let file of files2) {
-        const path5 = sanitizeKey((0, import_path3.join)(bucketPath2, file.name));
-        const local = (0, import_path3.join)(localPath, file.name);
+        const path5 = sanitizeKey((0, import_path2.join)(bucketPath2, file.name));
+        const local = (0, import_path2.join)(localPath, file.name);
         if (file.isDirectory()) {
           uploads.push(uploadDirectory(bucketName, local, path5));
         } else {
-          uploads.push(streamUpload(bucketName, path5, import_fs4.default.createReadStream(local)));
+          uploads.push(streamUpload(bucketName, path5, import_fs3.default.createReadStream(local)));
         }
       }
       await Promise.all(uploads);
@@ -11525,7 +11442,7 @@ var init_objectStore = __esm({
       if (!response2.ok) {
         throw new Error(`unexpected response ${response2.statusText}`);
       }
-      await streamPipeline(response2.body, import_zlib2.default.createUnzip(), import_tar_fs.default.extract(path5));
+      await streamPipeline(response2.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(path5));
     };
     downloadTarball = async (url, bucketName, path5) => {
       bucketName = sanitizeBucket(bucketName);
@@ -11534,8 +11451,8 @@ var init_objectStore = __esm({
       if (!response2.ok) {
         throw new Error(`unexpected response ${response2.statusText}`);
       }
-      const tmpPath = (0, import_path3.join)(budibaseTempDir(), path5);
-      await streamPipeline(response2.body, import_zlib2.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
+      const tmpPath = (0, import_path2.join)(budibaseTempDir(), path5);
+      await streamPipeline(response2.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
       if (!environment_default.isTest() && environment_default.SELF_HOSTED) {
         await uploadDirectory(bucketName, tmpPath, path5);
       }
@@ -12117,16 +12034,16 @@ var init_constants4 = __esm({
 });
 
 // src/utilities/centralPath.ts
-function join4(...args) {
-  return import_path4.default.join(...args);
+function join3(...args) {
+  return import_path3.default.join(...args);
 }
 function resolve(...args) {
-  return import_path4.default.resolve(...args);
+  return import_path3.default.resolve(...args);
 }
-var import_path4;
+var import_path3;
 var init_centralPath = __esm({
   "src/utilities/centralPath.ts"() {
-    import_path4 = __toESM(require("path"));
+    import_path3 = __toESM(require("path"));
   }
 });
 
@@ -12148,14 +12065,14 @@ function parseIntSafe(number) {
     return parseInt(number);
   }
 }
-var import_path5, LOADED2, environment2, environment_default2;
+var import_path4, LOADED2, environment2, environment_default2;
 var init_environment3 = __esm({
   "src/environment.ts"() {
-    import_path5 = require("path");
+    import_path4 = require("path");
     LOADED2 = false;
     if (!LOADED2 && isDev2() && !isTest2()) {
       require("dotenv").config({
-        path: (0, import_path5.join)(__dirname, "..", ".env")
+        path: (0, import_path4.join)(__dirname, "..", ".env")
       });
       LOADED2 = true;
     }
@@ -12239,22 +12156,22 @@ var init_environment3 = __esm({
 });
 
 // src/utilities/fileSystem/filesystem.ts
-var import_fs5, import_path6, import_tar, uuid2, TOP_LEVEL_PATH, init9, checkDevelopmentEnvironment, loadHandlebarsFile, apiFileReturn, streamFile, createTempFolder, extractTarball, findFileRec, deleteFolderFileSystem;
+var import_fs4, import_path5, import_tar, uuid2, TOP_LEVEL_PATH, init9, checkDevelopmentEnvironment, loadHandlebarsFile, apiFileReturn, streamFile, createTempFolder, extractTarball, findFileRec, deleteFolderFileSystem;
 var init_filesystem = __esm({
   "src/utilities/fileSystem/filesystem.ts"() {
-    import_fs5 = __toESM(require("fs"));
+    import_fs4 = __toESM(require("fs"));
     init_budibaseDir();
-    import_path6 = require("path");
+    import_path5 = require("path");
     init_environment3();
     import_tar = __toESM(require("tar"));
     init_environment3();
     uuid2 = require("uuid/v4");
-    TOP_LEVEL_PATH = environment_default2.TOP_LEVEL_PATH || (0, import_path6.resolve)((0, import_path6.join)(__dirname, "..", "..", ".."));
+    TOP_LEVEL_PATH = environment_default2.TOP_LEVEL_PATH || (0, import_path5.resolve)((0, import_path5.join)(__dirname, "..", "..", ".."));
     init9 = () => {
       const tempDir = budibaseTempDir2();
-      if (!import_fs5.default.existsSync(tempDir)) {
+      if (!import_fs4.default.existsSync(tempDir)) {
         try {
-          import_fs5.default.mkdirSync(tempDir);
+          import_fs4.default.mkdirSync(tempDir);
         } catch (err) {
           if (!err || err.code !== "EEXIST") {
             throw err;
@@ -12266,11 +12183,11 @@ var init_filesystem = __esm({
       if (!environment_default2.isDev() || environment_default2.isTest()) {
         return;
       }
-      if (!import_fs5.default.existsSync(budibaseTempDir2())) {
-        import_fs5.default.mkdirSync(budibaseTempDir2());
+      if (!import_fs4.default.existsSync(budibaseTempDir2())) {
+        import_fs4.default.mkdirSync(budibaseTempDir2());
       }
       let error2;
-      if (!import_fs5.default.existsSync((0, import_path6.join)(process.cwd(), ".env"))) {
+      if (!import_fs4.default.existsSync((0, import_path5.join)(process.cwd(), ".env"))) {
         error2 = "Must run via yarn once to generate environment.";
       }
       if (error2) {
@@ -12279,23 +12196,23 @@ var init_filesystem = __esm({
       }
     };
     loadHandlebarsFile = (path5) => {
-      return import_fs5.default.readFileSync(path5, "utf8");
+      return import_fs4.default.readFileSync(path5, "utf8");
     };
     apiFileReturn = (contents) => {
-      const path5 = (0, import_path6.join)(budibaseTempDir2(), uuid2());
-      import_fs5.default.writeFileSync(path5, contents);
-      return import_fs5.default.createReadStream(path5);
+      const path5 = (0, import_path5.join)(budibaseTempDir2(), uuid2());
+      import_fs4.default.writeFileSync(path5, contents);
+      return import_fs4.default.createReadStream(path5);
     };
     streamFile = (path5) => {
-      return import_fs5.default.createReadStream(path5);
+      return import_fs4.default.createReadStream(path5);
     };
     createTempFolder = (item) => {
-      const path5 = (0, import_path6.join)(budibaseTempDir2(), item);
+      const path5 = (0, import_path5.join)(budibaseTempDir2(), item);
       try {
-        if (import_fs5.default.existsSync(path5)) {
-          import_fs5.default.rmSync(path5, { recursive: true, force: true });
+        if (import_fs4.default.existsSync(path5)) {
+          import_fs4.default.rmSync(path5, { recursive: true, force: true });
         }
-        import_fs5.default.mkdirSync(path5);
+        import_fs4.default.mkdirSync(path5);
       } catch (err) {
         throw new Error(`Path cannot be created: ${err.message}`);
       }
@@ -12308,13 +12225,13 @@ var init_filesystem = __esm({
       });
     };
     findFileRec = (startPath, filter2) => {
-      if (!import_fs5.default.existsSync(startPath)) {
+      if (!import_fs4.default.existsSync(startPath)) {
         return;
       }
-      const files2 = import_fs5.default.readdirSync(startPath);
+      const files2 = import_fs4.default.readdirSync(startPath);
       for (let i = 0, len = files2.length; i < len; i++) {
-        const filename = (0, import_path6.join)(startPath, files2[i]);
-        const stat = import_fs5.default.lstatSync(filename);
+        const filename = (0, import_path5.join)(startPath, files2[i]);
+        const stat = import_fs4.default.lstatSync(filename);
         if (stat.isDirectory()) {
           return findFileRec(filename, filter2);
         } else if (filename.endsWith(filter2)) {
@@ -12323,10 +12240,10 @@ var init_filesystem = __esm({
       }
     };
     deleteFolderFileSystem = (path5) => {
-      if (!import_fs5.default.existsSync(path5)) {
+      if (!import_fs4.default.existsSync(path5)) {
         return;
       }
-      import_fs5.default.rmSync(path5, { recursive: true, force: true });
+      import_fs4.default.rmSync(path5, { recursive: true, force: true });
     };
   }
 });
@@ -12340,12 +12257,12 @@ async function backupClientLibrary(appId) {
   try {
     tmpManifestPath = await objectStore_exports2.retrieveToTmp(
       ObjectStoreBuckets2.APPS,
-      (0, import_path7.join)(appId, "manifest.json")
+      (0, import_path6.join)(appId, "manifest.json")
     );
   } catch (error2) {
     tmpManifestPath = await objectStore_exports2.retrieveToTmp(
       ObjectStoreBuckets2.APPS,
-      (0, import_path7.join)(
+      (0, import_path6.join)(
         appId,
         "node_modules",
         "budibase",
@@ -12357,17 +12274,17 @@ async function backupClientLibrary(appId) {
   }
   const tmpClientPath = await objectStore_exports2.retrieveToTmp(
     ObjectStoreBuckets2.APPS,
-    (0, import_path7.join)(appId, "budibase-client.js")
+    (0, import_path6.join)(appId, "budibase-client.js")
   );
   const manifestUpload = objectStore_exports2.upload({
     bucket: ObjectStoreBuckets2.APPS,
-    filename: (0, import_path7.join)(appId, "manifest.json.bak"),
+    filename: (0, import_path6.join)(appId, "manifest.json.bak"),
     path: tmpManifestPath,
     type: "application/json"
   });
   const clientUpload = objectStore_exports2.upload({
     bucket: ObjectStoreBuckets2.APPS,
-    filename: (0, import_path7.join)(appId, "budibase-client.js.bak"),
+    filename: (0, import_path6.join)(appId, "budibase-client.js.bak"),
     path: tmpClientPath,
     type: "application/javascript"
   });
@@ -12377,7 +12294,7 @@ async function updateClientLibrary(appId) {
   let manifest, client3;
   if (environment_default2.isDev()) {
     const clientPath = devClientLibPath();
-    manifest = (0, import_path7.join)(import_path7.default.dirname(import_path7.default.dirname(clientPath)), "manifest.json");
+    manifest = (0, import_path6.join)(import_path6.default.dirname(import_path6.default.dirname(clientPath)), "manifest.json");
     client3 = clientPath;
   } else {
     manifest = resolve(TOP_LEVEL_PATH, "client", "manifest.json");
@@ -12385,16 +12302,16 @@ async function updateClientLibrary(appId) {
   }
   const manifestUpload = objectStore_exports2.streamUpload(
     ObjectStoreBuckets2.APPS,
-    (0, import_path7.join)(appId, "manifest.json"),
-    import_fs6.default.createReadStream(manifest),
+    (0, import_path6.join)(appId, "manifest.json"),
+    import_fs5.default.createReadStream(manifest),
     {
       ContentType: "application/json"
     }
   );
   const clientUpload = objectStore_exports2.streamUpload(
     ObjectStoreBuckets2.APPS,
-    (0, import_path7.join)(appId, "budibase-client.js"),
-    import_fs6.default.createReadStream(client3),
+    (0, import_path6.join)(appId, "budibase-client.js"),
+    import_fs5.default.createReadStream(client3),
     {
       ContentType: "application/javascript"
     }
@@ -12404,32 +12321,32 @@ async function updateClientLibrary(appId) {
 async function revertClientLibrary(appId) {
   const tmpManifestPath = await objectStore_exports2.retrieveToTmp(
     ObjectStoreBuckets2.APPS,
-    (0, import_path7.join)(appId, "manifest.json.bak")
+    (0, import_path6.join)(appId, "manifest.json.bak")
   );
   const tmpClientPath = await objectStore_exports2.retrieveToTmp(
     ObjectStoreBuckets2.APPS,
-    (0, import_path7.join)(appId, "budibase-client.js.bak")
+    (0, import_path6.join)(appId, "budibase-client.js.bak")
   );
   const manifestUpload = objectStore_exports2.upload({
     bucket: ObjectStoreBuckets2.APPS,
-    filename: (0, import_path7.join)(appId, "manifest.json"),
+    filename: (0, import_path6.join)(appId, "manifest.json"),
     path: tmpManifestPath,
     type: "application/json"
   });
   const clientUpload = objectStore_exports2.upload({
     bucket: ObjectStoreBuckets2.APPS,
-    filename: (0, import_path7.join)(appId, "budibase-client.js"),
+    filename: (0, import_path6.join)(appId, "budibase-client.js"),
     path: tmpClientPath,
     type: "application/javascript"
   });
   await Promise.all([manifestUpload, clientUpload]);
 }
-var import_path7, import_fs6;
+var import_path6, import_fs5;
 var init_clientLibrary = __esm({
   "src/utilities/fileSystem/clientLibrary.ts"() {
-    import_path7 = __toESM(require("path"));
+    import_path6 = __toESM(require("path"));
     init_constants4();
-    import_fs6 = __toESM(require("fs"));
+    import_fs5 = __toESM(require("fs"));
     init_src2();
     init_centralPath();
     init_environment3();
@@ -12438,18 +12355,18 @@ var init_clientLibrary = __esm({
 });
 
 // src/utilities/fileSystem/app.ts
-var import_fs7, import_path8, NODE_MODULES_PATH, createApp, deleteApp, getComponentLibraryManifest;
+var import_fs6, import_path7, NODE_MODULES_PATH, createApp, deleteApp, getComponentLibraryManifest;
 var init_app7 = __esm({
   "src/utilities/fileSystem/app.ts"() {
     init_budibaseDir();
-    import_fs7 = __toESM(require("fs"));
-    import_path8 = require("path");
+    import_fs6 = __toESM(require("fs"));
+    import_path7 = require("path");
     init_constants4();
     init_clientLibrary();
     init_environment3();
     init_src2();
     init_filesystem();
-    NODE_MODULES_PATH = (0, import_path8.join)(TOP_LEVEL_PATH, "node_modules");
+    NODE_MODULES_PATH = (0, import_path7.join)(TOP_LEVEL_PATH, "node_modules");
     createApp = async (appId) => {
       await updateClientLibrary(appId);
     };
@@ -12461,11 +12378,11 @@ var init_app7 = __esm({
       const filename = "manifest.json";
       if (environment_default2.isDev() || environment_default2.isTest()) {
         const paths = [
-          (0, import_path8.join)(TOP_LEVEL_PATH, "packages/client", filename),
-          (0, import_path8.join)(process.cwd(), "client", filename)
+          (0, import_path7.join)(TOP_LEVEL_PATH, "packages/client", filename),
+          (0, import_path7.join)(process.cwd(), "client", filename)
         ];
         for (let path6 of paths) {
-          if (import_fs7.default.existsSync(path6)) {
+          if (import_fs6.default.existsSync(path6)) {
             delete require.cache[require.resolve(path6)];
             return require(path6);
           }
@@ -12480,14 +12397,14 @@ var init_app7 = __esm({
       let resp;
       let path5;
       try {
-        path5 = (0, import_path8.join)(appId, filename);
+        path5 = (0, import_path7.join)(appId, filename);
         resp = await objectStore_exports2.retrieve(ObjectStoreBuckets2.APPS, path5);
       } catch (error2) {
         console.error(
           `component-manifest-objectstore=failed appId=${appId} path=${path5}`,
           error2
         );
-        path5 = (0, import_path8.join)(appId, "node_modules", library, "package", filename);
+        path5 = (0, import_path7.join)(appId, "node_modules", library, "package", filename);
         resp = await objectStore_exports2.retrieve(ObjectStoreBuckets2.APPS, path5);
       }
       if (typeof resp !== "string") {
@@ -12502,19 +12419,19 @@ var init_app7 = __esm({
 async function getPluginImpl(path5, plugin) {
   var _a2;
   const hash3 = (_a2 = plugin.schema) == null ? void 0 : _a2.hash;
-  if (!import_fs8.default.existsSync(path5)) {
-    import_fs8.default.mkdirSync(path5);
+  if (!import_fs7.default.existsSync(path5)) {
+    import_fs7.default.mkdirSync(path5);
   }
-  const filename = (0, import_path9.join)(path5, plugin.name);
+  const filename = (0, import_path8.join)(path5, plugin.name);
   const metadataName = `${filename}.bbmetadata`;
-  if (import_fs8.default.existsSync(filename)) {
-    const currentHash = import_fs8.default.readFileSync(metadataName, "utf8");
+  if (import_fs7.default.existsSync(filename)) {
+    const currentHash = import_fs7.default.readFileSync(metadataName, "utf8");
     if (currentHash === hash3) {
       return require(filename);
     } else {
       console.log(`Updating plugin: ${plugin.name}`);
       delete require.cache[require.resolve(filename)];
-      import_fs8.default.unlinkSync(filename);
+      import_fs7.default.unlinkSync(filename);
     }
   }
   const pluginKey = objectStore_exports2.getPluginJSKey(plugin);
@@ -12522,24 +12439,24 @@ async function getPluginImpl(path5, plugin) {
     objectStore_exports2.ObjectStoreBuckets.PLUGINS,
     pluginKey
   );
-  import_fs8.default.writeFileSync(filename, pluginJs);
-  import_fs8.default.writeFileSync(metadataName, hash3);
+  import_fs7.default.writeFileSync(filename, pluginJs);
+  import_fs7.default.writeFileSync(metadataName, hash3);
   return require(filename);
 }
-var import_fs8, import_path9, DATASOURCE_PATH, AUTOMATION_PATH, getPluginMetadata, getDatasourcePlugin, getAutomationPlugin;
+var import_fs7, import_path8, DATASOURCE_PATH, AUTOMATION_PATH, getPluginMetadata, getDatasourcePlugin, getAutomationPlugin;
 var init_plugin5 = __esm({
   "src/utilities/fileSystem/plugin.ts"() {
     init_budibaseDir();
-    import_fs8 = __toESM(require("fs"));
-    import_path9 = require("path");
+    import_fs7 = __toESM(require("fs"));
+    import_path8 = require("path");
     init_src2();
-    DATASOURCE_PATH = (0, import_path9.join)(budibaseTempDir2(), "datasource");
-    AUTOMATION_PATH = (0, import_path9.join)(budibaseTempDir2(), "automation");
+    DATASOURCE_PATH = (0, import_path8.join)(budibaseTempDir2(), "datasource");
+    AUTOMATION_PATH = (0, import_path8.join)(budibaseTempDir2(), "automation");
     getPluginMetadata = async (path5) => {
       let metadata2 = {};
       try {
-        const pkg2 = import_fs8.default.readFileSync((0, import_path9.join)(path5, "package.json"), "utf8");
-        const schema = import_fs8.default.readFileSync((0, import_path9.join)(path5, "schema.json"), "utf8");
+        const pkg2 = import_fs7.default.readFileSync((0, import_path8.join)(path5, "package.json"), "utf8");
+        const schema = import_fs7.default.readFileSync((0, import_path8.join)(path5, "schema.json"), "utf8");
         metadata2.schema = JSON.parse(schema);
         metadata2.package = JSON.parse(pkg2);
         if (!metadata2.package.name || !metadata2.package.version || !metadata2.package.description) {
@@ -13807,21 +13724,21 @@ __export(version_exports, {
   getLicenseVersion: () => getLicenseVersion,
   getProVersion: () => getProVersion
 });
-var import_fs9, import_path10, getLicenseVersion, getProVersion;
+var import_fs8, import_path9, getLicenseVersion, getProVersion;
 var init_version2 = __esm({
   "../pro/packages/pro/src/constants/version.ts"() {
     init_src2();
-    import_fs9 = __toESM(require("fs"));
-    import_path10 = __toESM(require("path"));
+    import_fs8 = __toESM(require("fs"));
+    import_path9 = __toESM(require("path"));
     getLicenseVersion = () => {
       if (environment_default.isDev()) {
         const DEV_VER_FILENAME = "dev-version.txt";
-        const verFile = import_path10.default.join(objectStore_exports2.budibaseTempDir(), DEV_VER_FILENAME);
-        if (import_fs9.default.existsSync(verFile)) {
-          return import_fs9.default.readFileSync(verFile, "utf8");
+        const verFile = import_path9.default.join(objectStore_exports2.budibaseTempDir(), DEV_VER_FILENAME);
+        if (import_fs8.default.existsSync(verFile)) {
+          return import_fs8.default.readFileSync(verFile, "utf8");
         } else {
           const devVer = utils_exports2.newid();
-          import_fs9.default.writeFileSync(verFile, devVer);
+          import_fs8.default.writeFileSync(verFile, devVer);
           return devVer;
         }
       } else {
@@ -14267,31 +14184,31 @@ function getOfflineLicense() {
   }
 }
 function getOfflineLicenseFromDisk() {
-  if (import_fs10.default.existsSync(LICENSE_FILE_PATH)) {
-    const token = import_fs10.default.readFileSync(LICENSE_FILE_PATH, { encoding: "utf-8" });
+  if (import_fs9.default.existsSync(LICENSE_FILE_PATH)) {
+    const token = import_fs9.default.readFileSync(LICENSE_FILE_PATH, { encoding: "utf-8" });
     return import_jsonwebtoken.default.verify(token, PUBLIC_KEY, { algorithms: ["RS256"] });
   }
 }
 function writeOfflineLicenseToDisk(signedLicense) {
-  import_fs10.default.writeFileSync(LICENSE_FILE_PATH, signedLicense, { encoding: "utf-8" });
+  import_fs9.default.writeFileSync(LICENSE_FILE_PATH, signedLicense, { encoding: "utf-8" });
 }
 function deleteOfflineLicense() {
-  import_fs10.default.rmSync(LICENSE_FILE_PATH, { force: true });
+  import_fs9.default.rmSync(LICENSE_FILE_PATH, { force: true });
 }
-var import_fs10, import_path11, import_os2, import_jsonwebtoken, SUB_DIRECTORY, DIRECTORY, OFFLINE_LICENSE_FILE, LICENSE_FILE_PATH, PUBLIC_KEY;
+var import_fs9, import_path10, import_os2, import_jsonwebtoken, SUB_DIRECTORY, DIRECTORY, OFFLINE_LICENSE_FILE, LICENSE_FILE_PATH, PUBLIC_KEY;
 var init_offline = __esm({
   "../pro/packages/pro/src/sdk/licensing/licenses/offline.ts"() {
-    import_fs10 = __toESM(require("fs"));
-    import_path11 = require("path");
+    import_fs9 = __toESM(require("fs"));
+    import_path10 = require("path");
     import_os2 = require("os");
     import_jsonwebtoken = __toESM(require("jsonwebtoken"));
     init_src2();
     SUB_DIRECTORY = environment_default.isTest() ? ".budibase-test" : ".budibase";
-    DIRECTORY = (0, import_path11.join)((0, import_os2.tmpdir)(), SUB_DIRECTORY);
+    DIRECTORY = (0, import_path10.join)((0, import_os2.tmpdir)(), SUB_DIRECTORY);
     OFFLINE_LICENSE_FILE = "offline_license.txt";
-    LICENSE_FILE_PATH = (0, import_path11.join)(DIRECTORY, OFFLINE_LICENSE_FILE);
-    if (!import_fs10.default.existsSync(DIRECTORY)) {
-      import_fs10.default.mkdirSync(DIRECTORY);
+    LICENSE_FILE_PATH = (0, import_path10.join)(DIRECTORY, OFFLINE_LICENSE_FILE);
+    if (!import_fs9.default.existsSync(DIRECTORY)) {
+      import_fs9.default.mkdirSync(DIRECTORY);
     }
     PUBLIC_KEY = "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAvz3jePLCFBXZ19c8Dpkv\nXtSgOhKFOcvQdo/LV0KJRUzQWDPWuO4ILtBtnqhjtIzZH4CH0qCYBet5L6Qr4CM1\nl2HXiAD1Q2rlHNW9wDaYyKb1F5f+v4RyqCAyzlkwRdksmkLeECTboojNnmRCrE3C\n8suunQP5bEScqEY2kclqzSf8e6xqMzPUg3mL/pNa1iEv7TuLbU9nJfgR36l0WmZY\n94fWnSaT8OSXSqcxsaByf06gfS3HAoTJNc7eqz1Hf9fUORQGPUAnFK8cT3SfdA36\nd/o3ZWE1TTj1zYwlCLN5qRKr3hU8nC3xEYNEbkB9SfTRaOq9Q7P8WmfLkoCPm3pR\nmwIDAQAB\n-----END PUBLIC KEY-----\n";
   }
@@ -15748,13 +15665,13 @@ var init_groups6 = __esm({
 
 // ../pro/packages/pro/src/utilities/fileSystem.ts
 function loadJSFile(directory2, name2) {
-  return import_fs11.default.readFileSync((0, import_path12.join)(directory2, name2), "utf8");
+  return import_fs10.default.readFileSync((0, import_path11.join)(directory2, name2), "utf8");
 }
-var import_fs11, import_path12;
+var import_fs10, import_path11;
 var init_fileSystem2 = __esm({
   "../pro/packages/pro/src/utilities/fileSystem.ts"() {
-    import_fs11 = __toESM(require("fs"));
-    import_path12 = require("path");
+    import_fs10 = __toESM(require("fs"));
+    import_path11 = require("path");
   }
 });
 
@@ -18721,8 +18638,8 @@ async function runBackup(trigger3, tenantId, appId, opts) {
       }
     });
     await updateMetadata2("complete" /* COMPLETE */, { filename, contents });
-    if (import_fs12.default.existsSync(tarPath)) {
-      import_fs12.default.rmSync(tarPath);
+    if (import_fs11.default.existsSync(tarPath)) {
+      import_fs11.default.rmSync(tarPath);
     }
   } catch (err) {
     logging_exports.logAlert("App backup error", err);
@@ -18780,14 +18697,14 @@ async function exportProcessor(job, opts) {
     });
   });
 }
-var import_fs12;
+var import_fs11;
 var init_processing = __esm({
   "../pro/packages/pro/src/sdk/backups/processing.ts"() {
     init_src2();
     init_backup5();
     init_src();
     init_queue4();
-    import_fs12 = __toESM(require("fs"));
+    import_fs11 = __toESM(require("fs"));
   }
 });
 
@@ -19470,15 +19387,15 @@ async function downloadBackup(ctx) {
   const backupId = ctx.params.backupId;
   const { metadata: metadata2, path: path5 } = await backups_default.downloadAppBackup(backupId);
   ctx.attachment(`backup-${metadata2.timestamp}.tar.gz`);
-  ctx.body = import_fs13.default.createReadStream(path5);
+  ctx.body = import_fs12.default.createReadStream(path5);
 }
-var import_fs13;
+var import_fs12;
 var init_backups3 = __esm({
   "../pro/packages/pro/src/api/controllers/apps/backups.ts"() {
     init_src();
     init_sdk2();
     init_src2();
-    import_fs13 = __toESM(require("fs"));
+    import_fs12 = __toESM(require("fs"));
   }
 });
 
@@ -20117,39 +20034,11 @@ var init_filters = __esm({
 // ../shared-core/src/utils.ts
 var utils_exports5 = {};
 __export(utils_exports5, {
-  parallelForeach: () => parallelForeach,
   unreachable: () => unreachable
 });
 function unreachable(value, message = `No such case in exhaustive switch: ${value}`) {
   throw new Error(message);
 }
-async function parallelForeach(items, task, maxConcurrency) {
-  const promises = [];
-  let index2 = 0;
-  const processItem = async (item) => {
-    try {
-      await task(item);
-    } finally {
-      processNext();
-    }
-  };
-  const processNext = () => {
-    if (index2 >= items.length) {
-      return;
-    }
-    const item = items[index2];
-    index2++;
-    const promise = processItem(item);
-    promises.push(promise);
-    if (promises.length >= maxConcurrency) {
-      Promise.race(promises).then(processNext);
-    } else {
-      processNext();
-    }
-  };
-  processNext();
-  await Promise.all(promises);
-}
 var init_utils13 = __esm({
   "../shared-core/src/utils.ts"() {
   }
@@ -20743,7 +20632,7 @@ var init_currentapp = __esm({
             userId,
             globalId,
             roleId,
-            role: await roles_exports.getRole(roleId, { defaultPublic: true })
+            role: await roles_exports.getRole(roleId)
           };
         }
         return next();
@@ -24394,6 +24283,13 @@ function convertBookmark(bookmark) {
   }
   return bookmark;
 }
+function isQsTrue(param) {
+  if (typeof param === "string") {
+    return param.toLowerCase() === "true";
+  } else {
+    return param === true;
+  }
+}
 var import_stream2, Readable, isDev3, NUMBER_REGEX;
 var init_utilities2 = __esm({
   "src/utilities/index.ts"() {
@@ -24447,16 +24343,7 @@ async function checkResponse(response2, errorMsg, { ctx } = {}) {
   }
   return response2.json();
 }
-async function sendSmtpEmail({
-  to,
-  from,
-  subject,
-  contents,
-  cc,
-  bcc,
-  automation,
-  invite
-}) {
+async function sendSmtpEmail(to, from, subject, contents, cc, bcc, automation) {
   const response2 = await (0, import_node_fetch8.default)(
     checkSlashesInUrl2(environment_default2.WORKER_URL + `/api/global/email/send`),
     request(void 0, {
@@ -24469,8 +24356,7 @@ async function sendSmtpEmail({
         cc,
         bcc,
         purpose: "custom",
-        automation,
-        invite
+        automation
       }
     })
   );
@@ -24963,22 +24849,22 @@ function threadSetup() {
   init10();
 }
 async function checkCacheForDynamicVariable(queryId, variable) {
-  const cache3 = await getClient3();
-  return cache3.get(makeVariableKey(queryId, variable));
+  const cache2 = await getClient3();
+  return cache2.get(makeVariableKey(queryId, variable));
 }
 async function invalidateDynamicVariables(cachedVars) {
-  const cache3 = await getClient3();
+  const cache2 = await getClient3();
   let promises = [];
   for (let variable of cachedVars) {
     promises.push(
-      cache3.delete(makeVariableKey(variable.queryId, variable.name))
+      cache2.delete(makeVariableKey(variable.queryId, variable.name))
     );
   }
   await Promise.all(promises);
 }
 async function storeDynamicVariable(queryId, variable, value) {
-  const cache3 = await getClient3();
-  await cache3.store(
+  const cache2 = await getClient3();
+  await cache2.store(
     makeVariableKey(queryId, variable),
     value,
     VARIABLE_TTL_SECONDS
@@ -25038,14 +24924,13 @@ __export(exports_exports, {
   streamExportApp: () => streamExportApp
 });
 function tarFilesToTmp(tmpDir, files2) {
-  const fileName = `${uuid3()}.tar.gz`;
-  const exportFile = (0, import_path13.join)(budibaseTempDir2(), fileName);
-  import_tar2.default.create(
+  const exportFile = (0, import_path12.join)(budibaseTempDir2(), `${uuid3()}.tar.gz`);
+  tar3.create(
     {
       sync: true,
       gzip: true,
       file: exportFile,
-      noDirRecurse: false,
+      recursive: true,
       cwd: tmpDir
     },
     files2
@@ -25062,7 +24947,7 @@ async function exportDB(dbName, opts = {}) {
   return db_exports.doWithDB(dbName, async (db2) => {
     if (opts == null ? void 0 : opts.exportPath) {
       const path5 = opts == null ? void 0 : opts.exportPath;
-      const writeStream = import_fs14.default.createWriteStream(path5);
+      const writeStream = import_fs13.default.createWriteStream(path5);
       await db2.dump(writeStream, exportOpts);
       return path5;
     } else {
@@ -25095,9 +24980,9 @@ async function exportApp(appId, config) {
       for (let path5 of STATIC_APP_FILES) {
         const contents = await objectStore_exports2.retrieve(
           ObjectStoreBuckets2.APPS,
-          (0, import_path13.join)(appPath, path5)
+          (0, import_path12.join)(appPath, path5)
         );
-        import_fs14.default.writeFileSync((0, import_path13.join)(tmpPath, path5), contents);
+        import_fs13.default.writeFileSync((0, import_path12.join)(tmpPath, path5), contents);
       }
     } else {
       tmpPath = await objectStore_exports2.retrieveDirectory(
@@ -25106,52 +24991,37 @@ async function exportApp(appId, config) {
       );
     }
   }
-  const downloadedPath = (0, import_path13.join)(tmpPath, appPath);
-  if (import_fs14.default.existsSync(downloadedPath)) {
-    const allFiles = import_fs14.default.readdirSync(downloadedPath);
+  const downloadedPath = (0, import_path12.join)(tmpPath, appPath);
+  if (import_fs13.default.existsSync(downloadedPath)) {
+    const allFiles = import_fs13.default.readdirSync(downloadedPath);
     for (let file of allFiles) {
-      const path5 = (0, import_path13.join)(downloadedPath, file);
-      import_fs14.default.renameSync(path5, (0, import_path13.join)(downloadedPath, "..", file));
+      const path5 = (0, import_path12.join)(downloadedPath, file);
+      import_fs13.default.renameSync(path5, (0, import_path12.join)(downloadedPath, "..", file));
     }
-    import_fs14.default.rmdirSync(downloadedPath);
+    import_fs13.default.rmdirSync(downloadedPath);
   }
-  const dbPath = (0, import_path13.join)(tmpPath, DB_EXPORT_FILE);
+  const dbPath = (0, import_path12.join)(tmpPath, DB_EXPORT_FILE);
   await exportDB(appId, {
     filter: defineFilter(config == null ? void 0 : config.excludeRows, config == null ? void 0 : config.excludeLogs),
     exportPath: dbPath
   });
-  if (config == null ? void 0 : config.encryptPassword) {
-    for (let file of import_fs14.default.readdirSync(tmpPath)) {
-      const path5 = (0, import_path13.join)(tmpPath, file);
-      await encryption_exports.encryptFile(
-        { dir: tmpPath, filename: file },
-        config.encryptPassword
-      );
-      import_fs14.default.rmSync(path5);
-    }
-  }
   if (config == null ? void 0 : config.tar) {
-    const tarPath = tarFilesToTmp(tmpPath, import_fs14.default.readdirSync(tmpPath));
-    import_fs14.default.rmSync(tmpPath, { recursive: true, force: true });
+    const tarPath = tarFilesToTmp(tmpPath, import_fs13.default.readdirSync(tmpPath));
+    import_fs13.default.rmSync(tmpPath, { recursive: true, force: true });
     return tarPath;
   } else {
     return tmpPath;
   }
 }
-async function streamExportApp({
-  appId,
-  excludeRows,
-  encryptPassword
-}) {
+async function streamExportApp(appId, excludeRows) {
   const tmpPath = await exportApp(appId, {
     excludeRows,
     excludeLogs: true,
-    tar: true,
-    encryptPassword
+    tar: true
   });
   return streamFile(tmpPath);
 }
-var import_fs14, import_path13, import_tar2, uuid3, MemoryStream2;
+var import_fs13, import_path12, uuid3, tar3, MemoryStream2;
 var init_exports2 = __esm({
   "src/sdk/app/backups/exports.ts"() {
     init_src2();
@@ -25160,11 +25030,11 @@ var init_exports2 = __esm({
     init_constants4();
     init_utils9();
     init_constants7();
-    import_fs14 = __toESM(require("fs"));
-    import_path13 = require("path");
+    import_fs13 = __toESM(require("fs"));
+    import_path12 = require("path");
     init_environment3();
-    import_tar2 = __toESM(require("tar"));
     uuid3 = require("uuid/v4");
+    tar3 = require("tar");
     MemoryStream2 = require("memorystream");
   }
 });
@@ -25241,16 +25111,16 @@ async function getTemplateStream(template) {
     throw new Error("Cannot import a non-text based file.");
   }
   if (template.file) {
-    return import_fs15.default.createReadStream(template.file.path);
+    return import_fs14.default.createReadStream(template.file.path);
   } else if (template.key) {
     const [type, name2] = template.key.split("/");
     const tmpPath = await downloadTemplate(type, name2);
-    return import_fs15.default.createReadStream((0, import_path14.join)(tmpPath, name2, "db", "dump.txt"));
+    return import_fs14.default.createReadStream((0, import_path13.join)(tmpPath, name2, "db", "dump.txt"));
   }
 }
 function untarFile(file) {
-  const tmpPath = (0, import_path14.join)(budibaseTempDir2(), uuid4());
-  import_fs15.default.mkdirSync(tmpPath);
+  const tmpPath = (0, import_path13.join)(budibaseTempDir2(), uuid4());
+  import_fs14.default.mkdirSync(tmpPath);
   tar4.extract({
     sync: true,
     cwd: tmpPath,
@@ -25258,49 +25128,31 @@ function untarFile(file) {
   });
   return tmpPath;
 }
-async function decryptFiles(path5, password) {
-  try {
-    for (let file of import_fs15.default.readdirSync(path5)) {
-      const inputPath = (0, import_path14.join)(path5, file);
-      const outputPath = inputPath.replace(/\.enc$/, "");
-      await encryption_exports.decryptFile(inputPath, outputPath, password);
-      import_fs15.default.rmSync(inputPath);
-    }
-  } catch (err) {
-    if (err.message === "incorrect header check") {
-      throw new Error("File cannot be imported");
-    }
-    throw err;
-  }
-}
 function getGlobalDBFile(tmpPath) {
-  return import_fs15.default.readFileSync((0, import_path14.join)(tmpPath, GLOBAL_DB_EXPORT_FILE), "utf8");
+  return import_fs14.default.readFileSync((0, import_path13.join)(tmpPath, GLOBAL_DB_EXPORT_FILE), "utf8");
 }
 function getListOfAppsInMulti(tmpPath) {
-  return import_fs15.default.readdirSync(tmpPath).filter((dir) => dir !== GLOBAL_DB_EXPORT_FILE);
+  return import_fs14.default.readdirSync(tmpPath).filter((dir) => dir !== GLOBAL_DB_EXPORT_FILE);
 }
 async function importApp(appId, db2, template) {
   var _a2, _b2;
   let prodAppId = db_exports.getProdAppID(appId);
   let dbStream;
   const isTar = template.file && ((_b2 = (_a2 = template == null ? void 0 : template.file) == null ? void 0 : _a2.type) == null ? void 0 : _b2.endsWith("gzip"));
-  const isDirectory = template.file && import_fs15.default.lstatSync(template.file.path).isDirectory();
+  const isDirectory = template.file && import_fs14.default.lstatSync(template.file.path).isDirectory();
   if (template.file && (isTar || isDirectory)) {
     const tmpPath = isTar ? untarFile(template.file) : template.file.path;
-    if (isTar && template.file.password) {
-      await decryptFiles(tmpPath, template.file.password);
-    }
-    const contents = import_fs15.default.readdirSync(tmpPath);
+    const contents = import_fs14.default.readdirSync(tmpPath);
     if (contents.length) {
       let promises = [];
       let excludedFiles = [GLOBAL_DB_EXPORT_FILE, DB_EXPORT_FILE];
       for (let filename of contents) {
-        const path5 = (0, import_path14.join)(tmpPath, filename);
+        const path5 = (0, import_path13.join)(tmpPath, filename);
         if (excludedFiles.includes(filename)) {
           continue;
         }
-        filename = (0, import_path14.join)(prodAppId, filename);
-        if (import_fs15.default.lstatSync(path5).isDirectory()) {
+        filename = (0, import_path13.join)(prodAppId, filename);
+        if (import_fs14.default.lstatSync(path5).isDirectory()) {
           promises.push(
             objectStore_exports2.uploadDirectory(ObjectStoreBuckets2.APPS, path5, filename)
           );
@@ -25316,7 +25168,7 @@ async function importApp(appId, db2, template) {
       }
       await Promise.all(promises);
     }
-    dbStream = import_fs15.default.createReadStream((0, import_path14.join)(tmpPath, DB_EXPORT_FILE));
+    dbStream = import_fs14.default.createReadStream((0, import_path13.join)(tmpPath, DB_EXPORT_FILE));
   } else {
     dbStream = await getTemplateStream(template);
   }
@@ -25328,7 +25180,7 @@ async function importApp(appId, db2, template) {
   await updateAutomations(prodAppId, db2);
   return ok;
 }
-var import_path14, import_fs15, uuid4, tar4;
+var import_path13, import_fs14, uuid4, tar4;
 var init_imports = __esm({
   "src/sdk/app/backups/imports.ts"() {
     init_src2();
@@ -25337,8 +25189,8 @@ var init_imports = __esm({
     init_constants7();
     init_fileSystem();
     init_constants4();
-    import_path14 = require("path");
-    import_fs15 = __toESM(require("fs"));
+    import_path13 = require("path");
+    import_fs14 = __toESM(require("fs"));
     init_sdk3();
     init_src();
     uuid4 = require("uuid/v4");
@@ -26645,8 +26497,7 @@ var init_postgres = __esm({
         try {
           await this.openConnection();
           const columnsResponse = await this.client.query(this.COLUMNS_SQL);
-          const names = columnsResponse.rows.map((row2) => row2.table_name);
-          return [...new Set(names)];
+          return columnsResponse.rows.map((row2) => row2.table_name);
         } finally {
           await this.closeConnection();
         }
@@ -27275,8 +27126,6 @@ var init_mongodb = __esm({
           response2.connected = true;
         } catch (e) {
           response2.error = e.message;
-        } finally {
-          await this.client.close();
         }
         return response2;
       }
@@ -29208,16 +29057,6 @@ var init_rest = __esm({
 });
 
 // src/integrations/googlesheets.ts
-async function setupCreationAuth(datasouce) {
-  if (datasouce.continueSetupId) {
-    const appId = context_exports.getAppId();
-    const tokens = await cache_exports.get(
-      `datasource:creation:${appId}:google:${datasouce.continueSetupId}`
-    );
-    datasouce.auth = tokens.tokens;
-    delete datasouce.continueSetupId;
-  }
-}
 var import_google_auth_library, import_google_spreadsheet, import_node_fetch10, ALLOWED_TYPES, SCHEMA12, GoogleSheetsIntegration, googlesheets_default;
 var init_googlesheets = __esm({
   "src/integrations/googlesheets.ts"() {
@@ -29255,7 +29094,7 @@ var init_googlesheets = __esm({
       },
       datasource: {
         spreadsheetId: {
-          display: "Spreadsheet URL",
+          display: "Google Sheet URL",
           type: "string" /* STRING */,
           required: true
         }
@@ -29376,7 +29215,6 @@ var init_googlesheets = __esm({
       async connect() {
         var _a2;
         try {
-          await setupCreationAuth(this.config);
           let googleConfig = await configs_exports.getGoogleDatasourceConfig();
           if (!googleConfig) {
             throw new HTTPError("Google config not found", 400);
@@ -29427,22 +29265,21 @@ var init_googlesheets = __esm({
         return table2;
       }
       async buildSchema(datasourceId, entities) {
+        if (!this.config.auth) {
+          return;
+        }
         await this.connect();
         const sheets = this.client.sheetsByIndex;
         const tables = {};
-        await utils_exports5.parallelForeach(
-          sheets,
-          async (sheet) => {
-            await sheet.getRows({ limit: 0, offset: 0 });
-            const id = buildExternalTableId(datasourceId, sheet.title);
-            tables[sheet.title] = this.getTableSchema(
-              sheet.title,
-              sheet.headerValues,
-              id
-            );
-          },
-          10
-        );
+        for (let sheet of sheets) {
+          await sheet.getRows();
+          const id = buildExternalTableId(datasourceId, sheet.title);
+          tables[sheet.title] = this.getTableSchema(
+            sheet.title,
+            sheet.headerValues,
+            id
+          );
+        }
         const final = finaliseExternalTables(tables, entities);
         this.tables = final.tables;
         this.schemaErrors = final.errors;
@@ -32234,41 +32071,21 @@ var init_automationUtils = __esm({
 
 // src/automations/steps/sendSmtpEmail.ts
 async function run3({ inputs }) {
-  let {
-    to,
-    from,
-    subject,
-    contents,
-    cc,
-    bcc,
-    addInvite,
-    startTime,
-    endTime,
-    summary,
-    location,
-    url
-  } = inputs;
+  let { to, from, subject, contents, cc, bcc } = inputs;
   if (!contents) {
     contents = "<h1>No content</h1>";
   }
   to = to || void 0;
   try {
-    let response2 = await sendSmtpEmail({
+    let response2 = await sendSmtpEmail(
       to,
       from,
       subject,
       contents,
       cc,
       bcc,
-      automation: true,
-      invite: addInvite ? {
-        startTime,
-        endTime,
-        summary,
-        location,
-        url
-      } : void 0
-    });
+      true
+    );
     return {
       success: true,
       response: response2
@@ -32324,35 +32141,6 @@ var init_sendSmtpEmail = __esm({
             contents: {
               type: "string" /* STRING */,
               title: "HTML Contents"
-            },
-            addInvite: {
-              type: "boolean" /* BOOLEAN */,
-              title: "Add calendar invite"
-            },
-            startTime: {
-              type: "date" /* DATE */,
-              title: "Start Time",
-              dependsOn: "addInvite"
-            },
-            endTime: {
-              type: "date" /* DATE */,
-              title: "End Time",
-              dependsOn: "addInvite"
-            },
-            summary: {
-              type: "string" /* STRING */,
-              title: "Meeting Summary",
-              dependsOn: "addInvite"
-            },
-            location: {
-              type: "string" /* STRING */,
-              title: "Location",
-              dependsOn: "addInvite"
-            },
-            url: {
-              type: "string" /* STRING */,
-              title: "URL",
-              dependsOn: "addInvite"
             }
           },
           required: ["to", "from", "subject", "contents"]
@@ -34863,19 +34651,6 @@ async function buildSchemaHelper(datasource2) {
   }
   return { tables: connector.tables, error: error2 };
 }
-async function buildFilteredSchema(datasource2, filter2) {
-  let { tables, error: error2 } = await buildSchemaHelper(datasource2);
-  let finalTables = tables;
-  if (filter2) {
-    finalTables = {};
-    for (let key in tables) {
-      if (filter2.some((filter3) => filter3.toLowerCase() === key.toLowerCase())) {
-        finalTables[key] = tables[key];
-      }
-    }
-  }
-  return { tables: finalTables, error: error2 };
-}
 async function fetch22(ctx) {
   const db2 = context_exports.getAppDB();
   const internalTables = await db2.allDocs(
@@ -34930,24 +34705,37 @@ async function information(ctx) {
   }
   const tableNames = await connector.getTableNames();
   ctx.body = {
-    tableNames: tableNames.sort()
+    tableNames
   };
 }
 async function buildSchemaFromDb(ctx) {
   const db2 = context_exports.getAppDB();
-  const tablesFilter = ctx.request.body.tablesFilter;
   const datasource2 = await sdk_default.datasources.get(ctx.params.datasourceId);
-  const { tables, error: error2 } = await buildFilteredSchema(datasource2, tablesFilter);
-  datasource2.entities = tables;
+  const tablesFilter = ctx.request.body.tablesFilter;
+  let { tables, error: error2 } = await buildSchemaHelper(datasource2);
+  if (tablesFilter) {
+    if (!datasource2.entities) {
+      datasource2.entities = {};
+    }
+    for (let key in tables) {
+      if (tablesFilter.some(
+        (filter2) => filter2.toLowerCase() === key.toLowerCase()
+      )) {
+        datasource2.entities[key] = tables[key];
+      }
+    }
+  } else {
+    datasource2.entities = tables;
+  }
   setDefaultDisplayColumns(datasource2);
   const dbResp = await db2.put(datasource2);
   datasource2._rev = dbResp.rev;
   const cleanedDatasource = await sdk_default.datasources.removeSecretSingle(datasource2);
-  const res = { datasource: cleanedDatasource };
+  const response2 = { datasource: cleanedDatasource };
   if (error2) {
-    res.error = error2;
+    response2.error = error2;
   }
-  ctx.body = res;
+  ctx.body = response2;
 }
 function setDefaultDisplayColumns(datasource2) {
   for (let entity of Object.values(datasource2.entities || {})) {
@@ -35021,7 +34809,6 @@ async function save13(ctx) {
   const db2 = context_exports.getAppDB();
   const plus = ctx.request.body.datasource.plus;
   const fetchSchema = ctx.request.body.fetchSchema;
-  const tablesFilter = ctx.request.body.tablesFilter;
   const datasource2 = {
     _id: generateDatasourceID({ plus }),
     ...ctx.request.body.datasource,
@@ -35029,17 +34816,11 @@ async function save13(ctx) {
   };
   let schemaError = null;
   if (fetchSchema) {
-    const { tables, error: error2 } = await buildFilteredSchema(
-      datasource2,
-      tablesFilter
-    );
+    const { tables, error: error2 } = await buildSchemaHelper(datasource2);
     schemaError = error2;
     datasource2.entities = tables;
     setDefaultDisplayColumns(datasource2);
   }
-  if (preSaveAction[datasource2.source]) {
-    await preSaveAction[datasource2.source](datasource2);
-  }
   const dbResp = await db2.put(datasource2);
   await events_exports.datasource.created(datasource2);
   datasource2._rev = dbResp.rev;
@@ -35118,7 +34899,6 @@ async function query(ctx) {
     ctx.throw(400, err);
   }
 }
-var preSaveAction;
 var init_datasource5 = __esm({
   "src/api/controllers/datasource.ts"() {
     init_utils9();
@@ -35128,15 +34908,8 @@ var init_datasource5 = __esm({
     init_utils24();
     init_utils18();
     init_src2();
-    init_src();
     init_sdk3();
     init_websockets();
-    init_googlesheets();
-    preSaveAction = {
-      ["GOOGLE_SHEETS" /* GOOGLE_SHEETS */]: async (datasource2) => {
-        await setupCreationAuth(datasource2.config);
-      }
-    };
   }
 });
 
@@ -37980,8 +37753,6 @@ function process2(updateCb) {
     } catch (err) {
       if ((err == null ? void 0 : err.status) === 404) {
         return;
-      } else if ((err == null ? void 0 : err.status) === 409) {
-        return;
       } else {
         logging_exports.logAlert("Failed to perform user/group app sync", err);
       }
@@ -38980,6 +38751,7 @@ async function fetchAppPackage(ctx) {
   let application2 = await db2.get(DocumentType2.APP_METADATA);
   const layouts = await getLayouts();
   let screens = await getScreens();
+  const license = await licensing_exports.getLicense();
   application2.usedPlugins = objectStore_exports2.enrichPluginURLs(
     application2.usedPlugins
   );
@@ -38994,6 +38766,7 @@ async function fetchAppPackage(ctx) {
   );
   ctx.body = {
     application: { ...application2, upgradableVersion: environment_default.VERSION },
+    licenseType: (license == null ? void 0 : license.plan.type) || "free" /* FREE */,
     screens,
     layouts,
     clientLibPath,
@@ -39327,7 +39100,6 @@ var init_application = __esm({
     init_workerRequests();
     init_utilities2();
     init_redis4();
-    init_fileSystem();
     init_utils27();
     init_logging3();
     init_rows6();
@@ -41863,23 +41635,17 @@ var init_query6 = __esm({
 
 // src/api/controllers/backup.ts
 async function exportAppDump(ctx) {
-  const { appId } = ctx.query;
-  const { excludeRows, encryptPassword } = ctx.request.body;
-  const [app2] = await db_exports.getAppsByIDs([appId]);
-  const appName = app2.name;
+  let { appId, excludeRows } = ctx.query;
   ctx.req.setTimeout(0);
-  const extension = encryptPassword ? "enc.tar.gz" : "tar.gz";
-  const backupIdentifier = `${appName}-export-${(/* @__PURE__ */ new Date()).getTime()}.${extension}`;
+  const appName = decodeURI(ctx.query.appname);
+  excludeRows = isQsTrue(excludeRows);
+  const backupIdentifier = `${appName}-export-${(/* @__PURE__ */ new Date()).getTime()}.tar.gz`;
   ctx.attachment(backupIdentifier);
-  ctx.body = await sdk_default.backups.streamExportApp({
-    appId,
-    excludeRows,
-    encryptPassword
-  });
+  ctx.body = await sdk_default.backups.streamExportApp(appId, excludeRows);
   await context_exports.doInAppContext(appId, async () => {
     const appDb = context_exports.getAppDB();
-    const app3 = await appDb.get(DocumentType2.APP_METADATA);
-    await events_exports.app.exported(app3);
+    const app2 = await appDb.get(DocumentType2.APP_METADATA);
+    await events_exports.app.exported(app2);
   });
 }
 var init_backup6 = __esm({
@@ -41887,6 +41653,7 @@ var init_backup6 = __esm({
     init_sdk3();
     init_src2();
     init_utils9();
+    init_utilities2();
   }
 });
 
@@ -41899,7 +41666,7 @@ var init_backup7 = __esm({
     init_authorized();
     init_src2();
     router28 = new import_router28.default();
-    router28.post(
+    router28.get(
       "/api/backups/export",
       authorized_default(permissions_exports.BUILDER),
       exportAppDump
@@ -43331,18 +43098,18 @@ async function npmUpload(url, name2, headers = {}) {
   }
   try {
     await extractTarball(tarballPluginFile, path5);
-    deleteFolderFileSystem((0, import_path15.join)(path5, "package"));
+    deleteFolderFileSystem((0, import_path14.join)(path5, "package"));
   } catch (err) {
     throw new Error(err);
   }
   return await getPluginMetadata(path5);
 }
-var import_node_fetch20, import_path15;
+var import_node_fetch20, import_path14;
 var init_npm = __esm({
   "src/api/controllers/plugin/npm.ts"() {
     init_fileSystem();
     import_node_fetch20 = __toESM(require("node-fetch"));
-    import_path15 = require("path");
+    import_path14 = require("path");
     init_utils28();
   }
 });
@@ -43550,7 +43317,7 @@ async function prepareUpload({ s3Key, bucket, metadata: metadata2, file }) {
     key: response2.Key
   };
 }
-var import_string_templates10, import_aws_sdk4, import_fs16, uuid5, send2, toggleBetaUiFeature, serveBuilder, uploadFile, deleteObjects, serveApp, serveBuilderPreview, serveClientLibrary, getSignedUploadURL;
+var import_string_templates10, import_aws_sdk4, import_fs15, uuid5, send2, toggleBetaUiFeature, serveBuilder, uploadFile, deleteObjects, serveApp, serveBuilderPreview, serveClientLibrary, getSignedUploadURL;
 var init_static = __esm({
   "src/api/controllers/static/index.ts"() {
     init_centralPath();
@@ -43561,7 +43328,7 @@ var init_static = __esm({
     init_utils9();
     init_src2();
     import_aws_sdk4 = __toESM(require("aws-sdk"));
-    import_fs16 = __toESM(require("fs"));
+    import_fs15 = __toESM(require("fs"));
     init_sdk3();
     init_src4();
     require("svelte/register");
@@ -43576,9 +43343,9 @@ var init_static = __esm({
         };
         return;
       }
-      let builderPath = join4(TOP_LEVEL_PATH, "new_design_ui");
-      if (!import_fs16.default.existsSync(builderPath)) {
-        import_fs16.default.mkdirSync(builderPath);
+      let builderPath = join3(TOP_LEVEL_PATH, "new_design_ui");
+      if (!import_fs15.default.existsSync(builderPath)) {
+        import_fs15.default.mkdirSync(builderPath);
       }
       await objectStore_exports2.downloadTarballDirect(
         "https://cdn.budi.live/beta:design_ui/new_ui.tar.gz",
@@ -43590,7 +43357,7 @@ var init_static = __esm({
       };
     };
     serveBuilder = async function(ctx) {
-      const builderPath = join4(TOP_LEVEL_PATH, "builder");
+      const builderPath = join3(TOP_LEVEL_PATH, "builder");
       await send2(ctx, ctx.file, { root: builderPath });
     };
     uploadFile = async function(ctx) {
@@ -43679,7 +43446,7 @@ var init_static = __esm({
     };
     serveClientLibrary = async function(ctx) {
       return send2(ctx, "budibase-client.js", {
-        root: join4(NODE_MODULES_PATH, "@budibase", "client", "dist")
+        root: join3(NODE_MODULES_PATH, "@budibase", "client", "dist")
       });
     };
     getSignedUploadURL = async function(ctx) {
@@ -44999,13 +44766,13 @@ var init_routes = __esm({
 });
 
 // src/api/index.ts
-var import_router35, import_zlib3, compress, router35;
+var import_router35, import_zlib2, compress, router35;
 var init_api8 = __esm({
   "src/api/index.ts"() {
     import_router35 = __toESM(require("@koa/router"));
     init_src2();
     init_currentapp();
-    import_zlib3 = __toESM(require("zlib"));
+    import_zlib2 = __toESM(require("zlib"));
     init_routes();
     init_src4();
     init_public();
@@ -45018,10 +44785,10 @@ var init_api8 = __esm({
       compress({
         threshold: 2048,
         gzip: {
-          flush: import_zlib3.default.constants.Z_SYNC_FLUSH
+          flush: import_zlib2.default.constants.Z_SYNC_FLUSH
         },
         deflate: {
-          flush: import_zlib3.default.constants.Z_SYNC_FLUSH
+          flush: import_zlib2.default.constants.Z_SYNC_FLUSH
         },
         br: false
       })
@@ -45067,7 +44834,7 @@ var init_automations8 = __esm({
 
 // src/watch.ts
 function watch() {
-  const watchPath = import_path16.default.join(environment_default2.PLUGINS_DIR, "./**/*.tar.gz");
+  const watchPath = import_path15.default.join(environment_default2.PLUGINS_DIR, "./**/*.tar.gz");
   import_chokidar.default.watch(watchPath, {
     ignored: "**/node_modules",
     awaitWriteFinish: {
@@ -45077,7 +44844,7 @@ function watch() {
     usePolling: true,
     interval: 250
   }).on("all", async (event, path5) => {
-    if (!(path5 == null ? void 0 : path5.endsWith(".tar.gz")) || !import_fs17.default.existsSync(path5)) {
+    if (!(path5 == null ? void 0 : path5.endsWith(".tar.gz")) || !import_fs16.default.existsSync(path5)) {
       return;
     }
     await tenancy.doInTenant(constants_exports.DEFAULT_TENANT_ID, async () => {
@@ -45093,13 +44860,13 @@ function watch() {
     });
   });
 }
-var import_path16, import_chokidar, import_fs17;
+var import_path15, import_chokidar, import_fs16;
 var init_watch = __esm({
   "src/watch.ts"() {
-    import_path16 = __toESM(require("path"));
+    import_path15 = __toESM(require("path"));
     init_environment3();
     import_chokidar = __toESM(require("chokidar"));
-    import_fs17 = __toESM(require("fs"));
+    import_fs16 = __toESM(require("fs"));
     init_src2();
     init_plugins5();
   }
@@ -45155,7 +44922,7 @@ async function startup(app2, server2) {
       shutdown9(server2);
     }
   }
-  if (environment_default2.SELF_HOSTED && !environment_default2.MULTI_TENANCY && environment_default2.PLUGINS_DIR && import_fs18.default.existsSync(environment_default2.PLUGINS_DIR)) {
+  if (environment_default2.SELF_HOSTED && !environment_default2.MULTI_TENANCY && environment_default2.PLUGINS_DIR && import_fs17.default.existsSync(environment_default2.PLUGINS_DIR)) {
     watch();
   }
   await installation_exports.checkInstallVersion();
@@ -45190,14 +44957,14 @@ async function startup(app2, server2) {
     }
   }
 }
-var import_fs18, STARTUP_RAN;
+var import_fs17, STARTUP_RAN;
 var init_startup = __esm({
   "src/startup.ts"() {
     init_environment3();
     init_redis4();
     init_workerRequests();
     init_src2();
-    import_fs18 = __toESM(require("fs"));
+    import_fs17 = __toESM(require("fs"));
     init_watch();
     init_automations8();
     init_fileSystem();