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

package/operations/files/FilesStorageOperations.js

@@ -0,0 +1,345 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FilesStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _table = _interopRequireDefault(require("../../definitions/table"));
+
+var _filesEntity = _interopRequireDefault(require("../../definitions/filesEntity"));
+
+var _query = require("@webiny/db-dynamodb/utils/query");
+
+var _cursor = require("@webiny/db-dynamodb/utils/cursor");
+
+var _filter = require("@webiny/db-dynamodb/utils/filter");
+
+var _sort = require("@webiny/db-dynamodb/utils/sort");
+
+var _FileDynamoDbFieldPlugin = require("../../plugins/FileDynamoDbFieldPlugin");
+
+var _batchWrite = require("@webiny/db-dynamodb/utils/batchWrite");
+
+var _get = require("@webiny/db-dynamodb/utils/get");
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+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; }
+
+class FilesStorageOperations {
+  get context() {
+    return this._context;
+  }
+
+  constructor({
+    context
+  }) {
+    (0, _defineProperty2.default)(this, "_context", void 0);
+    (0, _defineProperty2.default)(this, "table", void 0);
+    (0, _defineProperty2.default)(this, "entity", void 0);
+    this._context = context;
+    this.table = (0, _table.default)({
+      context
+    });
+    this.entity = (0, _filesEntity.default)({
+      context,
+      table: this.table
+    });
+  }
+
+  async get(params) {
+    const {
+      where
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(where),
+      SK: this.createSortKey(where)
+    };
+
+    try {
+      const file = await (0, _get.get)({
+        entity: this.entity,
+        keys
+      });
+      return (0, _cleanup.cleanupItem)(this.entity, file);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not fetch requested file.", ex.code || "GET_FILE_ERROR", {
+        error: ex,
+        where
+      });
+    }
+  }
+
+  async create(params) {
+    const {
+      file
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(file),
+      SK: this.createSortKey(file)
+    };
+
+    const item = _objectSpread(_objectSpread(_objectSpread({}, file), keys), {}, {
+      TYPE: "fm.file"
+    });
+
+    try {
+      await this.entity.put(item);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create a new file in the DynamoDB.", ex.code || "CREATE_FILE_ERROR", {
+        error: ex,
+        item
+      });
+    }
+
+    return file;
+  }
+
+  async update(params) {
+    const {
+      file
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(file),
+      SK: this.createSortKey(file)
+    };
+
+    const item = _objectSpread(_objectSpread(_objectSpread({}, file), keys), {}, {
+      TYPE: "fm.file"
+    });
+
+    try {
+      await this.entity.put(item);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update a file in the DynamoDB.", ex.code || "UPDATE_FILE_ERROR", {
+        error: ex,
+        item
+      });
+    }
+
+    return file;
+  }
+
+  async delete(params) {
+    const {
+      file
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(file),
+      SK: this.createSortKey(file)
+    };
+
+    try {
+      await this.entity.delete(keys);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete file from the DynamoDB.", ex.code || "DELETE_FILE_ERROR", {
+        error: ex,
+        file,
+        keys
+      });
+    }
+  }
+
+  async createBatch(params) {
+    const {
+      files
+    } = params;
+    const items = files.map(file => {
+      return this.entity.putBatch(_objectSpread(_objectSpread({}, file), {}, {
+        PK: this.createPartitionKey(file),
+        SK: this.createSortKey(file),
+        TYPE: "fm.file"
+      }));
+    });
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table: this.entity.table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not batch insert a list of files.", ex.code || "BATCH_CREATE_FILES_ERROR", {
+        error: ex,
+        files
+      });
+    }
+
+    return files;
+  }
+
+  async list(params) {
+    const {
+      where: initialWhere,
+      limit,
+      after,
+      sort
+    } = params;
+    const options = this.createQueryAllOptions({
+      where: initialWhere
+    });
+    const queryAllParams = {
+      entity: this.entity,
+      partitionKey: this.createPartitionKey(initialWhere),
+      options
+    };
+    let items = [];
+
+    try {
+      items = await (0, _query.queryAll)(queryAllParams);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not query for the files.", ex.code || "FILE_LIST_ERROR", {
+        error: ex,
+        where: initialWhere,
+        limit,
+        after,
+        sort,
+        queryParams: {
+          options,
+          partitionKey: queryAllParams.partitionKey,
+          entity: queryAllParams.entity.name,
+          table: queryAllParams.entity.table.name
+        }
+      });
+    }
+
+    const where = _objectSpread({}, initialWhere);
+
+    if (where.search) {
+      where.contains = {
+        fields: ["name", "tags"],
+        value: where.search
+      };
+    }
+
+    delete where["tenant"];
+    delete where["locale"];
+    delete where["search"];
+    const fields = this.context.plugins.byType(_FileDynamoDbFieldPlugin.FileDynamoDbFieldPlugin.type);
+    /**
+     * Filter the read items via the code.
+     * It will build the filters out of the where input and transform the values it is using.
+     */
+
+    const filteredFiles = (0, _filter.filterItems)({
+      plugins: this.context.plugins,
+      items,
+      where,
+      fields
+    });
+    const totalCount = filteredFiles.length;
+    /**
+     * Sorting is also done via the code.
+     * It takes the sort input and sorts by it via the lodash sortBy method.
+     */
+
+    const sortedFiles = (0, _sort.sortItems)({
+      items: filteredFiles,
+      sort,
+      fields
+    });
+    const start = (0, _cursor.decodeCursor)(after) || 0;
+    const hasMoreItems = totalCount > start + limit;
+    const end = limit > totalCount + start + limit ? undefined : start + limit;
+    const files = sortedFiles.slice(start, end);
+    /**
+     * Although we do not need a cursor here, we will use it as such to keep it standardized.
+     * Number is simply encoded.
+     */
+
+    const cursor = files.length > 0 ? (0, _cursor.encodeCursor)(start + limit) : null;
+    const meta = {
+      hasMoreItems,
+      totalCount: totalCount,
+      cursor
+    };
+    return [files, meta];
+  }
+
+  async tags(params) {
+    const {
+      where
+    } = params;
+    const queryAllParams = {
+      entity: this.entity,
+      partitionKey: this.createPartitionKey(where),
+      options: {
+        gte: " ",
+        reverse: false
+      }
+    };
+    let results = [];
+
+    try {
+      results = await (0, _query.queryAll)(queryAllParams);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Error in the DynamoDB query.", ex.code || "DYNAMODB_ERROR", {
+        error: ex,
+        query: queryAllParams
+      });
+    }
+    /**
+     * Aggregate all the tags from all the items in the database.
+     */
+
+
+    const tagsObject = results.reduce((collection, item) => {
+      for (const tag of item.tags) {
+        if (!collection[tag]) {
+          collection[tag] = [];
+        }
+
+        collection[tag].push(item.id);
+      }
+
+      return collection;
+    }, {});
+    const tags = Object.keys(tagsObject);
+    const hasMoreItems = false;
+    const totalCount = tags.length;
+    const meta = {
+      hasMoreItems,
+      totalCount,
+      cursor: null
+    };
+    return [tags, meta];
+  }
+
+  createQueryAllOptions({
+    where
+  }) {
+    const options = {};
+
+    if (where.id) {
+      options.eq = where.id;
+    }
+
+    return options;
+  }
+
+  createPartitionKey(params) {
+    const {
+      tenant,
+      locale
+    } = params;
+    return `T#${tenant}#L#${locale}#FM#F`;
+  }
+
+  createSortKey(params) {
+    const {
+      id
+    } = params;
+    return id;
+  }
+
+}
+
+exports.FilesStorageOperations = FilesStorageOperations;

package/operations/files/fields.d.ts

@@ -0,0 +1,3 @@
+import { FileDynamoDbFieldPlugin } from "../../plugins/FileDynamoDbFieldPlugin";
+declare const _default: () => FileDynamoDbFieldPlugin[];
+export default _default;

package/operations/files/fields.js

@@ -0,0 +1,42 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _FileDynamoDbFieldPlugin = require("../../plugins/FileDynamoDbFieldPlugin");
+
+var _default = () => [new _FileDynamoDbFieldPlugin.FileDynamoDbFieldPlugin({
+  field: "id"
+}),
+/**
+ * Path plugin for the field that are ddb map type and the value filtered by is the id property in the object.
+ */
+new _FileDynamoDbFieldPlugin.FileDynamoDbFieldPlugin({
+  field: "createdBy",
+  path: "createdBy.id"
+}),
+/**
+ * Path plugin for meta field properties.
+ */
+new _FileDynamoDbFieldPlugin.FileDynamoDbFieldPlugin({
+  field: "private",
+  path: "meta.private"
+}),
+/**
+ * Path plugin for tag field.
+ */
+new _FileDynamoDbFieldPlugin.FileDynamoDbFieldPlugin({
+  field: "tag",
+  path: "tags"
+}),
+/**
+ * Value transformation for the dateTime field.
+ */
+new _FileDynamoDbFieldPlugin.FileDynamoDbFieldPlugin({
+  field: "createdOn",
+  type: "date"
+})];
+
+exports.default = _default;

package/operations/files/index.d.ts

@@ -0,0 +1,6 @@
+import { FilesStorageOperationsProviderPlugin, Params } from "@webiny/api-file-manager/plugins/definitions/FilesStorageOperationsProviderPlugin";
+import { FilesStorageOperations } from "./FilesStorageOperations";
+export declare class FilesStorageOperationsProviderDdb extends FilesStorageOperationsProviderPlugin {
+    name: string;
+    provide({ context }: Params): Promise<FilesStorageOperations>;
+}

package/operations/files/index.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FilesStorageOperationsProviderDdb = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _FilesStorageOperationsProviderPlugin = require("@webiny/api-file-manager/plugins/definitions/FilesStorageOperationsProviderPlugin");
+
+var _FilesStorageOperations = require("./FilesStorageOperations");
+
+var _fields = _interopRequireDefault(require("./fields"));
+
+class FilesStorageOperationsProviderDdb extends _FilesStorageOperationsProviderPlugin.FilesStorageOperationsProviderPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "fm.storageOperationsProvider.files.ddb");
+  }
+
+  async provide({
+    context
+  }) {
+    context.plugins.register((0, _fields.default)());
+    return new _FilesStorageOperations.FilesStorageOperations({
+      context
+    });
+  }
+
+}
+
+exports.FilesStorageOperationsProviderDdb = FilesStorageOperationsProviderDdb;

package/operations/settings/SettingsStorageOperations.d.ts

@@ -0,0 +1,15 @@
+import { FileManagerContext, FileManagerSettings, FileManagerSettingsStorageOperations, FileManagerSettingsStorageOperationsCreateParams, FileManagerSettingsStorageOperationsUpdateParams } from "@webiny/api-file-manager/types";
+interface ConstructorParams {
+    context: FileManagerContext;
+}
+export declare class SettingsStorageOperations implements FileManagerSettingsStorageOperations {
+    private readonly _context;
+    private readonly _entity;
+    private get partitionKey();
+    constructor({ context }: ConstructorParams);
+    get(): Promise<FileManagerSettings>;
+    create({ data }: FileManagerSettingsStorageOperationsCreateParams): Promise<FileManagerSettings>;
+    update({ data }: FileManagerSettingsStorageOperationsUpdateParams): Promise<FileManagerSettings>;
+    delete(): Promise<void>;
+}
+export {};

package/operations/settings/SettingsStorageOperations.js

@@ -0,0 +1,120 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SettingsStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _table = _interopRequireDefault(require("../../definitions/table"));
+
+var _settingsEntity = _interopRequireDefault(require("../../definitions/settingsEntity"));
+
+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 SORT_KEY = "default";
+
+class SettingsStorageOperations {
+  get partitionKey() {
+    const tenant = this._context.tenancy.getCurrentTenant();
+
+    if (!tenant) {
+      throw new _error.default("Tenant missing.", "TENANT_NOT_FOUND");
+    }
+
+    return `T#${tenant.id}#FM#SETTINGS`;
+  }
+
+  constructor({
+    context
+  }) {
+    (0, _defineProperty2.default)(this, "_context", void 0);
+    (0, _defineProperty2.default)(this, "_entity", void 0);
+    this._context = context;
+    const table = (0, _table.default)({
+      context
+    });
+    this._entity = (0, _settingsEntity.default)({
+      context,
+      table
+    });
+  }
+
+  async get() {
+    try {
+      const settings = await this._entity.get({
+        PK: this.partitionKey,
+        SK: SORT_KEY
+      });
+
+      if (!settings || !settings.Item) {
+        return null;
+      }
+
+      return settings.Item;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not fetch the FileManager settings.", ex.code || "GET_SETTINGS_ERROR");
+    }
+  }
+
+  async create({
+    data
+  }) {
+    const original = await this.get();
+    /**
+     * TODO: check if need to throw an error on existing settings
+     */
+
+    if (original) {
+      return await this.update({
+        original,
+        data
+      });
+    }
+
+    try {
+      await this._entity.put(_objectSpread({
+        PK: this.partitionKey,
+        SK: SORT_KEY
+      }, data));
+      return data;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Cannot create FileManager settings.", ex.code || "CREATE_FM_SETTINGS_ERROR", {
+        data
+      });
+    }
+  }
+
+  async update({
+    data
+  }) {
+    try {
+      await this._entity.update(_objectSpread({
+        PK: this.partitionKey,
+        SK: SORT_KEY
+      }, data));
+      return data;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Cannot update FileManager settings.", ex.code || "UPDATE_FM_SETTINGS_ERROR", {
+        data
+      });
+    }
+  }
+
+  async delete() {
+    return this._entity.delete({
+      PK: this.partitionKey,
+      SK: SORT_KEY
+    });
+  }
+
+}
+
+exports.SettingsStorageOperations = SettingsStorageOperations;

package/operations/settings/index.d.ts

@@ -0,0 +1,8 @@
+import { SettingsStorageOperations } from "./SettingsStorageOperations";
+import { SettingsStorageOperationsProviderPlugin } from "@webiny/api-file-manager/plugins/definitions/SettingsStorageOperationsProviderPlugin";
+export declare class SettingsStorageOperationsProviderDdbPlugin extends SettingsStorageOperationsProviderPlugin {
+    name: string;
+    provide({ context }: {
+        context: any;
+    }): Promise<SettingsStorageOperations>;
+}

package/operations/settings/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SettingsStorageOperationsProviderDdbPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _SettingsStorageOperations = require("./SettingsStorageOperations");
+
+var _SettingsStorageOperationsProviderPlugin = require("@webiny/api-file-manager/plugins/definitions/SettingsStorageOperationsProviderPlugin");
+
+class SettingsStorageOperationsProviderDdbPlugin extends _SettingsStorageOperationsProviderPlugin.SettingsStorageOperationsProviderPlugin {
+  constructor(...args) {
+    super(...args);
+    (0, _defineProperty2.default)(this, "name", "fm.storageOperationsProvider.settings.ddb");
+  }
+
+  async provide({
+    context
+  }) {
+    return new _SettingsStorageOperations.SettingsStorageOperations({
+      context
+    });
+  }
+
+}
+
+exports.SettingsStorageOperationsProviderDdbPlugin = SettingsStorageOperationsProviderDdbPlugin;

package/operations/system/SystemStorageOperations.d.ts

@@ -0,0 +1,14 @@
+import { FileManagerContext, FileManagerSystem, FileManagerSystemStorageOperations, FileManagerSystemStorageOperationsCreateParams, FileManagerSystemStorageOperationsUpdateParams } from "@webiny/api-file-manager/types";
+interface ConstructorParams {
+    context: FileManagerContext;
+}
+export declare class SystemStorageOperations implements FileManagerSystemStorageOperations {
+    private readonly _context;
+    private readonly _entity;
+    private get partitionKey();
+    constructor({ context }: ConstructorParams);
+    get(): Promise<FileManagerSystem | null>;
+    create(params: FileManagerSystemStorageOperationsCreateParams): Promise<FileManagerSystem>;
+    update(params: FileManagerSystemStorageOperationsUpdateParams): Promise<FileManagerSystem>;
+}
+export {};