@webiny/api-file-manager 0.0.0-mt-1

package/plugins/crud/files.crud.js

@@ -0,0 +1,427 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _mdbid = _interopRequireDefault(require("mdbid"));
+
+var _handlerGraphql = require("@webiny/handler-graphql");
+
+var _apiSecurity = require("@webiny/api-security");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _checkBasePermissions = _interopRequireDefault(require("./utils/checkBasePermissions"));
+
+var _ContextPlugin = require("@webiny/handler/plugins/ContextPlugin");
+
+var _FilePlugin = require("../definitions/FilePlugin");
+
+var _FilesStorageOperationsProviderPlugin = require("../definitions/FilesStorageOperationsProviderPlugin");
+
+var _lifecycleEvents = require("./utils/lifecycleEvents");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const BATCH_CREATE_MAX_FILES = 20;
+/**
+ * If permission is limited to "own" files only, check that current identity owns the file.
+ */
+
+const checkOwnership = (file, permission, context) => {
+  if ((permission === null || permission === void 0 ? void 0 : permission.own) === true) {
+    const identity = context.security.getIdentity();
+
+    if (file.createdBy.id !== identity.id) {
+      throw new _apiSecurity.NotAuthorizedError();
+    }
+  }
+};
+
+const getLocaleCode = context => {
+  if (!context.i18nContent) {
+    throw new _error.default("Missing i18nContent on the FileManagerContext.", "MISSING_I18N_CONTENT");
+  } else if (!context.i18nContent.locale) {
+    throw new _error.default("Missing i18nContent.locale on the FileManagerContext.", "MISSING_I18N_CONTENT_LOCALE");
+  } else if (!context.i18nContent.locale.code) {
+    throw new _error.default("Missing i18nContent.locale.code on the FileManagerContext.", "MISSING_I18N_CONTENT_LOCALE_CODE");
+  }
+
+  return context.i18nContent.locale.code;
+};
+
+const filesContextCrudPlugin = new _ContextPlugin.ContextPlugin(async context => {
+  const pluginType = _FilesStorageOperationsProviderPlugin.FilesStorageOperationsProviderPlugin.type;
+  const providerPlugin = context.plugins.byType(pluginType).find(() => true);
+
+  if (!providerPlugin) {
+    throw new _error.default(`Missing "${pluginType}" plugin.`, "PLUGIN_NOT_FOUND", {
+      type: pluginType
+    });
+  }
+
+  const storageOperations = await providerPlugin.provide({
+    context
+  });
+
+  if (!context.fileManager) {
+    context.fileManager = {};
+  }
+
+  const filePlugins = context.plugins.byType(_FilePlugin.FilePlugin.type);
+  context.fileManager.files = {
+    async getFile(id) {
+      const permission = await (0, _checkBasePermissions.default)(context, {
+        rwd: "r"
+      });
+      const file = await storageOperations.get({
+        where: {
+          id,
+          tenant: context.tenancy.getCurrentTenant().id,
+          locale: getLocaleCode(context)
+        }
+      });
+
+      if (!file) {
+        throw new _handlerGraphql.NotFoundError(`File with id "${id}" does not exists.`);
+      }
+
+      checkOwnership(file, permission, context);
+      return file;
+    },
+
+    async createFile(input) {
+      await (0, _checkBasePermissions.default)(context, {
+        rwd: "w"
+      });
+      const identity = context.security.getIdentity();
+      const tenant = context.tenancy.getCurrentTenant();
+      const id = (0, _mdbid.default)();
+
+      const file = _objectSpread(_objectSpread({}, input), {}, {
+        id,
+        meta: _objectSpread({
+          private: false
+        }, input.meta || {}),
+        tenant: tenant.id,
+        createdOn: new Date().toISOString(),
+        createdBy: {
+          id: identity.id,
+          displayName: identity.displayName,
+          type: identity.type
+        },
+        locale: getLocaleCode(context),
+        webinyVersion: context.WEBINY_VERSION
+      });
+
+      try {
+        await (0, _lifecycleEvents.runLifecycleEvent)("beforeCreate", {
+          context,
+          plugins: filePlugins,
+          data: file
+        });
+        const result = await storageOperations.create({
+          file
+        });
+        await (0, _lifecycleEvents.runLifecycleEvent)("afterCreate", {
+          context,
+          plugins: filePlugins,
+          data: file,
+          file: result
+        });
+        return result;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not create a file.", ex.code || "CREATE_FILE_ERROR", _objectSpread(_objectSpread({}, ex.data || {}), {}, {
+          file
+        }));
+      }
+    },
+
+    async updateFile(id, input) {
+      const permission = await (0, _checkBasePermissions.default)(context, {
+        rwd: "w"
+      });
+      const original = await storageOperations.get({
+        where: {
+          id,
+          tenant: context.tenancy.getCurrentTenant().id,
+          locale: getLocaleCode(context)
+        }
+      });
+
+      if (!original) {
+        throw new _handlerGraphql.NotFoundError(`File with id "${id}" does not exists.`);
+      }
+
+      checkOwnership(original, permission, context);
+
+      const file = _objectSpread(_objectSpread(_objectSpread({}, original), input), {}, {
+        id: original.id,
+        webinyVersion: context.WEBINY_VERSION
+      });
+
+      try {
+        await (0, _lifecycleEvents.runLifecycleEvent)("beforeUpdate", {
+          context,
+          plugins: filePlugins,
+          original,
+          data: file
+        });
+        const result = await storageOperations.update({
+          original,
+          file
+        });
+        await (0, _lifecycleEvents.runLifecycleEvent)("afterUpdate", {
+          context,
+          plugins: filePlugins,
+          original,
+          data: file,
+          file: result
+        });
+        return result;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not update a file.", ex.code || "UPDATE_FILE_ERROR", _objectSpread(_objectSpread({}, ex.data || {}), {}, {
+          original,
+          file
+        }));
+      }
+    },
+
+    async deleteFile(id) {
+      const permission = await (0, _checkBasePermissions.default)(context, {
+        rwd: "d"
+      });
+      const file = await storageOperations.get({
+        where: {
+          id,
+          tenant: context.tenancy.getCurrentTenant().id,
+          locale: getLocaleCode(context)
+        }
+      });
+
+      if (!file) {
+        throw new _handlerGraphql.NotFoundError(`File with id "${id}" does not exists.`);
+      }
+
+      checkOwnership(file, permission, context);
+
+      try {
+        await (0, _lifecycleEvents.runLifecycleEvent)("beforeDelete", {
+          context,
+          plugins: filePlugins,
+          file
+        });
+        await storageOperations.delete({
+          file
+        });
+        await (0, _lifecycleEvents.runLifecycleEvent)("afterDelete", {
+          context,
+          plugins: filePlugins,
+          file
+        });
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not delete a file.", ex.code || "DELETE_FILE_ERROR", _objectSpread(_objectSpread({}, ex.data || {}), {}, {
+          id,
+          file
+        }));
+      }
+
+      return true;
+    },
+
+    async createFilesInBatch(inputs) {
+      if (!Array.isArray(inputs)) {
+        throw new _error.default(`"data" must be an array.`, "CREATE_FILES_NON_ARRAY");
+      }
+
+      if (inputs.length === 0) {
+        throw new _error.default(`"data" argument must contain at least one file.`, "CREATE_FILES_MIN_FILES");
+      }
+
+      if (inputs.length > BATCH_CREATE_MAX_FILES) {
+        throw new _error.default(`"data" argument must not contain more than ${BATCH_CREATE_MAX_FILES} files.`, "CREATE_FILES_MAX_FILES");
+      }
+
+      await (0, _checkBasePermissions.default)(context, {
+        rwd: "w"
+      });
+      const identity = context.security.getIdentity();
+      const tenant = context.tenancy.getCurrentTenant();
+      const createdBy = {
+        id: identity.id,
+        displayName: identity.displayName,
+        type: identity.type
+      };
+      const files = inputs.map(input => {
+        return _objectSpread(_objectSpread({}, input), {}, {
+          meta: _objectSpread({
+            private: false
+          }, input.meta || {}),
+          id: (0, _mdbid.default)(),
+          tenant: tenant.id,
+          createdOn: new Date().toISOString(),
+          createdBy,
+          locale: getLocaleCode(context),
+          webinyVersion: context.WEBINY_VERSION
+        });
+      });
+
+      try {
+        await (0, _lifecycleEvents.runLifecycleEvent)("beforeBatchCreate", {
+          context,
+          plugins: filePlugins,
+          data: files
+        });
+        const results = await storageOperations.createBatch({
+          files
+        });
+        await (0, _lifecycleEvents.runLifecycleEvent)("afterBatchCreate", {
+          context,
+          plugins: filePlugins,
+          data: files,
+          files: results
+        });
+        return results;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not create a batch of files.", ex.code || "CREATE_FILES_ERROR", _objectSpread(_objectSpread({}, ex.data || {}), {}, {
+          files
+        }));
+      }
+    },
+
+    async listFiles(params = {}) {
+      const permission = await (0, _checkBasePermissions.default)(context, {
+        rwd: "r"
+      });
+      const {
+        limit = 40,
+        search = "",
+        types = [],
+        tags = [],
+        ids = [],
+        after = null,
+        where: initialWhere,
+        sort: initialSort
+      } = params;
+
+      const where = _objectSpread(_objectSpread({}, initialWhere), {}, {
+        private: false,
+        locale: context.i18nContent.getLocale().code,
+        tenant: context.tenancy.getCurrentTenant().id
+      });
+      /**
+       * Always override the createdBy received from the user, if any.
+       */
+
+
+      if (permission.own === true) {
+        const identity = context.security.getIdentity();
+        where.createdBy = identity.id;
+      }
+      /**
+       * We need to map the old GraphQL definition to the new one.
+       * That GQL definition is marked as deprecated.
+       */
+
+      /**
+       * To have standardized where objects across the applications, we transform the types into type_in.
+       */
+
+
+      if (Array.isArray(types) && types.length > 0 && !where.type_in) {
+        where.type_in = types;
+      }
+      /**
+       * We are assigning search to tag and name search.
+       * This should be treated as OR condition in the storage operations.
+       */
+
+
+      if (search && !where.search) {
+        where.search = search;
+      }
+      /**
+       * Same as on types/type_in.
+       */
+
+
+      if (Array.isArray(tags) && tags.length > 0 && !where.tag_in) {
+        where.tag_in = tags.map(tag => tag.toLowerCase());
+      }
+      /**
+       * Same as on types/type_in.
+       */
+
+
+      if (Array.isArray(ids) && ids.length > 0 && !where.id_in) {
+        where.id_in = ids;
+      }
+
+      const sort = Array.isArray(initialSort) && initialSort.length > 0 ? initialSort : ["id_DESC"];
+
+      try {
+        return await storageOperations.list({
+          where,
+          after,
+          limit,
+          sort
+        });
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not list files by given parameters.", ex.code || "FILE_TAG_SEARCH_ERROR", _objectSpread(_objectSpread({}, ex.data || {}), {}, {
+          where,
+          after,
+          limit,
+          sort
+        }));
+      }
+    },
+
+    async listTags({
+      after,
+      limit
+    }) {
+      await (0, _checkBasePermissions.default)(context);
+      const {
+        i18nContent
+      } = context;
+      const where = {
+        tenant: context.tenancy.getCurrentTenant().id,
+        locale: i18nContent.locale.code
+      };
+      const params = {
+        where,
+        limit: limit || 100000,
+        after
+      };
+
+      try {
+        /**
+         * There is a meta object on the second key.
+         * TODO: use when changing GraphQL output of the tags.
+         */
+        const [tags] = await storageOperations.tags(params);
+        /**
+         * just to keep it standardized, sort by the tag ASC
+         */
+
+        return tags.sort();
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not search for tags.", ex.code || "FILE_TAG_SEARCH_ERROR", _objectSpread(_objectSpread({}, ex.data || {}), {}, {
+          params
+        }));
+      }
+    }
+
+  };
+});
+filesContextCrudPlugin.name = "FileManagerFilesCrud";
+var _default = filesContextCrudPlugin;
+exports.default = _default;

package/plugins/crud/settings.crud.d.ts

@@ -0,0 +1,5 @@
+import { FileManagerContext } from "../../types";
+import { ContextPlugin } from "@webiny/handler/plugins/ContextPlugin";
+export declare const SETTINGS_KEY = "file-manager";
+declare const settingsCrudContextPlugin: ContextPlugin<FileManagerContext>;
+export default settingsCrudContextPlugin;

package/plugins/crud/settings.crud.js

@@ -0,0 +1,115 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = exports.SETTINGS_KEY = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _fields = require("@commodo/fields");
+
+var _validation = require("@webiny/validation");
+
+var _SettingsStorageOperationsProviderPlugin = require("../definitions/SettingsStorageOperationsProviderPlugin");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _ContextPlugin = require("@webiny/handler/plugins/ContextPlugin");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const SETTINGS_KEY = "file-manager";
+exports.SETTINGS_KEY = SETTINGS_KEY;
+const CreateDataModel = (0, _fields.withFields)({
+  uploadMinFileSize: (0, _fields.number)({
+    value: 0,
+    validation: _validation.validation.create("gte:0")
+  }),
+  uploadMaxFileSize: (0, _fields.number)({
+    value: 26214401
+  }),
+  srcPrefix: (0, _fields.onSet)(value => {
+    // Make sure srcPrefix always ends with forward slash.
+    if (typeof value === "string") {
+      return value.endsWith("/") ? value : value + "/";
+    }
+
+    return value;
+  })((0, _fields.string)({
+    value: "/files/"
+  }))
+})();
+const UpdateDataModel = (0, _fields.withFields)({
+  uploadMinFileSize: (0, _fields.number)({
+    validation: _validation.validation.create("gte:0")
+  }),
+  uploadMaxFileSize: (0, _fields.number)(),
+  srcPrefix: (0, _fields.onSet)(value => {
+    // Make sure srcPrefix always ends with forward slash.
+    if (typeof value === "string") {
+      return value.endsWith("/") ? value : value + "/";
+    }
+
+    return value;
+  })((0, _fields.string)())
+})();
+const settingsCrudContextPlugin = new _ContextPlugin.ContextPlugin(async context => {
+  const pluginType = _SettingsStorageOperationsProviderPlugin.SettingsStorageOperationsProviderPlugin.type;
+  const providerPlugin = context.plugins.byType(pluginType).find(() => true);
+
+  if (!providerPlugin) {
+    throw new _error.default(`Missing "${pluginType}" plugin.`, "PLUGIN_NOT_FOUND", {
+      type: pluginType
+    });
+  }
+
+  const storageOperations = await providerPlugin.provide({
+    context
+  });
+
+  if (!context.fileManager) {
+    context.fileManager = {};
+  }
+
+  context.fileManager.settings = {
+    async getSettings() {
+      return storageOperations.get();
+    },
+
+    async createSettings(data) {
+      const settings = new CreateDataModel().populate(data);
+      await settings.validate();
+      const settingsData = await settings.toJSON();
+      return storageOperations.create({
+        data: settingsData
+      });
+    },
+
+    async updateSettings(data) {
+      const updatedValue = new UpdateDataModel().populate(data);
+      await updatedValue.validate();
+      const existingSettings = await storageOperations.get();
+      const updatedSettings = await updatedValue.toJSON({
+        onlyDirty: true
+      });
+      return storageOperations.update({
+        original: existingSettings,
+        data: _objectSpread(_objectSpread({}, existingSettings), updatedSettings)
+      });
+    },
+
+    async deleteSettings() {
+      await storageOperations.delete();
+      return true;
+    }
+
+  };
+});
+settingsCrudContextPlugin.name = "FileMangerSettingsCrud";
+var _default = settingsCrudContextPlugin;
+exports.default = _default;

package/plugins/crud/system.crud.d.ts

@@ -0,0 +1,4 @@
+import { FileManagerContext } from "../../types";
+import { ContextPlugin } from "@webiny/handler/plugins/ContextPlugin";
+declare const systemCrudContextPlugin: ContextPlugin<FileManagerContext>;
+export default systemCrudContextPlugin;

package/plugins/crud/system.crud.js

@@ -0,0 +1,145 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _apiSecurity = require("@webiny/api-security");
+
+var _apiUpgrade = require("@webiny/api-upgrade");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _ContextPlugin = require("@webiny/handler/plugins/ContextPlugin");
+
+var _utils = require("../../utils");
+
+var _InstallationPlugin = require("../definitions/InstallationPlugin");
+
+var _SystemStorageOperationsProviderPlugin = require("../definitions/SystemStorageOperationsProviderPlugin");
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const systemCrudContextPlugin = new _ContextPlugin.ContextPlugin(async context => {
+  const pluginType = _SystemStorageOperationsProviderPlugin.SystemStorageOperationsProviderPlugin.type;
+  const providerPlugin = context.plugins.byType(pluginType).find(() => true);
+
+  if (!providerPlugin) {
+    throw new _error.default(`Missing "${pluginType}" plugin.`, "PLUGIN_NOT_FOUND", {
+      type: pluginType
+    });
+  }
+
+  const storageOperations = await providerPlugin.provide({
+    context
+  });
+
+  if (!context.fileManager) {
+    context.fileManager = {};
+  }
+
+  context.fileManager.system = {
+    async getVersion() {
+      const system = await storageOperations.get();
+      return system ? system.version : null;
+    },
+
+    async setVersion(version) {
+      const system = await storageOperations.get();
+
+      if (system) {
+        const data = _objectSpread(_objectSpread({}, system), {}, {
+          version
+        });
+
+        try {
+          await storageOperations.update({
+            original: system,
+            data
+          });
+          return;
+        } catch (ex) {
+          throw new _error.default("Could not update the system data.", "SYSTEM_UPDATE_ERROR", {
+            data
+          });
+        }
+      }
+
+      const data = {
+        version
+      };
+
+      try {
+        await storageOperations.create({
+          data
+        });
+        return;
+      } catch (ex) {
+        throw new _error.default("Could not create the system data.", "SYSTEM_CREATE_ERROR", {
+          data
+        });
+      }
+    },
+
+    async install({
+      srcPrefix
+    }) {
+      const {
+        fileManager
+      } = context;
+      const version = await fileManager.system.getVersion();
+
+      if (version) {
+        throw new _error.default("File Manager is already installed.", "FILES_INSTALL_ABORTED");
+      }
+
+      const data = {};
+
+      if (srcPrefix) {
+        data.srcPrefix = srcPrefix;
+      }
+
+      const installationPlugins = context.plugins.byType(_InstallationPlugin.InstallationPlugin.type);
+      await (0, _utils.executeCallbacks)(installationPlugins, "beforeInstall", {
+        context
+      });
+      await fileManager.settings.createSettings(data);
+      await fileManager.system.setVersion(context.WEBINY_VERSION);
+      await (0, _utils.executeCallbacks)(installationPlugins, "afterInstall", {
+        context
+      });
+      return true;
+    },
+
+    async upgrade(version) {
+      const identity = context.security.getIdentity();
+
+      if (!identity) {
+        throw new _apiSecurity.NotAuthorizedError();
+      }
+
+      const upgradePlugins = context.plugins.byType("api-upgrade").filter(pl => pl.app === "file-manager");
+      const plugin = (0, _apiUpgrade.getApplicablePlugin)({
+        deployedVersion: context.WEBINY_VERSION,
+        installedAppVersion: await this.getVersion(),
+        upgradePlugins,
+        upgradeToVersion: version
+      });
+      await plugin.apply(context); // Store new app version
+
+      await context.fileManager.system.setVersion(version);
+      return true;
+    }
+
+  };
+});
+systemCrudContextPlugin.name = "FileManagerSystemCrud";
+var _default = systemCrudContextPlugin;
+exports.default = _default;

package/plugins/crud/utils/checkBasePermissions.d.ts

@@ -0,0 +1,5 @@
+import { FileManagerContext, FilePermission } from "../../../types";
+declare const _default: (context: FileManagerContext, check?: {
+    rwd?: string;
+}) => Promise<FilePermission>;
+export default _default;