@budibase/backend-core 2.9.38 → 2.9.39-alpha.1

package/dist/src/objectStore/buckets/tests/plugins.spec.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../src/objectStore/buckets/tests/plugins.spec.ts"],
+  "sourcesContent": ["import * as plugins from \"../plugins\"\nimport { structures } from \"../../../../tests\"\nimport { testEnv } from \"../../../../tests/extra\"\n\ndescribe(\"plugins\", () => {\n  describe(\"enrichPluginURLs\", () => {\n    const plugin = structures.plugins.plugin()\n\n    function getEnrichedPluginUrls() {\n      const enriched = plugins.enrichPluginURLs([plugin])[0]\n      return {\n        jsUrl: enriched.jsUrl!,\n        iconUrl: enriched.iconUrl!,\n      }\n    }\n\n    describe(\"single tenant\", () => {\n      beforeAll(() => {\n        testEnv.singleTenant()\n      })\n\n      it(\"gets url with embedded minio\", () => {\n        testEnv.withMinio()\n        const urls = getEnrichedPluginUrls()\n        expect(urls.jsUrl).toBe(\n          `/files/signed/plugins/${plugin.name}/plugin.min.js`\n        )\n        expect(urls.iconUrl).toBe(\n          `/files/signed/plugins/${plugin.name}/icon.svg`\n        )\n      })\n\n      it(\"gets url with custom S3\", () => {\n        testEnv.withS3()\n        const urls = getEnrichedPluginUrls()\n        expect(urls.jsUrl).toBe(\n          `http://s3.example.com/plugins/${plugin.name}/plugin.min.js`\n        )\n        expect(urls.iconUrl).toBe(\n          `http://s3.example.com/plugins/${plugin.name}/icon.svg`\n        )\n      })\n\n      it(\"gets url with cloudfront + s3\", () => {\n        testEnv.withCloudfront()\n        const urls = getEnrichedPluginUrls()\n        // omit rest of signed params\n        expect(\n          urls.jsUrl.includes(\n            `http://cf.example.com/plugins/${plugin.name}/plugin.min.js?`\n          )\n        ).toBe(true)\n        expect(\n          urls.iconUrl.includes(\n            `http://cf.example.com/plugins/${plugin.name}/icon.svg?`\n          )\n        ).toBe(true)\n      })\n    })\n\n    describe(\"multi tenant\", () => {\n      beforeAll(() => {\n        testEnv.multiTenant()\n      })\n\n      it(\"gets url with embedded minio\", async () => {\n        testEnv.withMinio()\n        await testEnv.withTenant(tenantId => {\n          const urls = getEnrichedPluginUrls()\n          expect(urls.jsUrl).toBe(\n            `/files/signed/plugins/${tenantId}/${plugin.name}/plugin.min.js`\n          )\n          expect(urls.iconUrl).toBe(\n            `/files/signed/plugins/${tenantId}/${plugin.name}/icon.svg`\n          )\n        })\n      })\n\n      it(\"gets url with custom S3\", async () => {\n        testEnv.withS3()\n        await testEnv.withTenant(tenantId => {\n          const urls = getEnrichedPluginUrls()\n          expect(urls.jsUrl).toBe(\n            `http://s3.example.com/plugins/${tenantId}/${plugin.name}/plugin.min.js`\n          )\n          expect(urls.iconUrl).toBe(\n            `http://s3.example.com/plugins/${tenantId}/${plugin.name}/icon.svg`\n          )\n        })\n      })\n\n      it(\"gets url with cloudfront + s3\", async () => {\n        testEnv.withCloudfront()\n        await testEnv.withTenant(tenantId => {\n          const urls = getEnrichedPluginUrls()\n          // omit rest of signed params\n          expect(\n            urls.jsUrl.includes(\n              `http://cf.example.com/plugins/${tenantId}/${plugin.name}/plugin.min.js?`\n            )\n          ).toBe(true)\n          expect(\n            urls.iconUrl.includes(\n              `http://cf.example.com/plugins/${tenantId}/${plugin.name}/icon.svg?`\n            )\n          ).toBe(true)\n        })\n      })\n    })\n  })\n})\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/src/objectStore/cloudfront.js

@@ -0,0 +1,74 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var cloudfront_exports = {};
+__export(cloudfront_exports, {
+  getPresignedUrl: () => getPresignedUrl,
+  getUrl: () => getUrl
+});
+module.exports = __toCommonJS(cloudfront_exports);
+var import_environment = __toESM(require("../environment"));
+const cfsign = require("aws-cloudfront-sign");
+let PRIVATE_KEY;
+function getPrivateKey() {
+  if (!import_environment.default.CLOUDFRONT_PRIVATE_KEY_64) {
+    throw new Error("CLOUDFRONT_PRIVATE_KEY_64 is not set");
+  }
+  if (PRIVATE_KEY) {
+    return PRIVATE_KEY;
+  }
+  PRIVATE_KEY = Buffer.from(import_environment.default.CLOUDFRONT_PRIVATE_KEY_64, "base64").toString(
+    "utf-8"
+  );
+  return PRIVATE_KEY;
+}
+const getCloudfrontSignParams = () => {
+  return {
+    keypairId: import_environment.default.CLOUDFRONT_PUBLIC_KEY_ID,
+    privateKeyString: getPrivateKey(),
+    expireTime: (/* @__PURE__ */ new Date()).getTime() + 1e3 * 60 * 60
+    // 1 hour
+  };
+};
+const getPresignedUrl = (s3Key) => {
+  const url = getUrl(s3Key);
+  return cfsign.getSignedUrl(url, getCloudfrontSignParams());
+};
+const getUrl = (s3Key) => {
+  let prefix = "/";
+  if (s3Key.startsWith("/")) {
+    prefix = "";
+  }
+  return `${import_environment.default.CLOUDFRONT_CDN}${prefix}${s3Key}`;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getPresignedUrl,
+  getUrl
+});
+//# sourceMappingURL=cloudfront.js.map

package/dist/src/objectStore/cloudfront.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/objectStore/cloudfront.ts"],
+  "sourcesContent": ["import env from \"../environment\"\nconst cfsign = require(\"aws-cloudfront-sign\")\n\nlet PRIVATE_KEY: string | undefined\n\nfunction getPrivateKey() {\n  if (!env.CLOUDFRONT_PRIVATE_KEY_64) {\n    throw new Error(\"CLOUDFRONT_PRIVATE_KEY_64 is not set\")\n  }\n\n  if (PRIVATE_KEY) {\n    return PRIVATE_KEY\n  }\n\n  PRIVATE_KEY = Buffer.from(env.CLOUDFRONT_PRIVATE_KEY_64, \"base64\").toString(\n    \"utf-8\"\n  )\n\n  return PRIVATE_KEY\n}\n\nconst getCloudfrontSignParams = () => {\n  return {\n    keypairId: env.CLOUDFRONT_PUBLIC_KEY_ID,\n    privateKeyString: getPrivateKey(),\n    expireTime: new Date().getTime() + 1000 * 60 * 60, // 1 hour\n  }\n}\n\nexport const getPresignedUrl = (s3Key: string) => {\n  const url = getUrl(s3Key)\n  return cfsign.getSignedUrl(url, getCloudfrontSignParams())\n}\n\nexport const getUrl = (s3Key: string) => {\n  let prefix = \"/\"\n  if (s3Key.startsWith(\"/\")) {\n    prefix = \"\"\n  }\n  return `${env.CLOUDFRONT_CDN}${prefix}${s3Key}`\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAAgB;AAChB,MAAM,SAAS,QAAQ,qBAAqB;AAE5C,IAAI;AAEJ,SAAS,gBAAgB;AACvB,MAAI,CAAC,mBAAAA,QAAI,2BAA2B;AAClC,UAAM,IAAI,MAAM,sCAAsC;AAAA,EACxD;AAEA,MAAI,aAAa;AACf,WAAO;AAAA,EACT;AAEA,gBAAc,OAAO,KAAK,mBAAAA,QAAI,2BAA2B,QAAQ,EAAE;AAAA,IACjE;AAAA,EACF;AAEA,SAAO;AACT;AAEA,MAAM,0BAA0B,MAAM;AACpC,SAAO;AAAA,IACL,WAAW,mBAAAA,QAAI;AAAA,IACf,kBAAkB,cAAc;AAAA,IAChC,aAAY,oBAAI,KAAK,GAAE,QAAQ,IAAI,MAAO,KAAK;AAAA;AAAA,EACjD;AACF;AAEO,MAAM,kBAAkB,CAAC,UAAkB;AAChD,QAAM,MAAM,OAAO,KAAK;AACxB,SAAO,OAAO,aAAa,KAAK,wBAAwB,CAAC;AAC3D;AAEO,MAAM,SAAS,CAAC,UAAkB;AACvC,MAAI,SAAS;AACb,MAAI,MAAM,WAAW,GAAG,GAAG;AACzB,aAAS;AAAA,EACX;AACA,SAAO,GAAG,mBAAAA,QAAI,cAAc,GAAG,MAAM,GAAG,KAAK;AAC/C;",
+  "names": ["env"]
+}

package/dist/src/objectStore/index.js

@@ -0,0 +1,27 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var objectStore_exports = {};
+module.exports = __toCommonJS(objectStore_exports);
+__reExport(objectStore_exports, require("./objectStore"), module.exports);
+__reExport(objectStore_exports, require("./utils"), module.exports);
+__reExport(objectStore_exports, require("./buckets"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./objectStore"),
+  ...require("./utils"),
+  ...require("./buckets")
+});
+//# sourceMappingURL=index.js.map

package/dist/src/objectStore/index.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/objectStore/index.ts"],
+  "sourcesContent": ["export * from \"./objectStore\"\nexport * from \"./utils\"\nexport * from \"./buckets\"\n"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAAA,gCAAc,0BAAd;AACA,gCAAc,oBADd;AAEA,gCAAc,sBAFd;",
+  "names": []
+}

package/dist/src/objectStore/objectStore.js

@@ -0,0 +1,372 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var objectStore_exports = {};
+__export(objectStore_exports, {
+  ObjectStore: () => ObjectStore,
+  deleteFile: () => deleteFile,
+  deleteFiles: () => deleteFiles,
+  deleteFolder: () => deleteFolder,
+  downloadTarball: () => downloadTarball,
+  downloadTarballDirect: () => downloadTarballDirect,
+  getPresignedUrl: () => getPresignedUrl,
+  listAllObjects: () => listAllObjects,
+  makeSureBucketExists: () => makeSureBucketExists,
+  retrieve: () => retrieve,
+  retrieveDirectory: () => retrieveDirectory,
+  retrieveToTmp: () => retrieveToTmp,
+  sanitizeBucket: () => sanitizeBucket,
+  sanitizeKey: () => sanitizeKey,
+  streamUpload: () => streamUpload,
+  upload: () => upload,
+  uploadDirectory: () => uploadDirectory
+});
+module.exports = __toCommonJS(objectStore_exports);
+var import_aws_sdk = __toESM(require("aws-sdk"));
+var import_stream = __toESM(require("stream"));
+var import_node_fetch = __toESM(require("node-fetch"));
+var import_tar_fs = __toESM(require("tar-fs"));
+var import_zlib = __toESM(require("zlib"));
+var import_util = require("util");
+var import_path = require("path");
+var import_fs = __toESM(require("fs"));
+var import_environment = __toESM(require("../environment"));
+var import_utils = require("./utils");
+var import_uuid = require("uuid");
+var import_db = require("../db");
+const sanitize = require("sanitize-s3-objectkey");
+const streamPipeline = (0, import_util.promisify)(import_stream.default.pipeline);
+const STATE = {
+  bucketCreationPromises: {}
+};
+const CONTENT_TYPE_MAP = {
+  txt: "text/plain",
+  html: "text/html",
+  css: "text/css",
+  js: "application/javascript",
+  json: "application/json",
+  gz: "application/gzip"
+};
+const STRING_CONTENT_TYPES = [
+  CONTENT_TYPE_MAP.html,
+  CONTENT_TYPE_MAP.css,
+  CONTENT_TYPE_MAP.js,
+  CONTENT_TYPE_MAP.json
+];
+function sanitizeKey(input) {
+  return sanitize(sanitizeBucket(input)).replace(/\\/g, "/");
+}
+function sanitizeBucket(input) {
+  return input.replace(new RegExp(import_db.APP_DEV_PREFIX, "g"), import_db.APP_PREFIX);
+}
+const ObjectStore = (bucket, opts = { presigning: false }) => {
+  const config = {
+    s3ForcePathStyle: true,
+    signatureVersion: "v4",
+    apiVersion: "2006-03-01",
+    accessKeyId: import_environment.default.MINIO_ACCESS_KEY,
+    secretAccessKey: import_environment.default.MINIO_SECRET_KEY,
+    region: import_environment.default.AWS_REGION
+  };
+  if (bucket) {
+    config.params = {
+      Bucket: sanitizeBucket(bucket)
+    };
+  }
+  if (import_environment.default.MINIO_URL) {
+    if (opts.presigning && import_environment.default.MINIO_ENABLED) {
+      config.endpoint = "minio-service";
+    } else {
+      config.endpoint = import_environment.default.MINIO_URL;
+    }
+  }
+  return new import_aws_sdk.default.S3(config);
+};
+const 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.");
+    }
+  }
+};
+const upload = async ({
+  bucket: bucketName,
+  filename,
+  path,
+  type,
+  metadata
+}) => {
+  const extension = filename.split(".").pop();
+  const fileBytes = import_fs.default.readFileSync(path);
+  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();
+};
+const 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 params = {
+    Bucket: sanitizeBucket(bucketName),
+    Key: sanitizeKey(filename),
+    Body: stream2,
+    ...extra
+  };
+  return objectStore.upload(params).promise();
+};
+const retrieve = async (bucketName, filepath) => {
+  const objectStore = ObjectStore(bucketName);
+  const params = {
+    Bucket: sanitizeBucket(bucketName),
+    Key: sanitizeKey(filepath)
+  };
+  const response = await objectStore.getObject(params).promise();
+  if (STRING_CONTENT_TYPES.includes(response.ContentType)) {
+    return response.Body.toString("utf8");
+  } else {
+    return response.Body;
+  }
+};
+const listAllObjects = async (bucketName, path) => {
+  const objectStore = ObjectStore(bucketName);
+  const list = (params = {}) => {
+    return objectStore.listObjectsV2({
+      ...params,
+      Bucket: sanitizeBucket(bucketName),
+      Prefix: sanitizeKey(path)
+    }).promise();
+  };
+  let isTruncated = false, token, objects = [];
+  do {
+    let params = {};
+    if (token) {
+      params.ContinuationToken = token;
+    }
+    const response = await list(params);
+    if (response.Contents) {
+      objects = objects.concat(response.Contents);
+    }
+    isTruncated = !!response.IsTruncated;
+  } while (isTruncated);
+  return objects;
+};
+const getPresignedUrl = (bucketName, key, durationSeconds = 3600) => {
+  const objectStore = ObjectStore(bucketName, { presigning: true });
+  const params = {
+    Bucket: sanitizeBucket(bucketName),
+    Key: sanitizeKey(key),
+    Expires: durationSeconds
+  };
+  const url = objectStore.getSignedUrl("getObject", params);
+  if (!import_environment.default.MINIO_ENABLED) {
+    return url;
+  } else {
+    const signedUrl = new URL(url);
+    const path = signedUrl.pathname;
+    const query = signedUrl.search;
+    return `/files/signed${path}${query}`;
+  }
+};
+const retrieveToTmp = async (bucketName, filepath) => {
+  bucketName = sanitizeBucket(bucketName);
+  filepath = sanitizeKey(filepath);
+  const data = await retrieve(bucketName, filepath);
+  const outputPath = (0, import_path.join)((0, import_utils.budibaseTempDir)(), (0, import_uuid.v4)());
+  import_fs.default.writeFileSync(outputPath, data);
+  return outputPath;
+};
+const retrieveDirectory = async (bucketName, path) => {
+  let writePath = (0, import_path.join)((0, import_utils.budibaseTempDir)(), (0, import_uuid.v4)());
+  import_fs.default.mkdirSync(writePath);
+  const objects = await listAllObjects(bucketName, path);
+  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_fs.default.mkdirSync((0, import_path.join)(writePath, ...dirs), { recursive: true });
+    }
+    import_fs.default.writeFileSync((0, import_path.join)(writePath, ...possiblePath), data);
+  }
+  return writePath;
+};
+const deleteFile = async (bucketName, filepath) => {
+  const objectStore = ObjectStore(bucketName);
+  await makeSureBucketExists(objectStore, bucketName);
+  const params = {
+    Bucket: bucketName,
+    Key: sanitizeKey(filepath)
+  };
+  return objectStore.deleteObject(params).promise();
+};
+const deleteFiles = async (bucketName, filepaths) => {
+  const objectStore = ObjectStore(bucketName);
+  await makeSureBucketExists(objectStore, bucketName);
+  const params = {
+    Bucket: bucketName,
+    Delete: {
+      Objects: filepaths.map((path) => ({ Key: sanitizeKey(path) }))
+    }
+  };
+  return objectStore.deleteObjects(params).promise();
+};
+const 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);
+  }
+};
+const uploadDirectory = async (bucketName, localPath, bucketPath) => {
+  bucketName = sanitizeBucket(bucketName);
+  let uploads = [];
+  const files = import_fs.default.readdirSync(localPath, { withFileTypes: true });
+  for (let file of files) {
+    const path = sanitizeKey((0, import_path.join)(bucketPath, file.name));
+    const local = (0, import_path.join)(localPath, file.name);
+    if (file.isDirectory()) {
+      uploads.push(uploadDirectory(bucketName, local, path));
+    } else {
+      uploads.push(streamUpload(bucketName, path, import_fs.default.createReadStream(local)));
+    }
+  }
+  await Promise.all(uploads);
+  return files;
+};
+const downloadTarballDirect = async (url, path, headers = {}) => {
+  path = sanitizeKey(path);
+  const response = await (0, import_node_fetch.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(path));
+};
+const downloadTarball = async (url, bucketName, path) => {
+  bucketName = sanitizeBucket(bucketName);
+  path = sanitizeKey(path);
+  const response = await (0, import_node_fetch.default)(url);
+  if (!response.ok) {
+    throw new Error(`unexpected response ${response.statusText}`);
+  }
+  const tmpPath = (0, import_path.join)((0, import_utils.budibaseTempDir)(), path);
+  await streamPipeline(response.body, import_zlib.default.createUnzip(), import_tar_fs.default.extract(tmpPath));
+  if (!import_environment.default.isTest() && import_environment.default.SELF_HOSTED) {
+    await uploadDirectory(bucketName, tmpPath, path);
+  }
+  return tmpPath;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObjectStore,
+  deleteFile,
+  deleteFiles,
+  deleteFolder,
+  downloadTarball,
+  downloadTarballDirect,
+  getPresignedUrl,
+  listAllObjects,
+  makeSureBucketExists,
+  retrieve,
+  retrieveDirectory,
+  retrieveToTmp,
+  sanitizeBucket,
+  sanitizeKey,
+  streamUpload,
+  upload,
+  uploadDirectory
+});
+//# sourceMappingURL=objectStore.js.map

package/dist/src/objectStore/objectStore.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/objectStore/objectStore.ts"],
+  "sourcesContent": ["const sanitize = require(\"sanitize-s3-objectkey\")\nimport AWS from \"aws-sdk\"\nimport stream from \"stream\"\nimport fetch from \"node-fetch\"\nimport tar from \"tar-fs\"\nimport zlib from \"zlib\"\nimport { promisify } from \"util\"\nimport { join } from \"path\"\nimport fs from \"fs\"\nimport env from \"../environment\"\nimport { budibaseTempDir } from \"./utils\"\nimport { v4 } from \"uuid\"\nimport { APP_PREFIX, APP_DEV_PREFIX } from \"../db\"\n\nconst streamPipeline = promisify(stream.pipeline)\n// use this as a temporary store of buckets that are being created\nconst STATE = {\n  bucketCreationPromises: {},\n}\n\ntype ListParams = {\n  ContinuationToken?: string\n}\n\ntype UploadParams = {\n  bucket: string\n  filename: string\n  path: string\n  type?: string | null\n  // can be undefined, we will remove it\n  metadata?: {\n    [key: string]: string | undefined\n  }\n}\n\nconst CONTENT_TYPE_MAP: any = {\n  txt: \"text/plain\",\n  html: \"text/html\",\n  css: \"text/css\",\n  js: \"application/javascript\",\n  json: \"application/json\",\n  gz: \"application/gzip\",\n}\n\nconst STRING_CONTENT_TYPES = [\n  CONTENT_TYPE_MAP.html,\n  CONTENT_TYPE_MAP.css,\n  CONTENT_TYPE_MAP.js,\n  CONTENT_TYPE_MAP.json,\n]\n\n// does normal sanitization and then swaps dev apps to apps\nexport function sanitizeKey(input: string) {\n  return sanitize(sanitizeBucket(input)).replace(/\\\\/g, \"/\")\n}\n\n// simply handles the dev app to app conversion\nexport function sanitizeBucket(input: string) {\n  return input.replace(new RegExp(APP_DEV_PREFIX, \"g\"), APP_PREFIX)\n}\n\n/**\n * Gets a connection to the object store using the S3 SDK.\n * @param {string} bucket the name of the bucket which blobs will be uploaded/retrieved from.\n * @param {object} opts configuration for the object store.\n * @return {Object} an S3 object store object, check S3 Nodejs SDK for usage.\n * @constructor\n */\nexport const ObjectStore = (\n  bucket: string,\n  opts: { presigning: boolean } = { presigning: false }\n) => {\n  const config: any = {\n    s3ForcePathStyle: true,\n    signatureVersion: \"v4\",\n    apiVersion: \"2006-03-01\",\n    accessKeyId: env.MINIO_ACCESS_KEY,\n    secretAccessKey: env.MINIO_SECRET_KEY,\n    region: env.AWS_REGION,\n  }\n  if (bucket) {\n    config.params = {\n      Bucket: sanitizeBucket(bucket),\n    }\n  }\n\n  // custom S3 is in use i.e. minio\n  if (env.MINIO_URL) {\n    if (opts.presigning && env.MINIO_ENABLED) {\n      // IMPORTANT: Signed urls will inspect the host header of the request.\n      // Normally a signed url will need to be generated with a specified host in mind.\n      // To support dynamic hosts, e.g. some unknown self-hosted installation url,\n      // use a predefined host. The host 'minio-service' is also forwarded to minio requests via nginx\n      config.endpoint = \"minio-service\"\n    } else {\n      config.endpoint = env.MINIO_URL\n    }\n  }\n\n  return new AWS.S3(config)\n}\n\n/**\n * Given an object store and a bucket name this will make sure the bucket exists,\n * if it does not exist then it will create it.\n */\nexport const makeSureBucketExists = async (client: any, bucketName: string) => {\n  bucketName = sanitizeBucket(bucketName)\n  try {\n    await client\n      .headBucket({\n        Bucket: bucketName,\n      })\n      .promise()\n  } catch (err: any) {\n    const promises: any = STATE.bucketCreationPromises\n    const doesntExist = err.statusCode === 404,\n      noAccess = err.statusCode === 403\n    if (promises[bucketName]) {\n      await promises[bucketName]\n    } else if (doesntExist || noAccess) {\n      if (doesntExist) {\n        // bucket doesn't exist create it\n        promises[bucketName] = client\n          .createBucket({\n            Bucket: bucketName,\n          })\n          .promise()\n        await promises[bucketName]\n        delete promises[bucketName]\n      }\n    } else {\n      throw new Error(\"Unable to write to object store bucket.\")\n    }\n  }\n}\n\n/**\n * Uploads the contents of a file given the required parameters, useful when\n * temp files in use (for example file uploaded as an attachment).\n */\nexport const upload = async ({\n  bucket: bucketName,\n  filename,\n  path,\n  type,\n  metadata,\n}: UploadParams) => {\n  const extension = filename.split(\".\").pop()\n  const fileBytes = fs.readFileSync(path)\n\n  const objectStore = ObjectStore(bucketName)\n  await makeSureBucketExists(objectStore, bucketName)\n\n  let contentType = type\n  if (!contentType) {\n    contentType = extension\n      ? CONTENT_TYPE_MAP[extension.toLowerCase()]\n      : CONTENT_TYPE_MAP.txt\n  }\n  const config: any = {\n    // windows file paths need to be converted to forward slashes for s3\n    Key: sanitizeKey(filename),\n    Body: fileBytes,\n    ContentType: contentType,\n  }\n  if (metadata && typeof metadata === \"object\") {\n    // remove any nullish keys from the metadata object, as these may be considered invalid\n    for (let key of Object.keys(metadata)) {\n      if (!metadata[key] || typeof metadata[key] !== \"string\") {\n        delete metadata[key]\n      }\n    }\n    config.Metadata = metadata\n  }\n  return objectStore.upload(config).promise()\n}\n\n/**\n * Similar to the upload function but can be used to send a file stream\n * through to the object store.\n */\nexport const streamUpload = async (\n  bucketName: string,\n  filename: string,\n  stream: any,\n  extra = {}\n) => {\n  const objectStore = ObjectStore(bucketName)\n  await makeSureBucketExists(objectStore, bucketName)\n\n  // Set content type for certain known extensions\n  if (filename?.endsWith(\".js\")) {\n    extra = {\n      ...extra,\n      ContentType: \"application/javascript\",\n    }\n  } else if (filename?.endsWith(\".svg\")) {\n    extra = {\n      ...extra,\n      ContentType: \"image\",\n    }\n  }\n\n  const params = {\n    Bucket: sanitizeBucket(bucketName),\n    Key: sanitizeKey(filename),\n    Body: stream,\n    ...extra,\n  }\n  return objectStore.upload(params).promise()\n}\n\n/**\n * retrieves the contents of a file from the object store, if it is a known content type it\n * will be converted, otherwise it will be returned as a buffer stream.\n */\nexport const retrieve = async (bucketName: string, filepath: string) => {\n  const objectStore = ObjectStore(bucketName)\n  const params = {\n    Bucket: sanitizeBucket(bucketName),\n    Key: sanitizeKey(filepath),\n  }\n  const response: any = await objectStore.getObject(params).promise()\n  // currently these are all strings\n  if (STRING_CONTENT_TYPES.includes(response.ContentType)) {\n    return response.Body.toString(\"utf8\")\n  } else {\n    return response.Body\n  }\n}\n\nexport const listAllObjects = async (bucketName: string, path: string) => {\n  const objectStore = ObjectStore(bucketName)\n  const list = (params: ListParams = {}) => {\n    return objectStore\n      .listObjectsV2({\n        ...params,\n        Bucket: sanitizeBucket(bucketName),\n        Prefix: sanitizeKey(path),\n      })\n      .promise()\n  }\n  let isTruncated = false,\n    token,\n    objects: AWS.S3.Types.Object[] = []\n  do {\n    let params: ListParams = {}\n    if (token) {\n      params.ContinuationToken = token\n    }\n    const response = await list(params)\n    if (response.Contents) {\n      objects = objects.concat(response.Contents)\n    }\n    isTruncated = !!response.IsTruncated\n  } while (isTruncated)\n  return objects\n}\n\n/**\n * Generate a presigned url with a default TTL of 1 hour\n */\nexport const getPresignedUrl = (\n  bucketName: string,\n  key: string,\n  durationSeconds: number = 3600\n) => {\n  const objectStore = ObjectStore(bucketName, { presigning: true })\n  const params = {\n    Bucket: sanitizeBucket(bucketName),\n    Key: sanitizeKey(key),\n    Expires: durationSeconds,\n  }\n  const url = objectStore.getSignedUrl(\"getObject\", params)\n\n  if (!env.MINIO_ENABLED) {\n    // return the full URL to the client\n    return url\n  } else {\n    // return the path only to the client\n    // use the presigned url route to ensure the static\n    // hostname will be used in the request\n    const signedUrl = new URL(url)\n    const path = signedUrl.pathname\n    const query = signedUrl.search\n    return `/files/signed${path}${query}`\n  }\n}\n\n/**\n * Same as retrieval function but puts to a temporary file.\n */\nexport const retrieveToTmp = async (bucketName: string, filepath: string) => {\n  bucketName = sanitizeBucket(bucketName)\n  filepath = sanitizeKey(filepath)\n  const data = await retrieve(bucketName, filepath)\n  const outputPath = join(budibaseTempDir(), v4())\n  fs.writeFileSync(outputPath, data)\n  return outputPath\n}\n\nexport const retrieveDirectory = async (bucketName: string, path: string) => {\n  let writePath = join(budibaseTempDir(), v4())\n  fs.mkdirSync(writePath)\n  const objects = await listAllObjects(bucketName, path)\n  let fullObjects = await Promise.all(\n    objects.map(obj => retrieve(bucketName, obj.Key!))\n  )\n  let count = 0\n  for (let obj of objects) {\n    const filename = obj.Key!\n    const data = fullObjects[count++]\n    const possiblePath = filename.split(\"/\")\n    if (possiblePath.length > 1) {\n      const dirs = possiblePath.slice(0, possiblePath.length - 1)\n      fs.mkdirSync(join(writePath, ...dirs), { recursive: true })\n    }\n    fs.writeFileSync(join(writePath, ...possiblePath), data)\n  }\n  return writePath\n}\n\n/**\n * Delete a single file.\n */\nexport const deleteFile = async (bucketName: string, filepath: string) => {\n  const objectStore = ObjectStore(bucketName)\n  await makeSureBucketExists(objectStore, bucketName)\n  const params = {\n    Bucket: bucketName,\n    Key: sanitizeKey(filepath),\n  }\n  return objectStore.deleteObject(params).promise()\n}\n\nexport const deleteFiles = async (bucketName: string, filepaths: string[]) => {\n  const objectStore = ObjectStore(bucketName)\n  await makeSureBucketExists(objectStore, bucketName)\n  const params = {\n    Bucket: bucketName,\n    Delete: {\n      Objects: filepaths.map((path: any) => ({ Key: sanitizeKey(path) })),\n    },\n  }\n  return objectStore.deleteObjects(params).promise()\n}\n\n/**\n * Delete a path, including everything within.\n */\nexport const deleteFolder = async (\n  bucketName: string,\n  folder: string\n): Promise<any> => {\n  bucketName = sanitizeBucket(bucketName)\n  folder = sanitizeKey(folder)\n  const client = ObjectStore(bucketName)\n  const listParams = {\n    Bucket: bucketName,\n    Prefix: folder,\n  }\n\n  const existingObjectsResponse = await client.listObjects(listParams).promise()\n  if (existingObjectsResponse.Contents?.length === 0) {\n    return\n  }\n  const deleteParams: any = {\n    Bucket: bucketName,\n    Delete: {\n      Objects: [],\n    },\n  }\n\n  existingObjectsResponse.Contents?.forEach((content: any) => {\n    deleteParams.Delete.Objects.push({ Key: content.Key })\n  })\n\n  const deleteResponse = await client.deleteObjects(deleteParams).promise()\n  // can only empty 1000 items at once\n  if (deleteResponse.Deleted?.length === 1000) {\n    return deleteFolder(bucketName, folder)\n  }\n}\n\nexport const uploadDirectory = async (\n  bucketName: string,\n  localPath: string,\n  bucketPath: string\n) => {\n  bucketName = sanitizeBucket(bucketName)\n  let uploads = []\n  const files = fs.readdirSync(localPath, { withFileTypes: true })\n  for (let file of files) {\n    const path = sanitizeKey(join(bucketPath, file.name))\n    const local = join(localPath, file.name)\n    if (file.isDirectory()) {\n      uploads.push(uploadDirectory(bucketName, local, path))\n    } else {\n      uploads.push(streamUpload(bucketName, path, fs.createReadStream(local)))\n    }\n  }\n  await Promise.all(uploads)\n  return files\n}\n\nexport const downloadTarballDirect = async (\n  url: string,\n  path: string,\n  headers = {}\n) => {\n  path = sanitizeKey(path)\n  const response = await fetch(url, { headers })\n  if (!response.ok) {\n    throw new Error(`unexpected response ${response.statusText}`)\n  }\n\n  await streamPipeline(response.body, zlib.createUnzip(), tar.extract(path))\n}\n\nexport const downloadTarball = async (\n  url: string,\n  bucketName: string,\n  path: string\n) => {\n  bucketName = sanitizeBucket(bucketName)\n  path = sanitizeKey(path)\n  const response = await fetch(url)\n  if (!response.ok) {\n    throw new Error(`unexpected response ${response.statusText}`)\n  }\n\n  const tmpPath = join(budibaseTempDir(), path)\n  await streamPipeline(response.body, zlib.createUnzip(), tar.extract(tmpPath))\n  if (!env.isTest() && env.SELF_HOSTED) {\n    await uploadDirectory(bucketName, tmpPath, path)\n  }\n  // return the temporary path incase there is a use for it\n  return tmpPath\n}\n"],
+  "mappings": "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",
+  "names": ["stream", "env", "AWS", "fs", "fetch", "zlib", "tar"]
+}

package/dist/src/objectStore/utils.js

@@ -0,0 +1,58 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var utils_exports = {};
+__export(utils_exports, {
+  ObjectStoreBuckets: () => ObjectStoreBuckets,
+  budibaseTempDir: () => budibaseTempDir
+});
+module.exports = __toCommonJS(utils_exports);
+var import_path = require("path");
+var import_os = require("os");
+var import_fs = __toESM(require("fs"));
+var import_environment = __toESM(require("../environment"));
+const ObjectStoreBuckets = {
+  BACKUPS: import_environment.default.BACKUPS_BUCKET_NAME,
+  APPS: import_environment.default.APPS_BUCKET_NAME,
+  TEMPLATES: import_environment.default.TEMPLATES_BUCKET_NAME,
+  GLOBAL: import_environment.default.GLOBAL_BUCKET_NAME,
+  PLUGINS: import_environment.default.PLUGIN_BUCKET_NAME
+};
+const bbTmp = (0, import_path.join)((0, import_os.tmpdir)(), ".budibase");
+if (!import_fs.default.existsSync(bbTmp)) {
+  import_fs.default.mkdirSync(bbTmp);
+}
+function budibaseTempDir() {
+  return bbTmp;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ObjectStoreBuckets,
+  budibaseTempDir
+});
+//# sourceMappingURL=utils.js.map

package/dist/src/objectStore/utils.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/objectStore/utils.ts"],
+  "sourcesContent": ["import { join } from \"path\"\nimport { tmpdir } from \"os\"\nimport fs from \"fs\"\nimport env from \"../environment\"\n\n/****************************************************\n *      NOTE: When adding a new bucket - name       *\n *     sure that S3 usages (like budibase-infra)    *\n *  have been updated to have a unique bucket name. *\n ****************************************************/\n// can't be an enum - only numbers can be used for computed types\nexport const ObjectStoreBuckets = {\n  BACKUPS: env.BACKUPS_BUCKET_NAME,\n  APPS: env.APPS_BUCKET_NAME,\n  TEMPLATES: env.TEMPLATES_BUCKET_NAME,\n  GLOBAL: env.GLOBAL_BUCKET_NAME,\n  PLUGINS: env.PLUGIN_BUCKET_NAME,\n}\n\nconst bbTmp = join(tmpdir(), \".budibase\")\nif (!fs.existsSync(bbTmp)) {\n  fs.mkdirSync(bbTmp)\n}\n\nexport function budibaseTempDir() {\n  return bbTmp\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,kBAAqB;AACrB,gBAAuB;AACvB,gBAAe;AACf,yBAAgB;AAQT,MAAM,qBAAqB;AAAA,EAChC,SAAS,mBAAAA,QAAI;AAAA,EACb,MAAM,mBAAAA,QAAI;AAAA,EACV,WAAW,mBAAAA,QAAI;AAAA,EACf,QAAQ,mBAAAA,QAAI;AAAA,EACZ,SAAS,mBAAAA,QAAI;AACf;AAEA,MAAM,YAAQ,sBAAK,kBAAO,GAAG,WAAW;AACxC,IAAI,CAAC,UAAAC,QAAG,WAAW,KAAK,GAAG;AACzB,YAAAA,QAAG,UAAU,KAAK;AACpB;AAEO,SAAS,kBAAkB;AAChC,SAAO;AACT;",
+  "names": ["env", "fs"]
+}