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

package/plugins/crud/utils/checkBasePermissions.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _apiSecurity = require("@webiny/api-security");
+
+var _default = async (context, check = {}) => {
+  await context.i18nContent.checkI18NContentPermission();
+  const filePermission = await context.security.getPermission("fm.file");
+
+  if (!filePermission) {
+    throw new _apiSecurity.NotAuthorizedError();
+  }
+
+  if (check.rwd && !hasRwd(filePermission, check.rwd)) {
+    throw new _apiSecurity.NotAuthorizedError();
+  }
+
+  return filePermission;
+};
+
+exports.default = _default;
+
+const hasRwd = (filesFilePermission, rwd) => {
+  if (typeof filesFilePermission.rwd !== "string") {
+    return true;
+  }
+
+  return filesFilePermission.rwd.includes(rwd);
+};

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

@@ -0,0 +1,2 @@
+declare const _default: (create?: boolean) => any;
+export default _default;

package/plugins/crud/utils/createFileModel.js

@@ -0,0 +1,64 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _fields = require("@commodo/fields");
+
+var _commodoFieldsObject = require("commodo-fields-object");
+
+var _validation = require("@webiny/validation");
+
+var _default = (create = true) => {
+  return (0, _fields.withFields)({
+    key: (0, _fields.string)({
+      validation: _validation.validation.create(`${create ? "required," : ""}maxLength:1000`)
+    }),
+    name: (0, _fields.string)({
+      validation: _validation.validation.create("maxLength:1000")
+    }),
+    size: (0, _fields.number)(),
+    type: (0, _fields.string)({
+      validation: _validation.validation.create("maxLength:255")
+    }),
+    meta: (0, _commodoFieldsObject.object)({
+      value: {
+        private: false
+      }
+    }),
+    tags: (0, _fields.onSet)(value => {
+      if (!Array.isArray(value)) {
+        return null;
+      }
+
+      return value.map(item => item.toLowerCase());
+    })((0, _fields.string)({
+      list: true,
+      validation: tags => {
+        if (!Array.isArray(tags)) {
+          return;
+        }
+
+        if (tags.length > 15) {
+          throw Error("You cannot set more than 15 tags.");
+        }
+
+        for (let i = 0; i < tags.length; i++) {
+          const tag = tags[i];
+
+          if (typeof tag !== "string") {
+            throw Error("Tag must be typeof string.");
+          }
+
+          if (tag.length > 50) {
+            throw Error(`Tag ${tag} is more than 50 characters long.`);
+          }
+        }
+      }
+    }))
+  })();
+};
+
+exports.default = _default;

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

@@ -0,0 +1,6 @@
+import { FilePlugin } from "../../definitions/FilePlugin";
+import { FileManagerContext } from "../../../types";
+export declare const runLifecycleEvent: (hook: string, params: {
+    context: FileManagerContext;
+    plugins: FilePlugin[];
+} & Record<string, any>) => Promise<void>;

package/plugins/crud/utils/lifecycleEvents.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.runLifecycleEvent = void 0;
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+const _excluded = ["plugins"];
+
+const runLifecycleEvent = async (hook, params) => {
+  const {
+    plugins
+  } = params,
+        rest = (0, _objectWithoutProperties2.default)(params, _excluded);
+
+  if (plugins.length === 0) {
+    return;
+  }
+
+  for (const plugin of plugins) {
+    if (!plugin[hook]) {
+      continue;
+    }
+
+    await plugin[hook](rest);
+  }
+};
+
+exports.runLifecycleEvent = runLifecycleEvent;

package/plugins/definitions/FilePhysicalStoragePlugin.d.ts

@@ -0,0 +1,22 @@
+/// <reference types="node" />
+import { Plugin } from "@webiny/plugins";
+import { FileManagerSettings } from "../../types";
+export interface Params {
+    upload: (args: UploadParams) => Promise<any>;
+    delete: (args: DeleteParams) => Promise<void>;
+}
+export interface UploadParams {
+    settings: FileManagerSettings;
+    buffer: Buffer;
+    [key: string]: any;
+}
+export interface DeleteParams {
+    key: string;
+}
+export declare class FilePhysicalStoragePlugin extends Plugin {
+    static readonly type = "api-file-manager-storage";
+    private readonly _params;
+    constructor(params: Params);
+    upload(params: UploadParams): Promise<any>;
+    delete(params: DeleteParams): Promise<any>;
+}

package/plugins/definitions/FilePhysicalStoragePlugin.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FilePhysicalStoragePlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+class FilePhysicalStoragePlugin extends _plugins.Plugin {
+  constructor(params) {
+    super();
+    (0, _defineProperty2.default)(this, "_params", void 0);
+    this._params = params;
+  }
+
+  async upload(params) {
+    if (!this._params.upload) {
+      throw new _error.default(`You must define the "upload" method of this plugin.`, "UPLOAD_METHOD_ERROR");
+    }
+
+    return this._params.upload(params);
+  }
+
+  async delete(params) {
+    if (!this._params.delete) {
+      throw new _error.default(`You must define the "delete" method of this plugin.`, "DELETE_METHOD_ERROR");
+    }
+
+    return this._params.delete(params);
+  }
+
+}
+
+exports.FilePhysicalStoragePlugin = FilePhysicalStoragePlugin;
+(0, _defineProperty2.default)(FilePhysicalStoragePlugin, "type", "api-file-manager-storage");

package/plugins/definitions/FilePlugin.d.ts

@@ -0,0 +1,133 @@
+import { Plugin } from "@webiny/plugins";
+import { File, FileManagerContext } from "../../types";
+/**
+ * Parameters for beforeCreate lifecycle.
+ */
+export interface BeforeCreateParams {
+    context: FileManagerContext;
+    /**
+     * Data to be inserted into the storage.
+     */
+    data: File;
+}
+/**
+ * Parameters for afterCreate lifecycle.
+ */
+export interface AfterCreateParams {
+    context: FileManagerContext;
+    /**
+     * Data that was inserted into the storage.
+     */
+    data: File;
+    /**
+     * Result of the storage operations create method.
+     * Possibly changed something on the "data".
+     */
+    file: File;
+}
+/**
+ * Parameters for beforeUpdate lifecycle.
+ */
+export interface BeforeUpdateParams {
+    context: FileManagerContext;
+    /**
+     * Original file from the storage.
+     */
+    original: File;
+    /**
+     * Data to be updated to the storage.
+     */
+    data: File;
+}
+/**
+ * Parameters for afterUpdate lifecycle.
+ */
+export interface AfterUpdateParams {
+    context: FileManagerContext;
+    /**
+     * Original file from the storage.
+     */
+    original: File;
+    /**
+     * Data that was updated in the storage.
+     */
+    data: File;
+    /**
+     * Result of the storage operations update method.
+     * Possibly changed something on the "data".
+     */
+    file: File;
+}
+/**
+ * Parameters for beforeBatchCreate lifecycle.
+ */
+export interface BeforeBatchCreateParams {
+    context: FileManagerContext;
+    /**
+     * Files to be inserted into the storage.
+     */
+    data: File[];
+}
+/**
+ * Parameters for afterBatchCreate lifecycle.
+ */
+export interface AfterBatchCreateParams {
+    context: FileManagerContext;
+    /**
+     * Files that were inserted into the storage.
+     */
+    data: File[];
+    /**
+     * Results of the insert.
+     */
+    files: File[];
+}
+/**
+ * Parameters for beforeDelete lifecycle.
+ */
+export interface BeforeDeleteParams {
+    context: FileManagerContext;
+    /**
+     * File to be deleted from the storage.
+     */
+    file: File;
+}
+/**
+ * Parameters for afterDelete lifecycle.
+ */
+export interface AfterDeleteParams {
+    context: FileManagerContext;
+    /**
+     * File that was deleted from the storage.
+     */
+    file: File;
+}
+/**
+ * Definition for the constructor parameters of the FilePlugin.
+ *
+ * @category FilePlugin
+ */
+export interface Params {
+    beforeCreate?: (params: BeforeCreateParams) => Promise<void>;
+    afterCreate?: (params: AfterCreateParams) => Promise<void>;
+    beforeUpdate?: (params: BeforeUpdateParams) => Promise<void>;
+    afterUpdate?: (params: AfterUpdateParams) => Promise<void>;
+    beforeBatchCreate?: (params: BeforeBatchCreateParams) => Promise<void>;
+    afterBatchCreate?: (params: AfterBatchCreateParams) => Promise<void>;
+    beforeDelete?: (params: BeforeDeleteParams) => Promise<void>;
+    afterDelete?: (params: AfterDeleteParams) => Promise<void>;
+}
+export declare class FilePlugin extends Plugin {
+    static readonly type = "fm.file";
+    private readonly _params;
+    constructor(params?: Params);
+    beforeCreate(params: BeforeCreateParams): Promise<void>;
+    afterCreate(params: AfterCreateParams): Promise<void>;
+    beforeUpdate(params: BeforeUpdateParams): Promise<void>;
+    afterUpdate(params: AfterUpdateParams): Promise<void>;
+    beforeBatchCreate(params: BeforeBatchCreateParams): Promise<void>;
+    afterBatchCreate(params: AfterBatchCreateParams): Promise<void>;
+    beforeDelete(params: BeforeDeleteParams): Promise<void>;
+    afterDelete(params: AfterDeleteParams): Promise<void>;
+    private _execute;
+}

package/plugins/definitions/FilePlugin.js

@@ -0,0 +1,64 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FilePlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class FilePlugin extends _plugins.Plugin {
+  constructor(params) {
+    super();
+    (0, _defineProperty2.default)(this, "_params", void 0);
+    this._params = params || {};
+  }
+
+  async beforeCreate(params) {
+    await this._execute("beforeCreate", params);
+  }
+
+  async afterCreate(params) {
+    await this._execute("afterCreate", params);
+  }
+
+  async beforeUpdate(params) {
+    await this._execute("beforeUpdate", params);
+  }
+
+  async afterUpdate(params) {
+    await this._execute("afterUpdate", params);
+  }
+
+  async beforeBatchCreate(params) {
+    await this._execute("beforeBatchCreate", params);
+  }
+
+  async afterBatchCreate(params) {
+    await this._execute("afterBatchCreate", params);
+  }
+
+  async beforeDelete(params) {
+    await this._execute("beforeDelete", params);
+  }
+
+  async afterDelete(params) {
+    await this._execute("afterDelete", params);
+  }
+
+  async _execute(callback, params) {
+    if (typeof this._params[callback] !== "function") {
+      return;
+    }
+
+    await this._params[callback](params);
+  }
+
+}
+
+exports.FilePlugin = FilePlugin;
+(0, _defineProperty2.default)(FilePlugin, "type", "fm.file");

package/plugins/definitions/FileStorageTransformPlugin.d.ts

@@ -0,0 +1,34 @@
+import { Plugin } from "@webiny/plugins";
+import { File } from "../../types";
+export interface ToParams {
+    /**
+     * File that is being sent to the storage operations method.
+     */
+    file: File & Record<string, any>;
+}
+export interface FromParams {
+    /**
+     * File that was fetched from the storage operations method.
+     */
+    file: File & Record<string, any>;
+}
+export interface Params {
+    toStorage?: (params: ToParams) => Promise<File & Record<string, any>>;
+    fromStorage?: (params: FromParams) => Promise<File & Record<string, any>>;
+}
+export declare class FileStorageTransformPlugin extends Plugin {
+    static readonly type = "fm.files.storage.transform";
+    private readonly _params;
+    constructor(params: Params);
+    /**
+     * Transform the file value into something that can be stored.
+     * Be aware that you must return the whole file object.
+     */
+    toStorage(params: ToParams): Promise<File & Record<string, any>>;
+    /**
+     * Transform the file value from the storage type to one required by our system.
+     * Be aware that you must return the whole file object.
+     * This method MUST reverse what ever toStorage method changed on the file object.
+     */
+    fromStorage(params: FromParams): Promise<File & Record<string, any>>;
+}

package/plugins/definitions/FileStorageTransformPlugin.js

@@ -0,0 +1,51 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FileStorageTransformPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class FileStorageTransformPlugin extends _plugins.Plugin {
+  constructor(params) {
+    super();
+    (0, _defineProperty2.default)(this, "_params", void 0);
+    this._params = params;
+  }
+  /**
+   * Transform the file value into something that can be stored.
+   * Be aware that you must return the whole file object.
+   */
+
+
+  async toStorage(params) {
+    if (!this._params.toStorage) {
+      return params.file;
+    }
+
+    return this._params.toStorage(params);
+  }
+  /**
+   * Transform the file value from the storage type to one required by our system.
+   * Be aware that you must return the whole file object.
+   * This method MUST reverse what ever toStorage method changed on the file object.
+   */
+
+
+  async fromStorage(params) {
+    if (!this._params.fromStorage) {
+      return params.file;
+    }
+
+    return this._params.fromStorage(params);
+  }
+
+}
+
+exports.FileStorageTransformPlugin = FileStorageTransformPlugin;
+(0, _defineProperty2.default)(FileStorageTransformPlugin, "type", "fm.files.storage.transform");

package/plugins/definitions/FilesStorageOperationsProviderPlugin.d.ts

@@ -0,0 +1,9 @@
+import { Plugin } from "@webiny/plugins";
+import { FileManagerContext, FileManagerFilesStorageOperations } from "../../types";
+export interface Params {
+    context: FileManagerContext;
+}
+export declare abstract class FilesStorageOperationsProviderPlugin extends Plugin {
+    static readonly type = "fm.storageOperationsProvider.files";
+    abstract provide(params: Params): Promise<FileManagerFilesStorageOperations>;
+}

package/plugins/definitions/FilesStorageOperationsProviderPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FilesStorageOperationsProviderPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class FilesStorageOperationsProviderPlugin extends _plugins.Plugin {}
+
+exports.FilesStorageOperationsProviderPlugin = FilesStorageOperationsProviderPlugin;
+(0, _defineProperty2.default)(FilesStorageOperationsProviderPlugin, "type", "fm.storageOperationsProvider.files");

package/plugins/definitions/InstallationPlugin.d.ts

@@ -0,0 +1,19 @@
+import { FileManagerContext } from "../../types";
+import { Plugin } from "@webiny/plugins";
+export declare type CallbackFunction<TParams> = (params: TParams) => Promise<void>;
+export interface Params {
+    context: FileManagerContext;
+}
+interface Config {
+    beforeInstall?: CallbackFunction<Params>;
+    afterInstall?: CallbackFunction<Params>;
+}
+export declare abstract class InstallationPlugin extends Plugin {
+    static readonly type = "fm.install";
+    private readonly _config;
+    constructor(config?: Partial<Config>);
+    beforeInstall(params: Params): Promise<void>;
+    afterInstall(params: Params): Promise<void>;
+    private _execute;
+}
+export {};

package/plugins/definitions/InstallationPlugin.js

@@ -0,0 +1,40 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.InstallationPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class InstallationPlugin extends _plugins.Plugin {
+  constructor(config) {
+    super();
+    (0, _defineProperty2.default)(this, "_config", void 0);
+    this._config = config || {};
+  }
+
+  async beforeInstall(params) {
+    return this._execute("beforeInstall", params);
+  }
+
+  async afterInstall(params) {
+    return this._execute("afterInstall", params);
+  }
+
+  async _execute(callback, params) {
+    if (typeof this._config[callback] !== "function") {
+      return;
+    }
+
+    return this._config[callback](params);
+  }
+
+}
+
+exports.InstallationPlugin = InstallationPlugin;
+(0, _defineProperty2.default)(InstallationPlugin, "type", "fm.install");

package/plugins/definitions/SettingsStorageOperationsProviderPlugin.d.ts

@@ -0,0 +1,9 @@
+import { Plugin } from "@webiny/plugins";
+import { FileManagerContext, FileManagerSettingsStorageOperations } from "../../types";
+export interface Params {
+    context: FileManagerContext;
+}
+export declare abstract class SettingsStorageOperationsProviderPlugin extends Plugin {
+    static readonly type = "fm.storageOperationsProvider.settings";
+    abstract provide(params: Params): Promise<FileManagerSettingsStorageOperations>;
+}

package/plugins/definitions/SettingsStorageOperationsProviderPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SettingsStorageOperationsProviderPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class SettingsStorageOperationsProviderPlugin extends _plugins.Plugin {}
+
+exports.SettingsStorageOperationsProviderPlugin = SettingsStorageOperationsProviderPlugin;
+(0, _defineProperty2.default)(SettingsStorageOperationsProviderPlugin, "type", "fm.storageOperationsProvider.settings");

package/plugins/definitions/SystemStorageOperationsProviderPlugin.d.ts

@@ -0,0 +1,9 @@
+import { Plugin } from "@webiny/plugins";
+import { FileManagerContext, FileManagerSystemStorageOperations } from "../../types";
+export interface Params {
+    context: FileManagerContext;
+}
+export declare abstract class SystemStorageOperationsProviderPlugin extends Plugin {
+    static readonly type = "fm.storageOperationsProvider.system";
+    abstract provide(params: Params): Promise<FileManagerSystemStorageOperations>;
+}

package/plugins/definitions/SystemStorageOperationsProviderPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SystemStorageOperationsProviderPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class SystemStorageOperationsProviderPlugin extends _plugins.Plugin {}
+
+exports.SystemStorageOperationsProviderPlugin = SystemStorageOperationsProviderPlugin;
+(0, _defineProperty2.default)(SystemStorageOperationsProviderPlugin, "type", "fm.storageOperationsProvider.system");

package/plugins/graphql.d.ts

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