@budibase/backend-core 2.11.42 → 2.11.44

package/dist/index.js

@@ -1753,11 +1753,11 @@ function getPackageJsonFields() {
     const content = (0, import_fs.readFileSync)(packageJsonFile, "utf-8");
     const parsedContent = JSON.parse(content);
     return {
-      VERSION: parsedContent.version,
+      VERSION: process.env.BUDIBASE_VERSION || parsedContent.version,
       SERVICE_NAME: parsedContent.name
     };
   } catch {
-    return { VERSION: "", SERVICE_NAME: "" };
+    return { VERSION: process.env.BUDIBASE_VERSION || "", SERVICE_NAME: "" };
   }
 }
 function isWorker() {
@@ -2141,8 +2141,8 @@ var init_pouchDB = __esm({
         import_pouchdb.default.adapter("writableStream", replicationStream.adapters.writableStream);
       }
       if (opts.find) {
-        const find = require("pouchdb-find");
-        import_pouchdb.default.plugin(find);
+        const find2 = require("pouchdb-find");
+        import_pouchdb.default.plugin(find2);
       }
       return import_pouchdb.default.defaults(POUCH_DB_DEFAULTS);
     };
@@ -2581,12 +2581,12 @@ function getAppId() {
     return foundId;
   }
 }
-function doInEnvironmentContext(values, task) {
-  if (!values) {
+function doInEnvironmentContext(values2, task) {
+  if (!values2) {
     throw new Error("Must supply environment variables.");
   }
   const updates = {
-    environmentVariables: values
+    environmentVariables: values2
   };
   return newContext(updates, task);
 }
@@ -4734,7 +4734,282 @@ 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_fetch3, import_tar_fs, import_zlib, import_util, import_path2, import_fs3, import_uuid2, sanitize, streamPipeline, STATE, CONTENT_TYPE_MAP, STRING_CONTENT_TYPES, ObjectStore, makeSureBucketExists, upload, streamUpload, retrieve, listAllObjects, getPresignedUrl, retrieveToTmp, retrieveDirectory, deleteFile, deleteFiles, deleteFolder, uploadDirectory, downloadTarballDirect, downloadTarball;
+function ObjectStore(bucket, opts = { presigning: false }) {
+  const config = {
+    s3ForcePathStyle: true,
+    signatureVersion: "v4",
+    apiVersion: "2006-03-01",
+    accessKeyId: environment_default.MINIO_ACCESS_KEY,
+    secretAccessKey: environment_default.MINIO_SECRET_KEY,
+    region: environment_default.AWS_REGION
+  };
+  if (bucket) {
+    config.params = {
+      Bucket: sanitizeBucket(bucket)
+    };
+  }
+  if (environment_default.MINIO_URL) {
+    if (opts.presigning && environment_default.MINIO_ENABLED) {
+      config.endpoint = "minio-service";
+    } else {
+      config.endpoint = environment_default.MINIO_URL;
+    }
+  }
+  return new import_aws_sdk.default.S3(config);
+}
+async function makeSureBucketExists(client, bucketName) {
+  bucketName = sanitizeBucket(bucketName);
+  try {
+    await client.headBucket({
+      Bucket: bucketName
+    }).promise();
+  } catch (err) {
+    const promises = STATE.bucketCreationPromises;
+    const doesntExist = err.statusCode === 404, noAccess = err.statusCode === 403;
+    if (promises[bucketName]) {
+      await promises[bucketName];
+    } else if (doesntExist || noAccess) {
+      if (doesntExist) {
+        promises[bucketName] = client.createBucket({
+          Bucket: bucketName
+        }).promise();
+        await promises[bucketName];
+        delete promises[bucketName];
+      }
+    } else {
+      throw new Error("Unable to write to object store bucket.");
+    }
+  }
+}
+async function upload({
+  bucket: bucketName,
+  filename,
+  path: path2,
+  type,
+  metadata
+}) {
+  const extension = filename.split(".").pop();
+  const fileBytes = import_fs3.default.readFileSync(path2);
+  const objectStore = ObjectStore(bucketName);
+  await makeSureBucketExists(objectStore, bucketName);
+  let contentType = type;
+  if (!contentType) {
+    contentType = extension ? CONTENT_TYPE_MAP[extension.toLowerCase()] : CONTENT_TYPE_MAP.txt;
+  }
+  const config = {
+    // windows file paths need to be converted to forward slashes for s3
+    Key: sanitizeKey(filename),
+    Body: fileBytes,
+    ContentType: contentType
+  };
+  if (metadata && typeof metadata === "object") {
+    for (let key of Object.keys(metadata)) {
+      if (!metadata[key] || typeof metadata[key] !== "string") {
+        delete metadata[key];
+      }
+    }
+    config.Metadata = metadata;
+  }
+  return objectStore.upload(config).promise();
+}
+async function streamUpload(bucketName, filename, stream2, extra = {}) {
+  const objectStore = ObjectStore(bucketName);
+  await makeSureBucketExists(objectStore, bucketName);
+  if (filename?.endsWith(".js")) {
+    extra = {
+      ...extra,
+      ContentType: "application/javascript"
+    };
+  } else if (filename?.endsWith(".svg")) {
+    extra = {
+      ...extra,
+      ContentType: "image"
+    };
+  }
+  const params2 = {
+    Bucket: sanitizeBucket(bucketName),
+    Key: sanitizeKey(filename),
+    Body: stream2,
+    ...extra
+  };
+  return objectStore.upload(params2).promise();
+}
+async function retrieve(bucketName, filepath) {
+  const objectStore = ObjectStore(bucketName);
+  const params2 = {
+    Bucket: sanitizeBucket(bucketName),
+    Key: sanitizeKey(filepath)
+  };
+  const response = await objectStore.getObject(params2).promise();
+  if (STRING_CONTENT_TYPES.includes(response.ContentType)) {
+    return response.Body.toString("utf8");
+  } else {
+    return response.Body;
+  }
+}
+async function listAllObjects(bucketName, path2) {
+  const objectStore = ObjectStore(bucketName);
+  const list = (params2 = {}) => {
+    return objectStore.listObjectsV2({
+      ...params2,
+      Bucket: sanitizeBucket(bucketName),
+      Prefix: sanitizeKey(path2)
+    }).promise();
+  };
+  let isTruncated = false, token, objects = [];
+  do {
+    let params2 = {};
+    if (token) {
+      params2.ContinuationToken = token;
+    }
+    const response = await list(params2);
+    if (response.Contents) {
+      objects = objects.concat(response.Contents);
+    }
+    isTruncated = !!response.IsTruncated;
+  } while (isTruncated);
+  return objects;
+}
+function getPresignedUrl(bucketName, key, durationSeconds = 3600) {
+  const objectStore = ObjectStore(bucketName, { presigning: true });
+  const params2 = {
+    Bucket: sanitizeBucket(bucketName),
+    Key: sanitizeKey(key),
+    Expires: durationSeconds
+  };
+  const url = objectStore.getSignedUrl("getObject", params2);
+  if (!environment_default.MINIO_ENABLED) {
+    return url;
+  } else {
+    const signedUrl = new URL(url);
+    const path2 = signedUrl.pathname;
+    const query = signedUrl.search;
+    return `/files/signed${path2}${query}`;
+  }
+}
+async function retrieveToTmp(bucketName, filepath) {
+  bucketName = sanitizeBucket(bucketName);
+  filepath = sanitizeKey(filepath);
+  const data = await retrieve(bucketName, filepath);
+  const outputPath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid2.v4)());
+  import_fs3.default.writeFileSync(outputPath, data);
+  return outputPath;
+}
+async function retrieveDirectory(bucketName, path2) {
+  let writePath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid2.v4)());
+  import_fs3.default.mkdirSync(writePath);
+  const objects = await listAllObjects(bucketName, path2);
+  let fullObjects = await Promise.all(
+    objects.map((obj) => retrieve(bucketName, obj.Key))
+  );
+  let count = 0;
+  for (let obj of objects) {
+    const filename = obj.Key;
+    const data = fullObjects[count++];
+    const possiblePath = filename.split("/");
+    if (possiblePath.length > 1) {
+      const dirs = possiblePath.slice(0, possiblePath.length - 1);
+      import_fs3.default.mkdirSync((0, import_path2.join)(writePath, ...dirs), { recursive: true });
+    }
+    import_fs3.default.writeFileSync((0, import_path2.join)(writePath, ...possiblePath), data);
+  }
+  return writePath;
+}
+async function deleteFile(bucketName, filepath) {
+  const objectStore = ObjectStore(bucketName);
+  await makeSureBucketExists(objectStore, bucketName);
+  const params2 = {
+    Bucket: bucketName,
+    Key: sanitizeKey(filepath)
+  };
+  return objectStore.deleteObject(params2).promise();
+}
+async function deleteFiles(bucketName, filepaths) {
+  const objectStore = ObjectStore(bucketName);
+  await makeSureBucketExists(objectStore, bucketName);
+  const params2 = {
+    Bucket: bucketName,
+    Delete: {
+      Objects: filepaths.map((path2) => ({ Key: sanitizeKey(path2) }))
+    }
+  };
+  return objectStore.deleteObjects(params2).promise();
+}
+async function deleteFolder(bucketName, folder) {
+  bucketName = sanitizeBucket(bucketName);
+  folder = sanitizeKey(folder);
+  const client = ObjectStore(bucketName);
+  const listParams = {
+    Bucket: bucketName,
+    Prefix: folder
+  };
+  const existingObjectsResponse = await client.listObjects(listParams).promise();
+  if (existingObjectsResponse.Contents?.length === 0) {
+    return;
+  }
+  const deleteParams = {
+    Bucket: bucketName,
+    Delete: {
+      Objects: []
+    }
+  };
+  existingObjectsResponse.Contents?.forEach((content) => {
+    deleteParams.Delete.Objects.push({ Key: content.Key });
+  });
+  const deleteResponse = await client.deleteObjects(deleteParams).promise();
+  if (deleteResponse.Deleted?.length === 1e3) {
+    return deleteFolder(bucketName, folder);
+  }
+}
+async function uploadDirectory(bucketName, localPath, bucketPath) {
+  bucketName = sanitizeBucket(bucketName);
+  let uploads = [];
+  const files = import_fs3.default.readdirSync(localPath, { withFileTypes: true });
+  for (let file of files) {
+    const path2 = sanitizeKey((0, import_path2.join)(bucketPath, file.name));
+    const local = (0, import_path2.join)(localPath, file.name);
+    if (file.isDirectory()) {
+      uploads.push(uploadDirectory(bucketName, local, path2));
+    } else {
+      uploads.push(streamUpload(bucketName, path2, import_fs3.default.createReadStream(local)));
+    }
+  }
+  await Promise.all(uploads);
+  return files;
+}
+async function downloadTarballDirect(url, path2, headers = {}) {
+  path2 = sanitizeKey(path2);
+  const response = await (0, import_node_fetch3.default)(url, { headers });
+  if (!response.ok) {
+    throw new Error(`unexpected response ${response.statusText}`);
+  }
+  await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(path2));
+}
+async function downloadTarball(url, bucketName, path2) {
+  bucketName = sanitizeBucket(bucketName);
+  path2 = sanitizeKey(path2);
+  const response = await (0, import_node_fetch3.default)(url);
+  if (!response.ok) {
+    throw new Error(`unexpected response ${response.statusText}`);
+  }
+  const tmpPath = (0, import_path2.join)(budibaseTempDir(), path2);
+  await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
+  if (!environment_default.isTest() && environment_default.SELF_HOSTED) {
+    await uploadDirectory(bucketName, tmpPath, path2);
+  }
+  return tmpPath;
+}
+async function getReadStream(bucketName, path2) {
+  bucketName = sanitizeBucket(bucketName);
+  path2 = sanitizeKey(path2);
+  const client = ObjectStore(bucketName);
+  const params2 = {
+    Bucket: bucketName,
+    Key: path2
+  };
+  return client.getObject(params2).createReadStream();
+}
+var import_aws_sdk, import_stream, import_node_fetch3, import_tar_fs, import_zlib, import_util, import_path2, import_fs3, import_uuid2, sanitize, streamPipeline, STATE, CONTENT_TYPE_MAP, STRING_CONTENT_TYPES;
 var init_objectStore = __esm({
   "src/objectStore/objectStore.ts"() {
     "use strict";
@@ -4769,271 +5044,6 @@ var init_objectStore = __esm({
       CONTENT_TYPE_MAP.js,
       CONTENT_TYPE_MAP.json
     ];
-    ObjectStore = (bucket, opts = { presigning: false }) => {
-      const config = {
-        s3ForcePathStyle: true,
-        signatureVersion: "v4",
-        apiVersion: "2006-03-01",
-        accessKeyId: environment_default.MINIO_ACCESS_KEY,
-        secretAccessKey: environment_default.MINIO_SECRET_KEY,
-        region: environment_default.AWS_REGION
-      };
-      if (bucket) {
-        config.params = {
-          Bucket: sanitizeBucket(bucket)
-        };
-      }
-      if (environment_default.MINIO_URL) {
-        if (opts.presigning && environment_default.MINIO_ENABLED) {
-          config.endpoint = "minio-service";
-        } else {
-          config.endpoint = environment_default.MINIO_URL;
-        }
-      }
-      return new import_aws_sdk.default.S3(config);
-    };
-    makeSureBucketExists = async (client, bucketName) => {
-      bucketName = sanitizeBucket(bucketName);
-      try {
-        await client.headBucket({
-          Bucket: bucketName
-        }).promise();
-      } catch (err) {
-        const promises = STATE.bucketCreationPromises;
-        const doesntExist = err.statusCode === 404, noAccess = err.statusCode === 403;
-        if (promises[bucketName]) {
-          await promises[bucketName];
-        } else if (doesntExist || noAccess) {
-          if (doesntExist) {
-            promises[bucketName] = client.createBucket({
-              Bucket: bucketName
-            }).promise();
-            await promises[bucketName];
-            delete promises[bucketName];
-          }
-        } else {
-          throw new Error("Unable to write to object store bucket.");
-        }
-      }
-    };
-    upload = async ({
-      bucket: bucketName,
-      filename,
-      path: path2,
-      type,
-      metadata
-    }) => {
-      const extension = filename.split(".").pop();
-      const fileBytes = import_fs3.default.readFileSync(path2);
-      const objectStore = ObjectStore(bucketName);
-      await makeSureBucketExists(objectStore, bucketName);
-      let contentType = type;
-      if (!contentType) {
-        contentType = extension ? CONTENT_TYPE_MAP[extension.toLowerCase()] : CONTENT_TYPE_MAP.txt;
-      }
-      const config = {
-        // windows file paths need to be converted to forward slashes for s3
-        Key: sanitizeKey(filename),
-        Body: fileBytes,
-        ContentType: contentType
-      };
-      if (metadata && typeof metadata === "object") {
-        for (let key of Object.keys(metadata)) {
-          if (!metadata[key] || typeof metadata[key] !== "string") {
-            delete metadata[key];
-          }
-        }
-        config.Metadata = metadata;
-      }
-      return objectStore.upload(config).promise();
-    };
-    streamUpload = async (bucketName, filename, stream2, extra = {}) => {
-      const objectStore = ObjectStore(bucketName);
-      await makeSureBucketExists(objectStore, bucketName);
-      if (filename?.endsWith(".js")) {
-        extra = {
-          ...extra,
-          ContentType: "application/javascript"
-        };
-      } else if (filename?.endsWith(".svg")) {
-        extra = {
-          ...extra,
-          ContentType: "image"
-        };
-      }
-      const params2 = {
-        Bucket: sanitizeBucket(bucketName),
-        Key: sanitizeKey(filename),
-        Body: stream2,
-        ...extra
-      };
-      return objectStore.upload(params2).promise();
-    };
-    retrieve = async (bucketName, filepath) => {
-      const objectStore = ObjectStore(bucketName);
-      const params2 = {
-        Bucket: sanitizeBucket(bucketName),
-        Key: sanitizeKey(filepath)
-      };
-      const response = await objectStore.getObject(params2).promise();
-      if (STRING_CONTENT_TYPES.includes(response.ContentType)) {
-        return response.Body.toString("utf8");
-      } else {
-        return response.Body;
-      }
-    };
-    listAllObjects = async (bucketName, path2) => {
-      const objectStore = ObjectStore(bucketName);
-      const list = (params2 = {}) => {
-        return objectStore.listObjectsV2({
-          ...params2,
-          Bucket: sanitizeBucket(bucketName),
-          Prefix: sanitizeKey(path2)
-        }).promise();
-      };
-      let isTruncated = false, token, objects = [];
-      do {
-        let params2 = {};
-        if (token) {
-          params2.ContinuationToken = token;
-        }
-        const response = await list(params2);
-        if (response.Contents) {
-          objects = objects.concat(response.Contents);
-        }
-        isTruncated = !!response.IsTruncated;
-      } while (isTruncated);
-      return objects;
-    };
-    getPresignedUrl = (bucketName, key, durationSeconds = 3600) => {
-      const objectStore = ObjectStore(bucketName, { presigning: true });
-      const params2 = {
-        Bucket: sanitizeBucket(bucketName),
-        Key: sanitizeKey(key),
-        Expires: durationSeconds
-      };
-      const url = objectStore.getSignedUrl("getObject", params2);
-      if (!environment_default.MINIO_ENABLED) {
-        return url;
-      } else {
-        const signedUrl = new URL(url);
-        const path2 = signedUrl.pathname;
-        const query = signedUrl.search;
-        return `/files/signed${path2}${query}`;
-      }
-    };
-    retrieveToTmp = async (bucketName, filepath) => {
-      bucketName = sanitizeBucket(bucketName);
-      filepath = sanitizeKey(filepath);
-      const data = await retrieve(bucketName, filepath);
-      const outputPath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid2.v4)());
-      import_fs3.default.writeFileSync(outputPath, data);
-      return outputPath;
-    };
-    retrieveDirectory = async (bucketName, path2) => {
-      let writePath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid2.v4)());
-      import_fs3.default.mkdirSync(writePath);
-      const objects = await listAllObjects(bucketName, path2);
-      let fullObjects = await Promise.all(
-        objects.map((obj) => retrieve(bucketName, obj.Key))
-      );
-      let count = 0;
-      for (let obj of objects) {
-        const filename = obj.Key;
-        const data = fullObjects[count++];
-        const possiblePath = filename.split("/");
-        if (possiblePath.length > 1) {
-          const dirs = possiblePath.slice(0, possiblePath.length - 1);
-          import_fs3.default.mkdirSync((0, import_path2.join)(writePath, ...dirs), { recursive: true });
-        }
-        import_fs3.default.writeFileSync((0, import_path2.join)(writePath, ...possiblePath), data);
-      }
-      return writePath;
-    };
-    deleteFile = async (bucketName, filepath) => {
-      const objectStore = ObjectStore(bucketName);
-      await makeSureBucketExists(objectStore, bucketName);
-      const params2 = {
-        Bucket: bucketName,
-        Key: sanitizeKey(filepath)
-      };
-      return objectStore.deleteObject(params2).promise();
-    };
-    deleteFiles = async (bucketName, filepaths) => {
-      const objectStore = ObjectStore(bucketName);
-      await makeSureBucketExists(objectStore, bucketName);
-      const params2 = {
-        Bucket: bucketName,
-        Delete: {
-          Objects: filepaths.map((path2) => ({ Key: sanitizeKey(path2) }))
-        }
-      };
-      return objectStore.deleteObjects(params2).promise();
-    };
-    deleteFolder = async (bucketName, folder) => {
-      bucketName = sanitizeBucket(bucketName);
-      folder = sanitizeKey(folder);
-      const client = ObjectStore(bucketName);
-      const listParams = {
-        Bucket: bucketName,
-        Prefix: folder
-      };
-      const existingObjectsResponse = await client.listObjects(listParams).promise();
-      if (existingObjectsResponse.Contents?.length === 0) {
-        return;
-      }
-      const deleteParams = {
-        Bucket: bucketName,
-        Delete: {
-          Objects: []
-        }
-      };
-      existingObjectsResponse.Contents?.forEach((content) => {
-        deleteParams.Delete.Objects.push({ Key: content.Key });
-      });
-      const deleteResponse = await client.deleteObjects(deleteParams).promise();
-      if (deleteResponse.Deleted?.length === 1e3) {
-        return deleteFolder(bucketName, folder);
-      }
-    };
-    uploadDirectory = async (bucketName, localPath, bucketPath) => {
-      bucketName = sanitizeBucket(bucketName);
-      let uploads = [];
-      const files = import_fs3.default.readdirSync(localPath, { withFileTypes: true });
-      for (let file of files) {
-        const path2 = sanitizeKey((0, import_path2.join)(bucketPath, file.name));
-        const local = (0, import_path2.join)(localPath, file.name);
-        if (file.isDirectory()) {
-          uploads.push(uploadDirectory(bucketName, local, path2));
-        } else {
-          uploads.push(streamUpload(bucketName, path2, import_fs3.default.createReadStream(local)));
-        }
-      }
-      await Promise.all(uploads);
-      return files;
-    };
-    downloadTarballDirect = async (url, path2, headers = {}) => {
-      path2 = sanitizeKey(path2);
-      const response = await (0, import_node_fetch3.default)(url, { headers });
-      if (!response.ok) {
-        throw new Error(`unexpected response ${response.statusText}`);
-      }
-      await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(path2));
-    };
-    downloadTarball = async (url, bucketName, path2) => {
-      bucketName = sanitizeBucket(bucketName);
-      path2 = sanitizeKey(path2);
-      const response = await (0, import_node_fetch3.default)(url);
-      if (!response.ok) {
-        throw new Error(`unexpected response ${response.statusText}`);
-      }
-      const tmpPath = (0, import_path2.join)(budibaseTempDir(), path2);
-      await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
-      if (!environment_default.isTest() && environment_default.SELF_HOSTED) {
-        await uploadDirectory(bucketName, tmpPath, path2);
-      }
-      return tmpPath;
-    };
   }
 });
 
@@ -5079,35 +5089,51 @@ var init_cloudfront = __esm({
 });
 
 // src/objectStore/buckets/app.ts
-var clientLibraryUrl, getAppFileUrl;
+function clientLibraryPath(appId) {
+  return `${sanitizeKey(appId)}/budibase-client.js`;
+}
+function clientLibraryCDNUrl(appId, version) {
+  let file = clientLibraryPath(appId);
+  if (environment_default.CLOUDFRONT_CDN) {
+    if (version) {
+      file += `?v=${version}`;
+    }
+    return getUrl(file);
+  } else {
+    return getPresignedUrl(environment_default.APPS_BUCKET_NAME, file);
+  }
+}
+function clientLibraryUrl(appId, version) {
+  let tenantId, qsParams;
+  try {
+    tenantId = getTenantId();
+  } finally {
+    qsParams = {
+      appId,
+      version
+    };
+  }
+  if (tenantId && tenantId !== DEFAULT_TENANT_ID) {
+    qsParams.tenantId = tenantId;
+  }
+  return `/api/assets/client?${import_querystring.default.encode(qsParams)}`;
+}
+function getAppFileUrl(s3Key) {
+  if (environment_default.CLOUDFRONT_CDN) {
+    return getPresignedUrl2(s3Key);
+  } else {
+    return getPresignedUrl(environment_default.APPS_BUCKET_NAME, s3Key);
+  }
+}
+var import_querystring;
 var init_app5 = __esm({
   "src/objectStore/buckets/app.ts"() {
     "use strict";
     init_environment2();
     init_objectStore();
     init_cloudfront();
-    clientLibraryUrl = (appId, version) => {
-      if (environment_default.isProd()) {
-        let file = `${sanitizeKey(appId)}/budibase-client.js`;
-        if (environment_default.CLOUDFRONT_CDN) {
-          if (version) {
-            file += `?v=${version}`;
-          }
-          return getUrl(file);
-        } else {
-          return getPresignedUrl(environment_default.APPS_BUCKET_NAME, file);
-        }
-      } else {
-        return `/api/assets/client`;
-      }
-    };
-    getAppFileUrl = (s3Key) => {
-      if (environment_default.CLOUDFRONT_CDN) {
-        return getPresignedUrl2(s3Key);
-      } else {
-        return getPresignedUrl(environment_default.APPS_BUCKET_NAME, s3Key);
-      }
-    };
+    import_querystring = __toESM(require("querystring"));
+    init_context2();
   }
 });
 
@@ -5143,7 +5169,59 @@ var init_global3 = __esm({
 });
 
 // src/objectStore/buckets/plugins.ts
-var enrichPluginURLs, getPluginJSUrl, getPluginIconUrl, getPluginUrl, getPluginJSKey, getPluginIconKey, getPluginS3Key, getPluginS3Dir;
+function enrichPluginURLs(plugins) {
+  if (!plugins || !plugins.length) {
+    return [];
+  }
+  return plugins.map((plugin) => {
+    const jsUrl = getPluginJSUrl(plugin);
+    const iconUrl = getPluginIconUrl(plugin);
+    return { ...plugin, jsUrl, iconUrl };
+  });
+}
+function getPluginJSUrl(plugin) {
+  const s3Key = getPluginJSKey(plugin);
+  return getPluginUrl(s3Key);
+}
+function getPluginIconUrl(plugin) {
+  const s3Key = getPluginIconKey(plugin);
+  if (!s3Key) {
+    return;
+  }
+  return getPluginUrl(s3Key);
+}
+function getPluginUrl(s3Key) {
+  if (environment_default.CLOUDFRONT_CDN) {
+    return getPresignedUrl2(s3Key);
+  } else {
+    return getPresignedUrl(environment_default.PLUGIN_BUCKET_NAME, s3Key);
+  }
+}
+function getPluginJSKey(plugin) {
+  return getPluginS3Key(plugin, "plugin.min.js");
+}
+function getPluginIconKey(plugin) {
+  const iconFileName = plugin.iconUrl ? "icon.svg" : plugin.iconFileName;
+  if (!iconFileName) {
+    return;
+  }
+  return getPluginS3Key(plugin, iconFileName);
+}
+function getPluginS3Key(plugin, fileName) {
+  const s3Key = getPluginS3Dir(plugin.name);
+  return `${s3Key}/${fileName}`;
+}
+function getPluginS3Dir(pluginName) {
+  let s3Key = `${pluginName}`;
+  if (environment_default.MULTI_TENANCY) {
+    const tenantId = getTenantId();
+    s3Key = `${tenantId}/${s3Key}`;
+  }
+  if (environment_default.CLOUDFRONT_CDN) {
+    s3Key = `plugins/${s3Key}`;
+  }
+  return s3Key;
+}
 var init_plugins = __esm({
   "src/objectStore/buckets/plugins.ts"() {
     "use strict";
@@ -5151,59 +5229,6 @@ var init_plugins = __esm({
     init_objectStore();
     init_context2();
     init_cloudfront();
-    enrichPluginURLs = (plugins) => {
-      if (!plugins || !plugins.length) {
-        return [];
-      }
-      return plugins.map((plugin) => {
-        const jsUrl = getPluginJSUrl(plugin);
-        const iconUrl = getPluginIconUrl(plugin);
-        return { ...plugin, jsUrl, iconUrl };
-      });
-    };
-    getPluginJSUrl = (plugin) => {
-      const s3Key = getPluginJSKey(plugin);
-      return getPluginUrl(s3Key);
-    };
-    getPluginIconUrl = (plugin) => {
-      const s3Key = getPluginIconKey(plugin);
-      if (!s3Key) {
-        return;
-      }
-      return getPluginUrl(s3Key);
-    };
-    getPluginUrl = (s3Key) => {
-      if (environment_default.CLOUDFRONT_CDN) {
-        return getPresignedUrl2(s3Key);
-      } else {
-        return getPresignedUrl(environment_default.PLUGIN_BUCKET_NAME, s3Key);
-      }
-    };
-    getPluginJSKey = (plugin) => {
-      return getPluginS3Key(plugin, "plugin.min.js");
-    };
-    getPluginIconKey = (plugin) => {
-      const iconFileName = plugin.iconUrl ? "icon.svg" : plugin.iconFileName;
-      if (!iconFileName) {
-        return;
-      }
-      return getPluginS3Key(plugin, iconFileName);
-    };
-    getPluginS3Key = (plugin, fileName) => {
-      const s3Key = getPluginS3Dir(plugin.name);
-      return `${s3Key}/${fileName}`;
-    };
-    getPluginS3Dir = (pluginName) => {
-      let s3Key = `${pluginName}`;
-      if (environment_default.MULTI_TENANCY) {
-        const tenantId = getTenantId();
-        s3Key = `${tenantId}/${s3Key}`;
-      }
-      if (environment_default.CLOUDFRONT_CDN) {
-        s3Key = `plugins/${s3Key}`;
-      }
-      return s3Key;
-    };
   }
 });
 
@@ -5223,6 +5248,8 @@ __export(objectStore_exports2, {
   ObjectStore: () => ObjectStore,
   ObjectStoreBuckets: () => ObjectStoreBuckets,
   budibaseTempDir: () => budibaseTempDir,
+  clientLibraryCDNUrl: () => clientLibraryCDNUrl,
+  clientLibraryPath: () => clientLibraryPath,
   clientLibraryUrl: () => clientLibraryUrl,
   deleteFile: () => deleteFile,
   deleteFiles: () => deleteFiles,
@@ -5237,6 +5264,7 @@ __export(objectStore_exports2, {
   getPluginJSKey: () => getPluginJSKey,
   getPluginS3Dir: () => getPluginS3Dir,
   getPresignedUrl: () => getPresignedUrl,
+  getReadStream: () => getReadStream,
   listAllObjects: () => listAllObjects,
   makeSureBucketExists: () => makeSureBucketExists,
   retrieve: () => retrieve,
@@ -6254,6 +6282,7 @@ __export(users_exports3, {
   getAccountHolderFromUserIds: () => getAccountHolderFromUserIds,
   getAllUserIds: () => getAllUserIds,
   getById: () => getById,
+  getCreatorCount: () => getCreatorCount,
   getExistingAccounts: () => getExistingAccounts,
   getExistingPlatformUsers: () => getExistingPlatformUsers,
   getExistingTenantUsers: () => getExistingTenantUsers,
@@ -6267,6 +6296,7 @@ __export(users_exports3, {
   isAdmin: () => isAdmin2,
   isAdminOrBuilder: () => isAdminOrBuilder2,
   isBuilder: () => isBuilder2,
+  isCreator: () => isCreator2,
   isGlobalBuilder: () => isGlobalBuilder2,
   isSupportedUserSearch: () => isSupportedUserSearch,
   paginatedUsers: () => paginatedUsers,
@@ -6283,240 +6313,22 @@ init_db4();
 init_src();
 init_context2();
 init_context2();
-function removeUserPassword(users) {
-  if (Array.isArray(users)) {
-    return users.map((user) => {
-      if (user) {
-        delete user.password;
-        return user;
-      }
-    });
-  } else if (users) {
-    delete users.password;
-    return users;
-  }
-  return users;
-}
-var isSupportedUserSearch = (query) => {
-  const allowed = [
-    { op: "string" /* STRING */, key: "email" },
-    { op: "equal" /* EQUAL */, key: "_id" }
-  ];
-  for (let [key, operation] of Object.entries(query)) {
-    if (typeof operation !== "object") {
-      return false;
-    }
-    const fields = Object.keys(operation || {});
-    if (fields.length === 0) {
-      continue;
-    }
-    const allowedOperation = allowed.find(
-      (allow) => allow.op === key && fields.length === 1 && fields[0] === allow.key
-    );
-    if (!allowedOperation) {
-      return false;
-    }
-  }
-  return true;
-};
-var bulkGetGlobalUsersById = async (userIds, opts) => {
-  const db = getGlobalDB();
-  let users = (await db.allDocs({
-    keys: userIds,
-    include_docs: true
-  })).rows.map((row) => row.doc);
-  if (opts?.cleanup) {
-    users = removeUserPassword(users);
-  }
-  return users;
-};
-var getAllUserIds = async () => {
-  const db = getGlobalDB();
-  const startKey = `${"us" /* USER */}${SEPARATOR}`;
-  const response = await db.allDocs({
-    startkey: startKey,
-    endkey: `${startKey}${UNICODE_MAX}`
-  });
-  return response.rows.map((row) => row.id);
-};
-var bulkUpdateGlobalUsers = async (users) => {
-  const db = getGlobalDB();
-  return await db.bulkDocs(users);
-};
-async function getById(id, opts) {
-  const db = getGlobalDB();
-  let user = await db.get(id);
-  if (opts?.cleanup) {
-    user = removeUserPassword(user);
-  }
-  return user;
-}
-var getGlobalUserByEmail = async (email, opts) => {
-  if (email == null) {
-    throw "Must supply an email address to view";
-  }
-  const response = await queryGlobalView("by_email2" /* USER_BY_EMAIL */, {
-    key: email.toLowerCase(),
-    include_docs: true
-  });
-  if (Array.isArray(response)) {
-    throw new Error(`Multiple users found with email address: ${email}`);
-  }
-  let user = response;
-  if (opts?.cleanup) {
-    user = removeUserPassword(user);
-  }
-  return user;
-};
-var searchGlobalUsersByApp = async (appId, opts, getOpts) => {
-  if (typeof appId !== "string") {
-    throw new Error("Must provide a string based app ID");
-  }
-  const params2 = getUsersByAppParams(appId, {
-    include_docs: true
-  });
-  params2.startkey = opts && opts.startkey ? opts.startkey : params2.startkey;
-  let response = await queryGlobalView("by_app" /* USER_BY_APP */, params2);
-  if (!response) {
-    response = [];
-  }
-  let users = Array.isArray(response) ? response : [response];
-  if (getOpts?.cleanup) {
-    users = removeUserPassword(users);
-  }
-  return users;
-};
-var searchGlobalUsersByAppAccess = async (appId, opts) => {
-  const roleSelector = `roles.${appId}`;
-  let orQuery = [
-    {
-      "builder.global": true
-    },
-    {
-      "admin.global": true
-    }
-  ];
-  if (appId) {
-    const roleCheck = {
-      [roleSelector]: {
-        $exists: true
-      }
-    };
-    orQuery.push(roleCheck);
-  }
-  let searchOptions = {
-    selector: {
-      $or: orQuery,
-      _id: {
-        $regex: "^us_"
-      }
-    },
-    limit: opts?.limit || 50
-  };
-  const resp = await directCouchFind(getGlobalDBName(), searchOptions);
-  return resp?.rows;
-};
-var getGlobalUserByAppPage = (appId, user) => {
-  if (!user) {
-    return;
-  }
-  return generateAppUserID(getProdAppID(appId), user._id);
-};
-var searchGlobalUsersByEmail = async (email, opts, getOpts) => {
-  if (typeof email !== "string") {
-    throw new Error("Must provide a string to search by");
-  }
-  const lcEmail = email.toLowerCase();
-  const startkey = opts && opts.startkey ? opts.startkey : lcEmail;
-  let response = await queryGlobalView("by_email2" /* USER_BY_EMAIL */, {
-    ...opts,
-    startkey,
-    endkey: `${lcEmail}${UNICODE_MAX}`
-  });
-  if (!response) {
-    response = [];
-  }
-  let users = Array.isArray(response) ? response : [response];
-  if (getOpts?.cleanup) {
-    users = removeUserPassword(users);
-  }
-  return users;
-};
-var PAGE_LIMIT = 8;
-var paginatedUsers = async ({
-  bookmark,
-  query,
-  appId,
-  limit
-} = {}) => {
-  const db = getGlobalDB();
-  const pageLimit = limit ? limit + 1 : PAGE_LIMIT + 1;
-  const opts = {
-    include_docs: true,
-    limit: pageLimit
-  };
-  if (bookmark) {
-    opts.startkey = bookmark;
-  }
-  let userList, property = "_id", getKey;
-  if (query?.equal?._id) {
-    userList = [await getById(query.equal._id)];
-  } else if (appId) {
-    userList = await searchGlobalUsersByApp(appId, opts);
-    getKey = (doc) => getGlobalUserByAppPage(appId, doc);
-  } else if (query?.string?.email) {
-    userList = await searchGlobalUsersByEmail(query?.string?.email, opts);
-    property = "email";
-  } else {
-    const response = await db.allDocs(getGlobalUserParams(null, opts));
-    userList = response.rows.map((row) => row.doc);
-  }
-  return pagination(userList, pageLimit, {
-    paginate: true,
-    property,
-    getKey
-  });
-};
-async function getUserCount() {
-  const response = await queryGlobalViewRaw("by_email2" /* USER_BY_EMAIL */, {
-    limit: 0,
-    // to be as fast as possible - we just want the total rows count
-    include_docs: false
-  });
-  return response.total_rows;
-}
-function removePortalUserPermissions(user) {
-  delete user.admin;
-  delete user.builder;
-  return user;
-}
-function cleanseUserObject(user, base) {
-  delete user.admin;
-  delete user.builder;
-  delete user.roles;
-  if (base) {
-    user.admin = base.admin;
-    user.builder = base.builder;
-    user.roles = base.roles;
-  }
-  return user;
-}
-
-// src/users/utils.ts
-init_environment2();
-
-// src/users/lookup.ts
-init_db4();
-init_constants3();
-async function searchExistingEmails(emails) {
-  let matchedEmails = [];
-  const existingTenantUsers = await getExistingTenantUsers(emails);
-  matchedEmails.push(...existingTenantUsers.map((user) => user.email));
-  const existingPlatformUsers = await getExistingPlatformUsers(emails);
-  matchedEmails.push(...existingPlatformUsers.map((user) => user._id));
-  const existingAccounts = await getExistingAccounts(emails);
-  matchedEmails.push(...existingAccounts.map((account) => account.email));
-  return [...new Set(matchedEmails.map((email) => email.toLowerCase()))];
+
+// src/users/utils.ts
+init_environment2();
+
+// src/users/lookup.ts
+init_db4();
+init_constants3();
+async function searchExistingEmails(emails) {
+  let matchedEmails = [];
+  const existingTenantUsers = await getExistingTenantUsers(emails);
+  matchedEmails.push(...existingTenantUsers.map((user) => user.email));
+  const existingPlatformUsers = await getExistingPlatformUsers(emails);
+  matchedEmails.push(...existingPlatformUsers.map((user) => user._id));
+  const existingAccounts = await getExistingAccounts(emails);
+  matchedEmails.push(...existingAccounts.map((account) => account.email));
+  return [...new Set(matchedEmails.map((email) => email.toLowerCase()))];
 }
 async function getPlatformUser(identifier) {
   return await queryPlatformView("platform_users_lowercase_2" /* PLATFORM_USERS_LOWERCASE */, {
@@ -6787,14 +6599,17 @@ __export(users_exports2, {
   getGlobalUserID: () => getGlobalUserID,
   hasAdminPermissions: () => hasAdminPermissions,
   hasAppBuilderPermissions: () => hasAppBuilderPermissions,
+  hasAppCreatorPermissions: () => hasAppCreatorPermissions,
   hasBuilderPermissions: () => hasBuilderPermissions,
   isAdmin: () => isAdmin,
   isAdminOrBuilder: () => isAdminOrBuilder,
   isAdminOrGlobalBuilder: () => isAdminOrGlobalBuilder,
   isBuilder: () => isBuilder,
+  isCreator: () => isCreator,
   isGlobalBuilder: () => isGlobalBuilder
 });
 init_src();
+var _ = __toESM(require("lodash/fp"));
 function isBuilder(user, appId) {
   if (!user) {
     return false;
@@ -6829,6 +6644,17 @@ function hasAppBuilderPermissions(user) {
   const isGlobalBuilder3 = !!user.builder?.global;
   return !isGlobalBuilder3 && appLength != null && appLength > 0;
 }
+function hasAppCreatorPermissions(user) {
+  if (!user) {
+    return false;
+  }
+  return _.flow(
+    _.get("roles"),
+    _.values,
+    _.find((x) => ["CREATOR", "ADMIN"].includes(x)),
+    (x) => !!x
+  )(user);
+}
 function hasBuilderPermissions(user) {
   if (!user) {
     return false;
@@ -6841,6 +6667,12 @@ function hasAdminPermissions(user) {
   }
   return !!user.admin?.global;
 }
+function isCreator(user) {
+  if (!user) {
+    return false;
+  }
+  return isGlobalBuilder(user) || hasAdminPermissions(user) || hasAppBuilderPermissions(user) || hasAppCreatorPermissions(user);
+}
 function getGlobalUserID(userId) {
   if (typeof userId !== "string") {
     return userId;
@@ -6900,6 +6732,7 @@ var allowSortColumnByType = {
 // src/users/utils.ts
 var isBuilder2 = sdk_exports.users.isBuilder;
 var isAdmin2 = sdk_exports.users.isAdmin;
+var isCreator2 = sdk_exports.users.isCreator;
 var isGlobalBuilder2 = sdk_exports.users.isGlobalBuilder;
 var isAdminOrBuilder2 = sdk_exports.users.isAdminOrBuilder;
 var hasAdminPermissions2 = sdk_exports.users.hasAdminPermissions;
@@ -6933,6 +6766,238 @@ async function getAccountHolderFromUserIds(userIds) {
   }
 }
 
+// src/users/users.ts
+function removeUserPassword(users) {
+  if (Array.isArray(users)) {
+    return users.map((user) => {
+      if (user) {
+        delete user.password;
+        return user;
+      }
+    });
+  } else if (users) {
+    delete users.password;
+    return users;
+  }
+  return users;
+}
+var isSupportedUserSearch = (query) => {
+  const allowed = [
+    { op: "string" /* STRING */, key: "email" },
+    { op: "equal" /* EQUAL */, key: "_id" }
+  ];
+  for (let [key, operation] of Object.entries(query)) {
+    if (typeof operation !== "object") {
+      return false;
+    }
+    const fields = Object.keys(operation || {});
+    if (fields.length === 0) {
+      continue;
+    }
+    const allowedOperation = allowed.find(
+      (allow) => allow.op === key && fields.length === 1 && fields[0] === allow.key
+    );
+    if (!allowedOperation) {
+      return false;
+    }
+  }
+  return true;
+};
+var bulkGetGlobalUsersById = async (userIds, opts) => {
+  const db = getGlobalDB();
+  let users = (await db.allDocs({
+    keys: userIds,
+    include_docs: true
+  })).rows.map((row) => row.doc);
+  if (opts?.cleanup) {
+    users = removeUserPassword(users);
+  }
+  return users;
+};
+var getAllUserIds = async () => {
+  const db = getGlobalDB();
+  const startKey = `${"us" /* USER */}${SEPARATOR}`;
+  const response = await db.allDocs({
+    startkey: startKey,
+    endkey: `${startKey}${UNICODE_MAX}`
+  });
+  return response.rows.map((row) => row.id);
+};
+var bulkUpdateGlobalUsers = async (users) => {
+  const db = getGlobalDB();
+  return await db.bulkDocs(users);
+};
+async function getById(id, opts) {
+  const db = getGlobalDB();
+  let user = await db.get(id);
+  if (opts?.cleanup) {
+    user = removeUserPassword(user);
+  }
+  return user;
+}
+var getGlobalUserByEmail = async (email, opts) => {
+  if (email == null) {
+    throw "Must supply an email address to view";
+  }
+  const response = await queryGlobalView("by_email2" /* USER_BY_EMAIL */, {
+    key: email.toLowerCase(),
+    include_docs: true
+  });
+  if (Array.isArray(response)) {
+    throw new Error(`Multiple users found with email address: ${email}`);
+  }
+  let user = response;
+  if (opts?.cleanup) {
+    user = removeUserPassword(user);
+  }
+  return user;
+};
+var searchGlobalUsersByApp = async (appId, opts, getOpts) => {
+  if (typeof appId !== "string") {
+    throw new Error("Must provide a string based app ID");
+  }
+  const params2 = getUsersByAppParams(appId, {
+    include_docs: true
+  });
+  params2.startkey = opts && opts.startkey ? opts.startkey : params2.startkey;
+  let response = await queryGlobalView("by_app" /* USER_BY_APP */, params2);
+  if (!response) {
+    response = [];
+  }
+  let users = Array.isArray(response) ? response : [response];
+  if (getOpts?.cleanup) {
+    users = removeUserPassword(users);
+  }
+  return users;
+};
+var searchGlobalUsersByAppAccess = async (appId, opts) => {
+  const roleSelector = `roles.${appId}`;
+  let orQuery = [
+    {
+      "builder.global": true
+    },
+    {
+      "admin.global": true
+    }
+  ];
+  if (appId) {
+    const roleCheck = {
+      [roleSelector]: {
+        $exists: true
+      }
+    };
+    orQuery.push(roleCheck);
+  }
+  let searchOptions = {
+    selector: {
+      $or: orQuery,
+      _id: {
+        $regex: "^us_"
+      }
+    },
+    limit: opts?.limit || 50
+  };
+  const resp = await directCouchFind(getGlobalDBName(), searchOptions);
+  return resp?.rows;
+};
+var getGlobalUserByAppPage = (appId, user) => {
+  if (!user) {
+    return;
+  }
+  return generateAppUserID(getProdAppID(appId), user._id);
+};
+var searchGlobalUsersByEmail = async (email, opts, getOpts) => {
+  if (typeof email !== "string") {
+    throw new Error("Must provide a string to search by");
+  }
+  const lcEmail = email.toLowerCase();
+  const startkey = opts && opts.startkey ? opts.startkey : lcEmail;
+  let response = await queryGlobalView("by_email2" /* USER_BY_EMAIL */, {
+    ...opts,
+    startkey,
+    endkey: `${lcEmail}${UNICODE_MAX}`
+  });
+  if (!response) {
+    response = [];
+  }
+  let users = Array.isArray(response) ? response : [response];
+  if (getOpts?.cleanup) {
+    users = removeUserPassword(users);
+  }
+  return users;
+};
+var PAGE_LIMIT = 8;
+var paginatedUsers = async ({
+  bookmark,
+  query,
+  appId,
+  limit
+} = {}) => {
+  const db = getGlobalDB();
+  const pageLimit = limit ? limit + 1 : PAGE_LIMIT + 1;
+  const opts = {
+    include_docs: true,
+    limit: pageLimit
+  };
+  if (bookmark) {
+    opts.startkey = bookmark;
+  }
+  let userList, property = "_id", getKey;
+  if (query?.equal?._id) {
+    userList = [await getById(query.equal._id)];
+  } else if (appId) {
+    userList = await searchGlobalUsersByApp(appId, opts);
+    getKey = (doc) => getGlobalUserByAppPage(appId, doc);
+  } else if (query?.string?.email) {
+    userList = await searchGlobalUsersByEmail(query?.string?.email, opts);
+    property = "email";
+  } else {
+    const response = await db.allDocs(getGlobalUserParams(null, opts));
+    userList = response.rows.map((row) => row.doc);
+  }
+  return pagination(userList, pageLimit, {
+    paginate: true,
+    property,
+    getKey
+  });
+};
+async function getUserCount() {
+  const response = await queryGlobalViewRaw("by_email2" /* USER_BY_EMAIL */, {
+    limit: 0,
+    // to be as fast as possible - we just want the total rows count
+    include_docs: false
+  });
+  return response.total_rows;
+}
+async function getCreatorCount() {
+  let creators = 0;
+  async function iterate(startPage) {
+    const page = await paginatedUsers({ bookmark: startPage });
+    creators += page.data.filter(isCreator2).length;
+    if (page.hasNextPage) {
+      await iterate(page.nextPage);
+    }
+  }
+  await iterate();
+  return creators;
+}
+function removePortalUserPermissions(user) {
+  delete user.admin;
+  delete user.builder;
+  return user;
+}
+function cleanseUserObject(user, base) {
+  delete user.admin;
+  delete user.builder;
+  delete user.roles;
+  if (base) {
+    user.admin = base.admin;
+    user.builder = base.builder;
+    user.roles = base.roles;
+  }
+  return user;
+}
+
 // src/users/db.ts
 init_environment2();
 
@@ -10267,7 +10332,7 @@ async function put(db, doc, writeRateMs = DEFAULT_WRITE_RATE_MS) {
   }
   return { ok: true, id: output._id, rev: output._rev };
 }
-async function get2(db, id) {
+async function get3(db, id) {
   const cache = await getCache();
   const cacheKey = makeCacheKey(db, id);
   let cacheItem = await cache.get(cacheKey);
@@ -10300,7 +10365,7 @@ var Writethrough = class {
     return put(this.db, doc, this.writeRateMs);
   }
   async get(id) {
-    return get2(this.db, id);
+    return get3(this.db, id);
   }
   async remove(docOrId, rev) {
     return remove(this.db, docOrId, rev);
@@ -10619,7 +10684,7 @@ var DEFINITIONS = [
   },
   {
     type: "global" /* GLOBAL */,
-    name: "sync_quotas_1" /* SYNC_QUOTAS */
+    name: "sync_quotas_2" /* SYNC_QUOTAS */
   },
   {
     type: "app" /* APP */,