@budibase/backend-core 3.2.35 → 3.2.38

package/dist/index.js

@@ -11598,10 +11598,6 @@ var TenantResolutionStrategy = /* @__PURE__ */ ((TenantResolutionStrategy2) => {
 
 // ../types/src/sdk/featureFlag.ts
 var FeatureFlagDefaults = {
-  ["DEFAULT_VALUES" /* DEFAULT_VALUES */]: true,
-  ["AUTOMATION_BRANCHING" /* AUTOMATION_BRANCHING */]: true,
-  ["AI_CUSTOM_CONFIGS" /* AI_CUSTOM_CONFIGS */]: true,
-  ["BUDIBASE_AI" /* BUDIBASE_AI */]: true,
   ["USE_ZOD_VALIDATOR" /* USE_ZOD_VALIDATOR */]: false
 };
 
@@ -17086,7 +17082,7 @@ function sort(docs, sort2, sortOrder, sortType = "string" /* STRING */) {
   });
 }
 function limit(docs, limit2) {
-  const numLimit = parseFloat(limit2);
+  const numLimit = typeof limit2 === "number" ? limit2 : parseFloat(limit2);
   if (isNaN(numLimit)) {
     return docs;
   }
@@ -17698,7 +17694,7 @@ var environment = {
   MINIO_ACCESS_KEY: process.env.MINIO_ACCESS_KEY,
   MINIO_SECRET_KEY: process.env.MINIO_SECRET_KEY,
   AWS_SESSION_TOKEN: process.env.AWS_SESSION_TOKEN,
-  AWS_REGION: process.env.AWS_REGION || "eu-west-1",
+  AWS_REGION: process.env.AWS_REGION,
   MINIO_URL: process.env.MINIO_URL,
   MINIO_ENABLED: process.env.MINIO_ENABLED || 1,
   INTERNAL_API_KEY: process.env.INTERNAL_API_KEY,
@@ -18619,9 +18615,7 @@ __export(objectStore_exports2, {
 });
 
 // src/objectStore/objectStore.ts
-var import_client_s3 = require("@aws-sdk/client-s3");
-var import_lib_storage = require("@aws-sdk/lib-storage");
-var import_s3_request_presigner = require("@aws-sdk/s3-request-presigner");
+var import_aws_sdk = __toESM(require("aws-sdk"));
 var import_stream2 = __toESM(require("stream"));
 var import_node_fetch2 = __toESM(require("node-fetch"));
 var import_tar_fs = __toESM(require("tar-fs"));
@@ -18740,42 +18734,42 @@ function sanitizeKey(input) {
 function sanitizeBucket(input) {
   return input.replace(new RegExp(APP_DEV_PREFIX2, "g"), APP_PREFIX2);
 }
-function ObjectStore(opts = { presigning: false }) {
+function ObjectStore(bucket, opts = { presigning: false }) {
   const config = {
-    forcePathStyle: true,
-    credentials: {
-      accessKeyId: environment_default.MINIO_ACCESS_KEY,
-      secretAccessKey: environment_default.MINIO_SECRET_KEY
-    },
+    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 (!environment_default.MINIO_ENABLED && environment_default.AWS_SESSION_TOKEN) {
-    config.credentials = {
-      accessKeyId: environment_default.MINIO_ACCESS_KEY,
-      secretAccessKey: environment_default.MINIO_SECRET_KEY,
-      sessionToken: environment_default.AWS_SESSION_TOKEN
+  if (bucket) {
+    config.params = {
+      Bucket: sanitizeBucket(bucket)
     };
   }
+  if (!environment_default.MINIO_ENABLED && environment_default.AWS_SESSION_TOKEN) {
+    config.sessionToken = environment_default.AWS_SESSION_TOKEN;
+  }
   if (environment_default.MINIO_URL) {
     if (opts.presigning && environment_default.MINIO_ENABLED) {
-      config.endpoint = "http://minio-service";
+      config.endpoint = "minio-service";
     } else {
       config.endpoint = environment_default.MINIO_URL;
     }
   }
-  return new import_client_s3.S3(config);
+  return new import_aws_sdk.default.S3(config);
 }
 async function createBucketIfNotExists(client, bucketName) {
   bucketName = sanitizeBucket(bucketName);
   try {
     await client.headBucket({
       Bucket: bucketName
-    });
+    }).promise();
     return { created: false, exists: true };
   } catch (err) {
-    const statusCode = err.statusCode || err.$response?.statusCode;
     const promises = STATE.bucketCreationPromises;
-    const doesntExist = statusCode === 404, noAccess = statusCode === 403;
+    const doesntExist = err.statusCode === 404, noAccess = err.statusCode === 403;
     if (promises[bucketName]) {
       await promises[bucketName];
       return { created: false, exists: true };
@@ -18783,7 +18777,7 @@ async function createBucketIfNotExists(client, bucketName) {
       if (doesntExist) {
         promises[bucketName] = client.createBucket({
           Bucket: bucketName
-        });
+        }).promise();
         await promises[bucketName];
         delete promises[bucketName];
         return { created: true, exists: false };
@@ -18806,20 +18800,21 @@ async function upload({
 }) {
   const extension = filename.split(".").pop();
   const fileBytes = path3 ? (await import_promises.default.open(path3)).createReadStream() : body2;
-  const objectStore = ObjectStore();
+  const objectStore = ObjectStore(bucketName);
   const bucketCreated = await createBucketIfNotExists(objectStore, bucketName);
   if (ttl && bucketCreated.created) {
     let ttlConfig = bucketTTLConfig(bucketName, ttl);
-    await objectStore.putBucketLifecycleConfiguration(ttlConfig);
+    await objectStore.putBucketLifecycleConfiguration(ttlConfig).promise();
   }
   let contentType = type;
-  const finalContentType = contentType ? contentType : extension ? CONTENT_TYPE_MAP[extension.toLowerCase()] : CONTENT_TYPE_MAP.txt;
+  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
-    Bucket: sanitizeBucket(bucketName),
     Key: sanitizeKey(filename),
     Body: fileBytes,
-    ContentType: finalContentType
+    ContentType: contentType
   };
   if (metadata && typeof metadata === "object") {
     for (let key of Object.keys(metadata)) {
@@ -18829,11 +18824,7 @@ async function upload({
     }
     config.Metadata = metadata;
   }
-  const upload2 = new import_lib_storage.Upload({
-    client: objectStore,
-    params: config
-  });
-  return upload2.done();
+  return objectStore.upload(config).promise();
 }
 async function streamUpload({
   bucket: bucketName,
@@ -18847,11 +18838,11 @@ async function streamUpload({
     throw new Error("Stream to upload is invalid/undefined");
   }
   const extension = filename.split(".").pop();
-  const objectStore = ObjectStore();
+  const objectStore = ObjectStore(bucketName);
   const bucketCreated = await createBucketIfNotExists(objectStore, bucketName);
   if (ttl && bucketCreated.created) {
     let ttlConfig = bucketTTLConfig(bucketName, ttl);
-    await objectStore.putBucketLifecycleConfiguration(ttlConfig);
+    await objectStore.putBucketLifecycleConfiguration(ttlConfig).promise();
   }
   if (filename?.endsWith(".js")) {
     extra = {
@@ -18876,45 +18867,37 @@ async function streamUpload({
     ContentType: contentType,
     ...extra
   };
-  const upload2 = new import_lib_storage.Upload({
-    client: objectStore,
-    params: params2
-  });
-  const details = await upload2.done();
+  const details = await objectStore.upload(params2).promise();
   const headDetails = await objectStore.headObject({
     Bucket: bucket,
     Key: objKey
-  });
+  }).promise();
   return {
     ...details,
     ContentLength: headDetails.ContentLength
   };
 }
 async function retrieve(bucketName, filepath) {
-  const objectStore = ObjectStore();
+  const objectStore = ObjectStore(bucketName);
   const params2 = {
     Bucket: sanitizeBucket(bucketName),
     Key: sanitizeKey(filepath)
   };
-  const response = await objectStore.getObject(params2);
-  if (!response.Body) {
-    throw new Error("Unable to retrieve object");
-  }
-  const nodeResponse = response.Body;
+  const response = await objectStore.getObject(params2).promise();
   if (STRING_CONTENT_TYPES.includes(response.ContentType)) {
-    return nodeResponse.toString();
+    return response.Body.toString("utf8");
   } else {
-    return nodeResponse;
+    return response.Body;
   }
 }
 async function listAllObjects(bucketName, path3) {
-  const objectStore = ObjectStore();
+  const objectStore = ObjectStore(bucketName);
   const list = (params2 = {}) => {
     return objectStore.listObjectsV2({
       ...params2,
       Bucket: sanitizeBucket(bucketName),
       Prefix: sanitizeKey(path3)
-    });
+    }).promise();
   };
   let isTruncated = false, token, objects = [];
   do {
@@ -18931,15 +18914,14 @@ async function listAllObjects(bucketName, path3) {
   } while (isTruncated && token);
   return objects;
 }
-async function getPresignedUrl(bucketName, key, durationSeconds = 3600) {
-  const objectStore = ObjectStore({ presigning: true });
+function getPresignedUrl(bucketName, key, durationSeconds = 3600) {
+  const objectStore = ObjectStore(bucketName, { presigning: true });
   const params2 = {
     Bucket: sanitizeBucket(bucketName),
-    Key: sanitizeKey(key)
+    Key: sanitizeKey(key),
+    Expires: durationSeconds
   };
-  const url = await (0, import_s3_request_presigner.getSignedUrl)(objectStore, new import_client_s3.GetObjectCommand(params2), {
-    expiresIn: durationSeconds
-  });
+  const url = objectStore.getSignedUrl("getObject", params2);
   if (!environment_default.MINIO_ENABLED) {
     return url;
   } else {
@@ -18954,11 +18936,7 @@ async function retrieveToTmp(bucketName, filepath) {
   filepath = sanitizeKey(filepath);
   const data = await retrieve(bucketName, filepath);
   const outputPath = (0, import_path2.join)(budibaseTempDir(), (0, import_uuid2.v4)());
-  if (data instanceof import_stream2.default.Readable) {
-    data.pipe(import_fs3.default.createWriteStream(outputPath));
-  } else {
-    import_fs3.default.writeFileSync(outputPath, data);
-  }
+  import_fs3.default.writeFileSync(outputPath, data);
   return outputPath;
 }
 async function retrieveDirectory(bucketName, path3) {
@@ -18995,16 +18973,16 @@ async function retrieveDirectory(bucketName, path3) {
   return writePath;
 }
 async function deleteFile(bucketName, filepath) {
-  const objectStore = ObjectStore();
+  const objectStore = ObjectStore(bucketName);
   await createBucketIfNotExists(objectStore, bucketName);
   const params2 = {
     Bucket: bucketName,
     Key: sanitizeKey(filepath)
   };
-  return objectStore.deleteObject(params2);
+  return objectStore.deleteObject(params2).promise();
 }
 async function deleteFiles(bucketName, filepaths) {
-  const objectStore = ObjectStore();
+  const objectStore = ObjectStore(bucketName);
   await createBucketIfNotExists(objectStore, bucketName);
   const params2 = {
     Bucket: bucketName,
@@ -19012,17 +18990,17 @@ async function deleteFiles(bucketName, filepaths) {
       Objects: filepaths.map((path3) => ({ Key: sanitizeKey(path3) }))
     }
   };
-  return objectStore.deleteObjects(params2);
+  return objectStore.deleteObjects(params2).promise();
 }
 async function deleteFolder(bucketName, folder) {
   bucketName = sanitizeBucket(bucketName);
   folder = sanitizeKey(folder);
-  const client = ObjectStore();
+  const client = ObjectStore(bucketName);
   const listParams = {
     Bucket: bucketName,
     Prefix: folder
   };
-  const existingObjectsResponse = await client.listObjects(listParams);
+  const existingObjectsResponse = await client.listObjects(listParams).promise();
   if (existingObjectsResponse.Contents?.length === 0) {
     return;
   }
@@ -19035,7 +19013,7 @@ async function deleteFolder(bucketName, folder) {
   existingObjectsResponse.Contents?.forEach((content) => {
     deleteParams.Delete.Objects.push({ Key: content.Key });
   });
-  const deleteResponse = await client.deleteObjects(deleteParams);
+  const deleteResponse = await client.deleteObjects(deleteParams).promise();
   if (deleteResponse.Deleted?.length === 1e3) {
     return deleteFolder(bucketName, folder);
   }
@@ -19087,27 +19065,23 @@ async function downloadTarball(url, bucketName, path3) {
 async function getReadStream(bucketName, path3) {
   bucketName = sanitizeBucket(bucketName);
   path3 = sanitizeKey(path3);
-  const client = ObjectStore();
+  const client = ObjectStore(bucketName);
   const params2 = {
     Bucket: bucketName,
     Key: path3
   };
-  const response = await client.getObject(params2);
-  if (!response.Body || !(response.Body instanceof import_stream2.default.Readable)) {
-    throw new Error("Unable to retrieve stream - invalid response");
-  }
-  return response.Body;
+  return client.getObject(params2).createReadStream();
 }
 async function getObjectMetadata(bucket, path3) {
   bucket = sanitizeBucket(bucket);
   path3 = sanitizeKey(path3);
-  const client = ObjectStore();
+  const client = ObjectStore(bucket);
   const params2 = {
     Bucket: bucket,
     Key: path3
   };
   try {
-    return await client.headObject(params2);
+    return await client.headObject(params2).promise();
   } catch (err) {
     throw new Error("Unable to retrieve metadata from object");
   }
@@ -19165,7 +19139,7 @@ var import_querystring = __toESM(require("querystring"));
 function clientLibraryPath(appId) {
   return `${sanitizeKey(appId)}/budibase-client.js`;
 }
-async function clientLibraryCDNUrl(appId, version) {
+function clientLibraryCDNUrl(appId, version) {
   let file = clientLibraryPath(appId);
   if (environment_default.CLOUDFRONT_CDN) {
     if (version) {
@@ -19173,7 +19147,7 @@ async function clientLibraryCDNUrl(appId, version) {
     }
     return getUrl(file);
   } else {
-    return await getPresignedUrl(environment_default.APPS_BUCKET_NAME, file);
+    return getPresignedUrl(environment_default.APPS_BUCKET_NAME, file);
   }
 }
 function clientLibraryUrl(appId, version) {
@@ -19191,16 +19165,16 @@ function clientLibraryUrl(appId, version) {
   }
   return `/api/assets/client?${import_querystring.default.encode(qsParams)}`;
 }
-async function getAppFileUrl(s3Key) {
+function getAppFileUrl(s3Key) {
   if (environment_default.CLOUDFRONT_CDN) {
     return getPresignedUrl2(s3Key);
   } else {
-    return await getPresignedUrl(environment_default.APPS_BUCKET_NAME, s3Key);
+    return getPresignedUrl(environment_default.APPS_BUCKET_NAME, s3Key);
   }
 }
 
 // src/objectStore/buckets/global.ts
-var getGlobalFileUrl = async (type, name, etag) => {
+var getGlobalFileUrl = (type, name, etag) => {
   let file = getGlobalFileS3Key(type, name);
   if (environment_default.CLOUDFRONT_CDN) {
     if (etag) {
@@ -19208,7 +19182,7 @@ var getGlobalFileUrl = async (type, name, etag) => {
     }
     return getPresignedUrl2(file);
   } else {
-    return await getPresignedUrl(environment_default.GLOBAL_BUCKET_NAME, file);
+    return getPresignedUrl(environment_default.GLOBAL_BUCKET_NAME, file);
   }
 };
 var getGlobalFileS3Key = (type, name) => {
@@ -19221,34 +19195,32 @@ var getGlobalFileS3Key = (type, name) => {
 };
 
 // src/objectStore/buckets/plugins.ts
-async function enrichPluginURLs(plugins) {
+function enrichPluginURLs(plugins) {
   if (!plugins || !plugins.length) {
     return [];
   }
-  return await Promise.all(
-    plugins.map(async (plugin) => {
-      const jsUrl = await getPluginJSUrl(plugin);
-      const iconUrl = await getPluginIconUrl(plugin);
-      return { ...plugin, jsUrl, iconUrl };
-    })
-  );
+  return plugins.map((plugin) => {
+    const jsUrl = getPluginJSUrl(plugin);
+    const iconUrl = getPluginIconUrl(plugin);
+    return { ...plugin, jsUrl, iconUrl };
+  });
 }
-async function getPluginJSUrl(plugin) {
+function getPluginJSUrl(plugin) {
   const s3Key = getPluginJSKey(plugin);
   return getPluginUrl(s3Key);
 }
-async function getPluginIconUrl(plugin) {
+function getPluginIconUrl(plugin) {
   const s3Key = getPluginIconKey(plugin);
   if (!s3Key) {
     return;
   }
   return getPluginUrl(s3Key);
 }
-async function getPluginUrl(s3Key) {
+function getPluginUrl(s3Key) {
   if (environment_default.CLOUDFRONT_CDN) {
     return getPresignedUrl2(s3Key);
   } else {
-    return await getPresignedUrl(environment_default.PLUGIN_BUCKET_NAME, s3Key);
+    return getPresignedUrl(environment_default.PLUGIN_BUCKET_NAME, s3Key);
   }
 }
 function getPluginJSKey(plugin) {