@tachybase/module-file 0.23.8

package/dist/server/server.js

@@ -0,0 +1,130 @@
+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 server_exports = {};
+__export(server_exports, {
+  default: () => PluginFileManager,
+  storageTypes: () => import_storages2.default
+});
+module.exports = __toCommonJS(server_exports);
+var import_path = require("path");
+var import_server = require("@tachybase/server");
+var import_actions = __toESM(require("./actions"));
+var import_FileModel = require("./FileModel");
+var import_storages = require("./storages");
+var import_storages2 = __toESM(require("./storages"));
+class PluginFileManager extends import_server.Plugin {
+  storageType() {
+    return "local";
+  }
+  async loadStorages(options) {
+    const repository = this.db.getRepository("storages");
+    const storages = await repository.find({
+      transaction: options == null ? void 0 : options.transaction
+    });
+    const map = /* @__PURE__ */ new Map();
+    for (const storage of storages) {
+      map.set(storage.get("id"), storage.toJSON());
+    }
+    this.db["_fileStorages"] = map;
+  }
+  async install() {
+    const defaultStorageConfig = (0, import_storages.getStorageConfig)(this.storageType());
+    if (defaultStorageConfig) {
+      const Storage = this.db.getCollection("storages");
+      if (await Storage.repository.findOne({
+        filter: {
+          name: defaultStorageConfig.defaults().name
+        }
+      })) {
+        return;
+      }
+      await Storage.repository.create({
+        values: {
+          ...defaultStorageConfig.defaults(),
+          type: this.storageType(),
+          default: true
+        }
+      });
+    }
+  }
+  async beforeLoad() {
+    this.db.registerModels({ FileModel: import_FileModel.FileModel });
+    this.db.on("beforeDefineCollection", (options) => {
+      if (options.template === "file") {
+        options.model = "FileModel";
+      }
+    });
+    this.app.on("afterStart", async () => {
+      await this.loadStorages();
+    });
+  }
+  async load() {
+    await this.importCollections((0, import_path.resolve)(__dirname, "./collections"));
+    const Storage = this.db.getModel("storages");
+    Storage.afterSave(async (m, { transaction }) => {
+      await this.loadStorages({ transaction });
+    });
+    Storage.afterDestroy(async (m, { transaction }) => {
+      await this.loadStorages({ transaction });
+    });
+    this.app.acl.registerSnippet({
+      name: `pm.${this.name}.storages`,
+      actions: ["storages:*"]
+    });
+    this.db.addMigrations({
+      namespace: "file-manager",
+      directory: (0, import_path.resolve)(__dirname, "migrations"),
+      context: {
+        plugin: this
+      }
+    });
+    (0, import_actions.default)(this);
+    this.app.acl.allow("attachments", "upload", "loggedIn");
+    this.app.acl.allow("attachments", "create", "loggedIn");
+    const defaultStorageName = (0, import_storages.getStorageConfig)(this.storageType()).defaults().name;
+    this.app.acl.addFixedParams("storages", "destroy", () => {
+      return {
+        filter: { "name.$ne": defaultStorageName }
+      };
+    });
+    const ownMerger = () => {
+      return {
+        filter: {
+          createdById: "{{ctx.state.currentUser.id}}"
+        }
+      };
+    };
+    this.app.acl.addFixedParams("attachments", "update", ownMerger);
+    this.app.acl.addFixedParams("attachments", "create", ownMerger);
+    this.app.acl.addFixedParams("attachments", "destroy", ownMerger);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  storageTypes
+});

package/dist/server/storages/ali-oss.d.ts

@@ -0,0 +1,18 @@
+import { AttachmentModel } from '.';
+declare const _default: {
+    make(storage: any): any;
+    defaults(): {
+        title: string;
+        type: string;
+        name: string;
+        baseUrl: string;
+        options: {
+            region: string;
+            accessKeyId: string;
+            accessKeySecret: string;
+            bucket: string;
+        };
+    };
+    delete(storage: any, records: AttachmentModel[]): Promise<[number, AttachmentModel[]]>;
+};
+export default _default;

package/dist/server/storages/ali-oss.js

@@ -0,0 +1,55 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var ali_oss_exports = {};
+__export(ali_oss_exports, {
+  default: () => ali_oss_default
+});
+module.exports = __toCommonJS(ali_oss_exports);
+var import_constants = require("../constants");
+var import_utils = require("../utils");
+var ali_oss_default = {
+  make(storage) {
+    const createAliOssStorage = require("multer-aliyun-oss");
+    return new createAliOssStorage({
+      config: storage.options,
+      filename: (0, import_utils.cloudFilenameGetter)(storage)
+    });
+  },
+  defaults() {
+    return {
+      title: "\u963F\u91CC\u4E91\u5BF9\u8C61\u5B58\u50A8",
+      type: import_constants.STORAGE_TYPE_ALI_OSS,
+      name: "ali-oss-1",
+      baseUrl: process.env.ALI_OSS_STORAGE_BASE_URL,
+      options: {
+        region: process.env.ALI_OSS_REGION,
+        accessKeyId: process.env.ALI_OSS_ACCESS_KEY_ID,
+        accessKeySecret: process.env.ALI_OSS_ACCESS_KEY_SECRET,
+        bucket: process.env.ALI_OSS_BUCKET
+      }
+    };
+  },
+  async delete(storage, records) {
+    const { client } = this.make(storage);
+    const { deleted } = await client.deleteMulti(records.map((record) => `${record.path}/${record.filename}`));
+    return [
+      deleted.length,
+      records.filter((record) => !deleted.find((item) => item.Key === `${record.path}/${record.filename}`))
+    ];
+  }
+};

package/dist/server/storages/index.d.ts

@@ -0,0 +1,33 @@
+import Application from '@tachybase/server';
+import { Registry } from '@tachybase/utils';
+import { StorageEngine } from 'multer';
+export interface StorageModel {
+    title: string;
+    type: string;
+    name: string;
+    baseUrl: string;
+    options: {
+        [key: string]: string;
+    };
+    deleteFileOnDestroy?: boolean;
+}
+export interface AttachmentModel {
+    title: string;
+    filename: string;
+    path: string;
+}
+export interface IStorage {
+    filenameKey?: string;
+    middleware?(app: Application): void;
+    getFileData?(file: {
+        [key: string]: any;
+    }): {
+        [key: string]: any;
+    };
+    make(storage: StorageModel): StorageEngine;
+    defaults(): StorageModel;
+    delete(storage: StorageModel, records: AttachmentModel[]): Promise<[number, AttachmentModel[]]>;
+}
+declare const storageTypes: Registry<IStorage>;
+export declare function getStorageConfig(key: string): IStorage;
+export default storageTypes;

package/dist/server/storages/index.js

@@ -0,0 +1,52 @@
+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 storages_exports = {};
+__export(storages_exports, {
+  default: () => storages_default,
+  getStorageConfig: () => getStorageConfig
+});
+module.exports = __toCommonJS(storages_exports);
+var import_utils = require("@tachybase/utils");
+var import_constants = require("../constants");
+var import_ali_oss = __toESM(require("./ali-oss"));
+var import_local = __toESM(require("./local"));
+var import_s3 = __toESM(require("./s3"));
+var import_tx_cos = __toESM(require("./tx-cos"));
+const storageTypes = new import_utils.Registry();
+storageTypes.register(import_constants.STORAGE_TYPE_LOCAL, import_local.default);
+storageTypes.register(import_constants.STORAGE_TYPE_ALI_OSS, import_ali_oss.default);
+storageTypes.register(import_constants.STORAGE_TYPE_S3, import_s3.default);
+storageTypes.register(import_constants.STORAGE_TYPE_TX_COS, import_tx_cos.default);
+function getStorageConfig(key) {
+  return storageTypes.get(key);
+}
+var storages_default = storageTypes;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getStorageConfig
+});

package/dist/server/storages/local.d.ts

@@ -0,0 +1,16 @@
+import multer from 'multer';
+import { AttachmentModel } from '.';
+declare const _default: {
+    make(storage: any): multer.StorageEngine;
+    defaults(): {
+        title: string;
+        type: string;
+        name: string;
+        baseUrl: string;
+        options: {
+            documentRoot: string;
+        };
+    };
+    delete(storage: any, records: AttachmentModel[]): Promise<[number, AttachmentModel[]]>;
+};
+export default _default;

package/dist/server/storages/local.js

@@ -0,0 +1,87 @@
+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 local_exports = {};
+__export(local_exports, {
+  default: () => local_default
+});
+module.exports = __toCommonJS(local_exports);
+var import_promises = __toESM(require("fs/promises"));
+var import_path = __toESM(require("path"));
+var import_mkdirp = __toESM(require("mkdirp"));
+var import_multer = __toESM(require("multer"));
+var import_constants = require("../constants");
+var import_utils = require("../utils");
+function getDocumentRoot(storage) {
+  const { documentRoot = process.env.LOCAL_STORAGE_DEST || "storage/uploads" } = storage.options || {};
+  return import_path.default.resolve(import_path.default.isAbsolute(documentRoot) ? documentRoot : import_path.default.join(process.cwd(), documentRoot));
+}
+var local_default = {
+  make(storage) {
+    return import_multer.default.diskStorage({
+      destination: function(req, file, cb) {
+        const destPath = import_path.default.join(getDocumentRoot(storage), storage.path);
+        (0, import_mkdirp.default)(destPath, (err) => cb(err, destPath));
+      },
+      filename: import_utils.getFilename
+    });
+  },
+  defaults() {
+    return {
+      title: "Local storage",
+      type: import_constants.STORAGE_TYPE_LOCAL,
+      name: `local`,
+      baseUrl: "/storage/uploads",
+      options: {
+        documentRoot: "storage/uploads"
+      }
+    };
+  },
+  async delete(storage, records) {
+    const documentRoot = getDocumentRoot(storage);
+    let count = 0;
+    const undeleted = [];
+    await records.reduce(
+      (promise, record) => promise.then(async () => {
+        try {
+          await import_promises.default.unlink(import_path.default.join(documentRoot, record.path, record.filename));
+          count += 1;
+        } catch (ex) {
+          if (ex.code === "ENOENT") {
+            console.warn(ex.message);
+            count += 1;
+          } else {
+            console.error(ex);
+            undeleted.push(record);
+          }
+        }
+      }),
+      Promise.resolve()
+    );
+    return [count, undeleted];
+  }
+};

package/dist/server/storages/s3.d.ts

@@ -0,0 +1,19 @@
+import { AttachmentModel } from '.';
+declare const _default: {
+    filenameKey: string;
+    make(storage: any): any;
+    defaults(): {
+        title: string;
+        name: string;
+        type: string;
+        baseUrl: string;
+        options: {
+            region: string;
+            accessKeyId: string;
+            secretAccessKey: string;
+            bucket: string;
+        };
+    };
+    delete(storage: any, records: AttachmentModel[]): Promise<[number, AttachmentModel[]]>;
+};
+export default _default;

package/dist/server/storages/s3.js

@@ -0,0 +1,82 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var s3_exports = {};
+__export(s3_exports, {
+  default: () => s3_default
+});
+module.exports = __toCommonJS(s3_exports);
+var import_constants = require("../constants");
+var import_utils = require("../utils");
+var s3_default = {
+  filenameKey: "key",
+  make(storage) {
+    const { S3Client } = require("@aws-sdk/client-s3");
+    const multerS3 = require("multer-s3");
+    const { accessKeyId, secretAccessKey, bucket, acl = "public-read", ...options } = storage.options;
+    const s3 = new S3Client({
+      ...options,
+      credentials: {
+        accessKeyId,
+        secretAccessKey
+      }
+    });
+    return multerS3({
+      s3,
+      bucket,
+      acl,
+      contentType(req, file, cb) {
+        if (file.mimetype) {
+          cb(null, file.mimetype);
+          return;
+        }
+        multerS3.AUTO_CONTENT_TYPE(req, file, cb);
+      },
+      key: (0, import_utils.cloudFilenameGetter)(storage)
+    });
+  },
+  defaults() {
+    return {
+      title: "AWS S3",
+      name: "aws-s3",
+      type: import_constants.STORAGE_TYPE_S3,
+      baseUrl: process.env.AWS_S3_STORAGE_BASE_URL,
+      options: {
+        region: process.env.AWS_S3_REGION,
+        accessKeyId: process.env.AWS_ACCESS_KEY_ID,
+        secretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+        bucket: process.env.AWS_S3_BUCKET
+      }
+    };
+  },
+  async delete(storage, records) {
+    const { DeleteObjectsCommand } = require("@aws-sdk/client-s3");
+    const { s3 } = this.make(storage);
+    const { Deleted } = await s3.send(
+      new DeleteObjectsCommand({
+        Bucket: storage.options.bucket,
+        Delete: {
+          Objects: records.map((record) => ({ Key: `${record.path}/${record.filename}` }))
+        }
+      })
+    );
+    return [
+      Deleted.length,
+      records.filter((record) => !Deleted.find((item) => item.Key === `${record.path}/${record.filename}`))
+    ];
+  }
+};

package/dist/server/storages/tx-cos.d.ts

@@ -0,0 +1,19 @@
+import { AttachmentModel } from '.';
+declare const _default: {
+    filenameKey: string;
+    make(storage: any): any;
+    defaults(): {
+        title: string;
+        type: string;
+        name: string;
+        baseUrl: string;
+        options: {
+            Region: string;
+            SecretId: string;
+            SecretKey: string;
+            Bucket: string;
+        };
+    };
+    delete(storage: any, records: AttachmentModel[]): Promise<[number, AttachmentModel[]]>;
+};
+export default _default;

package/dist/server/storages/tx-cos.js

@@ -0,0 +1,61 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var tx_cos_exports = {};
+__export(tx_cos_exports, {
+  default: () => tx_cos_default
+});
+module.exports = __toCommonJS(tx_cos_exports);
+var import_util = require("util");
+var import_constants = require("../constants");
+var import_utils = require("../utils");
+var tx_cos_default = {
+  filenameKey: "url",
+  make(storage) {
+    const createTxCosStorage = require("multer-cos");
+    return new createTxCosStorage({
+      cos: storage.options,
+      filename: (0, import_utils.cloudFilenameGetter)(storage)
+    });
+  },
+  defaults() {
+    return {
+      title: "\u817E\u8BAF\u4E91\u5BF9\u8C61\u5B58\u50A8",
+      type: import_constants.STORAGE_TYPE_TX_COS,
+      name: "tx-cos-1",
+      baseUrl: process.env.TX_COS_STORAGE_BASE_URL,
+      options: {
+        Region: process.env.TX_COS_REGION,
+        SecretId: process.env.TX_COS_SECRET_ID,
+        SecretKey: process.env.TX_COS_SECRET_KEY,
+        Bucket: process.env.TX_COS_BUCKET
+      }
+    };
+  },
+  async delete(storage, records) {
+    const { cos } = this.make(storage);
+    const { Deleted } = await (0, import_util.promisify)(cos.deleteMultipleObject)({
+      Region: storage.options.Region,
+      Bucket: storage.options.Bucket,
+      Objects: records.map((record) => ({ Key: `${record.path}/${record.filename}` }))
+    });
+    return [
+      Deleted.length,
+      records.filter((record) => !Deleted.find((item) => item.Key === `${record.path}/${record.filename}`))
+    ];
+  }
+};

package/dist/server/utils.d.ts

@@ -0,0 +1,2 @@
+export declare function getFilename(req: any, file: any, cb: any): void;
+export declare const cloudFilenameGetter: (storage: any) => (req: any, file: any, cb: any) => void;

package/dist/server/utils.js

@@ -0,0 +1,53 @@
+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, {
+  cloudFilenameGetter: () => cloudFilenameGetter,
+  getFilename: () => getFilename
+});
+module.exports = __toCommonJS(utils_exports);
+var import_crypto = __toESM(require("crypto"));
+var import_path = __toESM(require("path"));
+function getFilename(req, file, cb) {
+  import_crypto.default.pseudoRandomBytes(16, function(err, raw) {
+    cb(err, err ? void 0 : `${raw.toString("hex")}${import_path.default.extname(file.originalname)}`);
+  });
+}
+const cloudFilenameGetter = (storage) => (req, file, cb) => {
+  getFilename(req, file, (err, filename) => {
+    if (err) {
+      return cb(err);
+    }
+    cb(null, `${storage.path ? `${storage.path}/` : ""}${filename}`);
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  cloudFilenameGetter,
+  getFilename
+});