@budibase/backend-core 3.2.34 → 3.2.35

package/dist/index.js

@@ -17698,7 +17698,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,
+  AWS_REGION: process.env.AWS_REGION || "eu-west-1",
   MINIO_URL: process.env.MINIO_URL,
   MINIO_ENABLED: process.env.MINIO_ENABLED || 1,
   INTERNAL_API_KEY: process.env.INTERNAL_API_KEY,
@@ -18619,7 +18619,9 @@ __export(objectStore_exports2, {
 });
 
 // src/objectStore/objectStore.ts
-var import_aws_sdk = __toESM(require("aws-sdk"));
+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_stream2 = __toESM(require("stream"));
 var import_node_fetch2 = __toESM(require("node-fetch"));
 var import_tar_fs = __toESM(require("tar-fs"));
@@ -18738,42 +18740,42 @@ function sanitizeKey(input) {
 function sanitizeBucket(input) {
   return input.replace(new RegExp(APP_DEV_PREFIX2, "g"), APP_PREFIX2);
 }
-function ObjectStore(bucket, opts = { presigning: false }) {
+function ObjectStore(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,
+    forcePathStyle: true,
+    credentials: {
+      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_ENABLED && environment_default.AWS_SESSION_TOKEN) {
-    config.sessionToken = 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 (environment_default.MINIO_URL) {
     if (opts.presigning && environment_default.MINIO_ENABLED) {
-      config.endpoint = "minio-service";
+      config.endpoint = "http://minio-service";
     } else {
       config.endpoint = environment_default.MINIO_URL;
     }
   }
-  return new import_aws_sdk.default.S3(config);
+  return new import_client_s3.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 = err.statusCode === 404, noAccess = err.statusCode === 403;
+    const doesntExist = statusCode === 404, noAccess = statusCode === 403;
     if (promises[bucketName]) {
       await promises[bucketName];
       return { created: false, exists: true };
@@ -18781,7 +18783,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 };
@@ -18804,21 +18806,20 @@ async function upload({
 }) {
   const extension = filename.split(".").pop();
   const fileBytes = path3 ? (await import_promises.default.open(path3)).createReadStream() : body2;
-  const objectStore = ObjectStore(bucketName);
+  const objectStore = ObjectStore();
   const bucketCreated = await createBucketIfNotExists(objectStore, bucketName);
   if (ttl && bucketCreated.created) {
     let ttlConfig = bucketTTLConfig(bucketName, ttl);
-    await objectStore.putBucketLifecycleConfiguration(ttlConfig).promise();
+    await objectStore.putBucketLifecycleConfiguration(ttlConfig);
   }
   let contentType = type;
-  if (!contentType) {
-    contentType = extension ? CONTENT_TYPE_MAP[extension.toLowerCase()] : CONTENT_TYPE_MAP.txt;
-  }
+  const finalContentType = 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: contentType
+    ContentType: finalContentType
   };
   if (metadata && typeof metadata === "object") {
     for (let key of Object.keys(metadata)) {
@@ -18828,7 +18829,11 @@ async function upload({
     }
     config.Metadata = metadata;
   }
-  return objectStore.upload(config).promise();
+  const upload2 = new import_lib_storage.Upload({
+    client: objectStore,
+    params: config
+  });
+  return upload2.done();
 }
 async function streamUpload({
   bucket: bucketName,
@@ -18842,11 +18847,11 @@ async function streamUpload({
     throw new Error("Stream to upload is invalid/undefined");
   }
   const extension = filename.split(".").pop();
-  const objectStore = ObjectStore(bucketName);
+  const objectStore = ObjectStore();
   const bucketCreated = await createBucketIfNotExists(objectStore, bucketName);
   if (ttl && bucketCreated.created) {
     let ttlConfig = bucketTTLConfig(bucketName, ttl);
-    await objectStore.putBucketLifecycleConfiguration(ttlConfig).promise();
+    await objectStore.putBucketLifecycleConfiguration(ttlConfig);
   }
   if (filename?.endsWith(".js")) {
     extra = {
@@ -18871,37 +18876,45 @@ async function streamUpload({
     ContentType: contentType,
     ...extra
   };
-  const details = await objectStore.upload(params2).promise();
+  const upload2 = new import_lib_storage.Upload({
+    client: objectStore,
+    params: params2
+  });
+  const details = await upload2.done();
   const headDetails = await objectStore.headObject({
     Bucket: bucket,
     Key: objKey
-  }).promise();
+  });
   return {
     ...details,
     ContentLength: headDetails.ContentLength
   };
 }
 async function retrieve(bucketName, filepath) {
-  const objectStore = ObjectStore(bucketName);
+  const objectStore = ObjectStore();
   const params2 = {
     Bucket: sanitizeBucket(bucketName),
     Key: sanitizeKey(filepath)
   };
-  const response = await objectStore.getObject(params2).promise();
+  const response = await objectStore.getObject(params2);
+  if (!response.Body) {
+    throw new Error("Unable to retrieve object");
+  }
+  const nodeResponse = response.Body;
   if (STRING_CONTENT_TYPES.includes(response.ContentType)) {
-    return response.Body.toString("utf8");
+    return nodeResponse.toString();
   } else {
-    return response.Body;
+    return nodeResponse;
   }
 }
 async function listAllObjects(bucketName, path3) {
-  const objectStore = ObjectStore(bucketName);
+  const objectStore = ObjectStore();
   const list = (params2 = {}) => {
     return objectStore.listObjectsV2({
       ...params2,
       Bucket: sanitizeBucket(bucketName),
       Prefix: sanitizeKey(path3)
-    }).promise();
+    });
   };
   let isTruncated = false, token, objects = [];
   do {
@@ -18918,14 +18931,15 @@ async function listAllObjects(bucketName, path3) {
   } while (isTruncated && token);
   return objects;
 }
-function getPresignedUrl(bucketName, key, durationSeconds = 3600) {
-  const objectStore = ObjectStore(bucketName, { presigning: true });
+async function getPresignedUrl(bucketName, key, durationSeconds = 3600) {
+  const objectStore = ObjectStore({ presigning: true });
   const params2 = {
     Bucket: sanitizeBucket(bucketName),
-    Key: sanitizeKey(key),
-    Expires: durationSeconds
+    Key: sanitizeKey(key)
   };
-  const url = objectStore.getSignedUrl("getObject", params2);
+  const url = await (0, import_s3_request_presigner.getSignedUrl)(objectStore, new import_client_s3.GetObjectCommand(params2), {
+    expiresIn: durationSeconds
+  });
   if (!environment_default.MINIO_ENABLED) {
     return url;
   } else {
@@ -18940,7 +18954,11 @@ 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)());
-  import_fs3.default.writeFileSync(outputPath, data);
+  if (data instanceof import_stream2.default.Readable) {
+    data.pipe(import_fs3.default.createWriteStream(outputPath));
+  } else {
+    import_fs3.default.writeFileSync(outputPath, data);
+  }
   return outputPath;
 }
 async function retrieveDirectory(bucketName, path3) {
@@ -18977,16 +18995,16 @@ async function retrieveDirectory(bucketName, path3) {
   return writePath;
 }
 async function deleteFile(bucketName, filepath) {
-  const objectStore = ObjectStore(bucketName);
+  const objectStore = ObjectStore();
   await createBucketIfNotExists(objectStore, bucketName);
   const params2 = {
     Bucket: bucketName,
     Key: sanitizeKey(filepath)
   };
-  return objectStore.deleteObject(params2).promise();
+  return objectStore.deleteObject(params2);
 }
 async function deleteFiles(bucketName, filepaths) {
-  const objectStore = ObjectStore(bucketName);
+  const objectStore = ObjectStore();
   await createBucketIfNotExists(objectStore, bucketName);
   const params2 = {
     Bucket: bucketName,
@@ -18994,17 +19012,17 @@ async function deleteFiles(bucketName, filepaths) {
       Objects: filepaths.map((path3) => ({ Key: sanitizeKey(path3) }))
     }
   };
-  return objectStore.deleteObjects(params2).promise();
+  return objectStore.deleteObjects(params2);
 }
 async function deleteFolder(bucketName, folder) {
   bucketName = sanitizeBucket(bucketName);
   folder = sanitizeKey(folder);
-  const client = ObjectStore(bucketName);
+  const client = ObjectStore();
   const listParams = {
     Bucket: bucketName,
     Prefix: folder
   };
-  const existingObjectsResponse = await client.listObjects(listParams).promise();
+  const existingObjectsResponse = await client.listObjects(listParams);
   if (existingObjectsResponse.Contents?.length === 0) {
     return;
   }
@@ -19017,7 +19035,7 @@ async function deleteFolder(bucketName, folder) {
   existingObjectsResponse.Contents?.forEach((content) => {
     deleteParams.Delete.Objects.push({ Key: content.Key });
   });
-  const deleteResponse = await client.deleteObjects(deleteParams).promise();
+  const deleteResponse = await client.deleteObjects(deleteParams);
   if (deleteResponse.Deleted?.length === 1e3) {
     return deleteFolder(bucketName, folder);
   }
@@ -19069,23 +19087,27 @@ async function downloadTarball(url, bucketName, path3) {
 async function getReadStream(bucketName, path3) {
   bucketName = sanitizeBucket(bucketName);
   path3 = sanitizeKey(path3);
-  const client = ObjectStore(bucketName);
+  const client = ObjectStore();
   const params2 = {
     Bucket: bucketName,
     Key: path3
   };
-  return client.getObject(params2).createReadStream();
+  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;
 }
 async function getObjectMetadata(bucket, path3) {
   bucket = sanitizeBucket(bucket);
   path3 = sanitizeKey(path3);
-  const client = ObjectStore(bucket);
+  const client = ObjectStore();
   const params2 = {
     Bucket: bucket,
     Key: path3
   };
   try {
-    return await client.headObject(params2).promise();
+    return await client.headObject(params2);
   } catch (err) {
     throw new Error("Unable to retrieve metadata from object");
   }
@@ -19143,7 +19165,7 @@ var import_querystring = __toESM(require("querystring"));
 function clientLibraryPath(appId) {
   return `${sanitizeKey(appId)}/budibase-client.js`;
 }
-function clientLibraryCDNUrl(appId, version) {
+async function clientLibraryCDNUrl(appId, version) {
   let file = clientLibraryPath(appId);
   if (environment_default.CLOUDFRONT_CDN) {
     if (version) {
@@ -19151,7 +19173,7 @@ function clientLibraryCDNUrl(appId, version) {
     }
     return getUrl(file);
   } else {
-    return getPresignedUrl(environment_default.APPS_BUCKET_NAME, file);
+    return await getPresignedUrl(environment_default.APPS_BUCKET_NAME, file);
   }
 }
 function clientLibraryUrl(appId, version) {
@@ -19169,16 +19191,16 @@ function clientLibraryUrl(appId, version) {
   }
   return `/api/assets/client?${import_querystring.default.encode(qsParams)}`;
 }
-function getAppFileUrl(s3Key) {
+async function getAppFileUrl(s3Key) {
   if (environment_default.CLOUDFRONT_CDN) {
     return getPresignedUrl2(s3Key);
   } else {
-    return getPresignedUrl(environment_default.APPS_BUCKET_NAME, s3Key);
+    return await getPresignedUrl(environment_default.APPS_BUCKET_NAME, s3Key);
   }
 }
 
 // src/objectStore/buckets/global.ts
-var getGlobalFileUrl = (type, name, etag) => {
+var getGlobalFileUrl = async (type, name, etag) => {
   let file = getGlobalFileS3Key(type, name);
   if (environment_default.CLOUDFRONT_CDN) {
     if (etag) {
@@ -19186,7 +19208,7 @@ var getGlobalFileUrl = (type, name, etag) => {
     }
     return getPresignedUrl2(file);
   } else {
-    return getPresignedUrl(environment_default.GLOBAL_BUCKET_NAME, file);
+    return await getPresignedUrl(environment_default.GLOBAL_BUCKET_NAME, file);
   }
 };
 var getGlobalFileS3Key = (type, name) => {
@@ -19199,32 +19221,34 @@ var getGlobalFileS3Key = (type, name) => {
 };
 
 // src/objectStore/buckets/plugins.ts
-function enrichPluginURLs(plugins) {
+async function enrichPluginURLs(plugins) {
   if (!plugins || !plugins.length) {
     return [];
   }
-  return plugins.map((plugin) => {
-    const jsUrl = getPluginJSUrl(plugin);
-    const iconUrl = getPluginIconUrl(plugin);
-    return { ...plugin, jsUrl, iconUrl };
-  });
+  return await Promise.all(
+    plugins.map(async (plugin) => {
+      const jsUrl = await getPluginJSUrl(plugin);
+      const iconUrl = await getPluginIconUrl(plugin);
+      return { ...plugin, jsUrl, iconUrl };
+    })
+  );
 }
-function getPluginJSUrl(plugin) {
+async function getPluginJSUrl(plugin) {
   const s3Key = getPluginJSKey(plugin);
   return getPluginUrl(s3Key);
 }
-function getPluginIconUrl(plugin) {
+async function getPluginIconUrl(plugin) {
   const s3Key = getPluginIconKey(plugin);
   if (!s3Key) {
     return;
   }
   return getPluginUrl(s3Key);
 }
-function getPluginUrl(s3Key) {
+async function getPluginUrl(s3Key) {
   if (environment_default.CLOUDFRONT_CDN) {
     return getPresignedUrl2(s3Key);
   } else {
-    return getPresignedUrl(environment_default.PLUGIN_BUCKET_NAME, s3Key);
+    return await getPresignedUrl(environment_default.PLUGIN_BUCKET_NAME, s3Key);
   }
 }
 function getPluginJSKey(plugin) {