@webiny/app-record-locking 6.0.0-beta.0 → 6.0.0-rc.1

package/domain/RecordLocking.js

@@ -1,378 +1,320 @@
-"use strict";
-
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.createRecordLocking = void 0;
-var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
-var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
-var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
-var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
-var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _RecordLockingGetLockRecord = require("./RecordLockingGetLockRecord");
-var _RecordLockingIsEntryLocked = require("./RecordLockingIsEntryLocked");
-var _RecordLockingListLockRecords = require("./RecordLockingListLockRecords");
-var _RecordLockingLockEntry = require("./RecordLockingLockEntry");
-var _RecordLockingUnlockEntry = require("./RecordLockingUnlockEntry");
-var _RecordLockingUnlockEntryRequest = require("./RecordLockingUnlockEntryRequest");
-var _RecordLockingClient = require("./RecordLockingClient");
-var _createRecordLockingError = require("./utils/createRecordLockingError");
-var _parseIdentifier9 = require("@webiny/utils/parseIdentifier");
-var _createCacheKey = require("../utils/createCacheKey");
-var _RecordLockingUpdateEntryLock = require("./RecordLockingUpdateEntryLock");
-var _RecordLockingGetLockedEntryLockRecord = require("./RecordLockingGetLockedEntryLockRecord");
-var RecordLocking = /*#__PURE__*/function () {
-  function RecordLocking(params) {
-    (0, _classCallCheck2.default)(this, RecordLocking);
-    (0, _defineProperty2.default)(this, "loading", false);
-    (0, _defineProperty2.default)(this, "records", []);
-    (0, _defineProperty2.default)(this, "onErrorCb", null);
-    this.client = params.client;
+import { RecordLockingGetLockRecord } from "./RecordLockingGetLockRecord.js";
+import { RecordLockingIsEntryLocked } from "./RecordLockingIsEntryLocked.js";
+import { RecordLockingListLockRecords } from "./RecordLockingListLockRecords.js";
+import { RecordLockingLockEntry } from "./RecordLockingLockEntry.js";
+import { RecordLockingUnlockEntry } from "./RecordLockingUnlockEntry.js";
+import { RecordLockingClient } from "./RecordLockingClient.js";
+import { createRecordLockingError } from "./utils/createRecordLockingError.js";
+import { parseIdentifier } from "@webiny/utils/parseIdentifier.js";
+import { createCacheKey } from "../utils/createCacheKey.js";
+import { RecordLockingUpdateEntryLock } from "./RecordLockingUpdateEntryLock.js";
+import { RecordLockingGetLockedEntryLockRecord } from "./RecordLockingGetLockedEntryLockRecord.js";
+class RecordLocking {
+  loading = false;
+  records = [];
+  onErrorCb = null;
+  constructor(params) {
     this._setLoading = params.setLoading;
     this._getLockRecord = params.getLockRecord;
     this._getLockedEntryLockRecord = params.getLockedEntryLockRecord;
-    this._isEntryLocked = params.isEntryLocked;
     this._listLockRecords = params.listLockRecords;
-    this._lockEntry = params.lockEntry;
     this._unlockEntry = params.unlockEntry;
-    this._unlockEntryRequest = params.unlockEntryRequest;
     this._updateEntryLock = params.updateEntryLock;
   }
-  return (0, _createClass2.default)(RecordLocking, [{
-    key: "setRecords",
-    value: async function setRecords(folderId, type, records) {
-      var result = await this.fetchAndAssignRecords(folderId, type, records);
-      if (!result) {
-        return undefined;
-      }
-      return result.map(function (record) {
-        var _parseIdentifier = (0, _parseIdentifier9.parseIdentifier)(record.id),
-          entryId = _parseIdentifier.id;
-        return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, record), {}, {
-          $lockingType: type,
-          $locked: record.$locked,
-          $selectable: record.$locked ? false : record.$selectable,
-          entryId: entryId
-        });
-      });
+  async setRecords(folderId, type, records) {
+    const result = await this.fetchAndAssignRecords(folderId, type, records);
+    if (!result) {
+      return undefined;
     }
-  }, {
-    key: "fetchLockRecord",
-    value: async function fetchLockRecord(params) {
-      var id = params.id,
-        $lockingType = params.$lockingType;
-      var _parseIdentifier2 = (0, _parseIdentifier9.parseIdentifier)(id),
-        entryId = _parseIdentifier2.id;
-      try {
-        var result = await this._getLockRecord.execute({
-          id: entryId,
-          type: $lockingType
-        });
-        return {
-          data: result.data,
-          error: result.error
-        };
-      } catch (ex) {
-        return {
-          data: null,
-          error: ex
-        };
-      }
-    }
-  }, {
-    key: "fetchLockedEntryLockRecord",
-    value: async function fetchLockedEntryLockRecord(params) {
-      var id = params.id,
-        $lockingType = params.$lockingType;
-      var _parseIdentifier3 = (0, _parseIdentifier9.parseIdentifier)(id),
-        entryId = _parseIdentifier3.id;
-      var result = await this._getLockedEntryLockRecord.execute({
+    return result.map(record => {
+      const {
+        id: entryId
+      } = parseIdentifier(record.id);
+      return {
+        ...record,
+        $type: "RECORD",
+        $lockingType: type,
+        $locked: record.$locked,
+        $selectable: record.$locked ? false : record.$selectable,
+        entryId
+      };
+    });
+  }
+  async fetchLockRecord(params) {
+    const {
+      id,
+      $lockingType
+    } = params;
+    const {
+      id: entryId
+    } = parseIdentifier(id);
+    try {
+      const result = await this._getLockRecord.execute({
         id: entryId,
         type: $lockingType
       });
-      return result.data;
+      return {
+        data: result.data,
+        error: result.error
+      };
+    } catch (ex) {
+      return {
+        data: null,
+        error: ex
+      };
     }
-  }, {
-    key: "getLockRecordEntry",
-    value: function getLockRecordEntry(id) {
-      return this.records.find(function (record) {
-        var _parseIdentifier4 = (0, _parseIdentifier9.parseIdentifier)(id),
-          entryId = _parseIdentifier4.id;
-        return record.entryId === entryId;
-      });
+  }
+  async fetchLockedEntryLockRecord(params) {
+    const {
+      id,
+      $lockingType
+    } = params;
+    const {
+      id: entryId
+    } = parseIdentifier(id);
+    const result = await this._getLockedEntryLockRecord.execute({
+      id: entryId,
+      type: $lockingType
+    });
+    return result.data;
+  }
+  getLockRecordEntry(id) {
+    return this.records.find(record => {
+      const {
+        id: entryId
+      } = parseIdentifier(id);
+      return record.entryId === entryId;
+    });
+  }
+  isRecordLocked(record) {
+    const result = this.records.find(r => {
+      const {
+        id: entryId
+      } = parseIdentifier(record.id);
+      return r.entryId === entryId && !!r.$locked && r.$lockingType === record.$lockingType;
+    });
+    if (!result?.$locked?.expiresOn) {
+      return false;
     }
-  }, {
-    key: "isRecordLocked",
-    value: function isRecordLocked(record) {
-      var result = this.records.find(function (r) {
-        var _parseIdentifier5 = (0, _parseIdentifier9.parseIdentifier)(record.id),
-          entryId = _parseIdentifier5.id;
-        return r.entryId === entryId && !!r.$locked && r.$lockingType === record.$lockingType;
+    const isExpired = this.isLockExpired(result.$locked.expiresOn);
+    return !isExpired;
+  }
+  async updateEntryLock(params) {
+    try {
+      return await this._updateEntryLock.execute({
+        id: params.id,
+        type: params.$lockingType
       });
-      if (!result?.$locked?.expiresOn) {
-        return false;
-      }
-      var isExpired = this.isLockExpired(result.$locked.expiresOn);
-      return !isExpired;
+    } catch (ex) {
+      this.triggerOnError(ex);
+      return {
+        data: null,
+        error: ex
+      };
     }
-  }, {
-    key: "updateEntryLock",
-    value: async function updateEntryLock(params) {
-      try {
-        return await this._updateEntryLock.execute({
-          id: params.id,
-          type: params.$lockingType
-        });
-      } catch (ex) {
-        this.triggerOnError(ex);
-        return {
-          data: null,
-          error: ex
-        };
-      }
+  }
+  removeEntryLock(params) {
+    const index = this.records.findIndex(record => {
+      return record.entryId === params.id && record.$lockingType === params.$lockingType;
+    });
+    if (index === -1) {
+      return;
     }
-  }, {
-    key: "removeEntryLock",
-    value: function removeEntryLock(params) {
-      var index = this.records.findIndex(function (record) {
-        return record.entryId === params.id && record.$lockingType === params.$lockingType;
+    this.records[index] = {
+      ...this.records[index],
+      $locked: null,
+      $selectable: true
+    };
+  }
+  async unlockEntry(params, force) {
+    try {
+      const result = await this._unlockEntry.execute({
+        id: params.id,
+        type: params.$lockingType,
+        force
       });
-      if (index === -1) {
-        return;
+      const id = result.data?.id;
+      if (!id) {
+        return result;
       }
-      this.records[index] = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, this.records[index]), {}, {
-        $locked: null,
-        $selectable: true
+      this.removeEntryLock({
+        ...params
       });
+      return result;
+    } catch (ex) {
+      this.triggerOnError(ex);
+      return {
+        data: null,
+        error: ex
+      };
     }
-  }, {
-    key: "unlockEntry",
-    value: async function unlockEntry(params, force) {
-      try {
-        var result = await this._unlockEntry.execute({
-          id: params.id,
-          type: params.$lockingType,
-          force: force
-        });
-        var id = result.data?.id;
-        if (!id) {
-          return result;
-        }
-        var index = this.records.findIndex(function (r) {
-          return r.entryId === id;
-        });
-        if (index === -1) {
-          return result;
-        }
-        this.records[index] = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, this.records[index]), {}, {
-          $locked: undefined,
-          $selectable: true
-        });
-        return result;
-      } catch (ex) {
-        this.triggerOnError(ex);
-        return {
-          data: null,
-          error: ex
-        };
-      }
+  }
+  onError(cb) {
+    this.onErrorCb = cb;
+  }
+  triggerOnError(error) {
+    this.setIsLoading(false);
+    if (!this.onErrorCb) {
+      return;
     }
-  }, {
-    key: "onError",
-    value: function onError(cb) {
-      this.onErrorCb = cb;
+    this.onErrorCb(error);
+  }
+  isLockExpired(input) {
+    const expiresOn = new Date(input);
+    return expiresOn <= new Date();
+  }
+  setIsLoading(loading) {
+    this._setLoading(loading);
+    this.loading = loading;
+  }
+  async fetchAndAssignRecords(folderId, type, records) {
+    if (records.length === 0) {
+      return;
+    } else if (this.loading) {
+      return;
     }
-  }, {
-    key: "triggerOnError",
-    value: function triggerOnError(error) {
-      this.setIsLoading(false);
-      if (!this.onErrorCb) {
-        return;
-      }
-      this.onErrorCb(error);
+    const assignedIdList = await this.assignRecords(folderId, type, records);
+    if (assignedIdList.length === 0) {
+      return;
     }
-  }, {
-    key: "isLockExpired",
-    value: function isLockExpired(input) {
-      var expiresOn = new Date(input);
-      return expiresOn <= new Date();
+    this.setIsLoading(true);
+    let result;
+    try {
+      result = await this._listLockRecords.execute({
+        where: {
+          id_in: assignedIdList,
+          type
+        },
+        limit: 10000
+      });
+    } catch (ex) {
+      console.error(ex);
+      this.triggerOnError(ex);
+      return;
+    } finally {
+      this.setIsLoading(false);
     }
-  }, {
-    key: "setIsLoading",
-    value: function setIsLoading(loading) {
-      this._setLoading(loading);
-      this.loading = loading;
+    if (result.error) {
+      this.triggerOnError(result.error);
+      return;
+    } else if (!result.data) {
+      this.triggerOnError(createRecordLockingError({
+        message: `There is no data in the result and there is no error. Please check the network tab for more info.`,
+        code: "NO_DATA_IN_RESULT"
+      }));
+      return;
+    } else if (result.data.length === 0) {
+      return;
     }
-  }, {
-    key: "fetchAndAssignRecords",
-    value: async function fetchAndAssignRecords(folderId, type, records) {
-      var _this = this;
-      if (records.length === 0) {
-        return;
-      } else if (this.loading) {
-        return;
-      }
-      var assignedIdList = await this.assignRecords(folderId, type, records);
-      if (assignedIdList.length === 0) {
-        return;
-      }
-      this.setIsLoading(true);
-      var result;
-      try {
-        result = await this._listLockRecords.execute({
-          where: {
-            id_in: assignedIdList,
-            type: type
-          },
-          limit: 10000
-        });
-      } catch (ex) {
-        console.error(ex);
-        this.triggerOnError(ex);
-        return;
-      } finally {
-        this.setIsLoading(false);
-      }
-      if (result.error) {
-        this.triggerOnError(result.error);
-        return;
-      } else if (!result.data) {
-        this.triggerOnError((0, _createRecordLockingError.createRecordLockingError)({
-          message: "There is no data in the result and there is no error. Please check the network tab for more info.",
-          code: "NO_DATA_IN_RESULT"
-        }));
-        return;
-      } else if (result.data.length === 0) {
-        return;
+    for (const record of result.data) {
+      const index = this.records.findIndex(r => {
+        const {
+          id: entryId
+        } = parseIdentifier(record.id);
+        return r.entryId === entryId;
+      });
+      if (index < 0) {
+        console.error(`There is no record with id ${record.id} in the records array.`);
+        continue;
       }
-      var _iterator = (0, _createForOfIteratorHelper2.default)(result.data),
-        _step;
-      try {
-        var _loop = async function _loop() {
-          var record = _step.value;
-          var index = _this.records.findIndex(function (r) {
-            var _parseIdentifier6 = (0, _parseIdentifier9.parseIdentifier)(record.id),
-              entryId = _parseIdentifier6.id;
-            return r.entryId === entryId;
-          });
-          if (index < 0) {
-            console.error("There is no record with id ".concat(record.id, " in the records array."));
-            return 1; // continue
-          }
-          _this.records[index] = (0, _objectSpread2.default)((0, _objectSpread2.default)({}, _this.records[index]), {}, {
-            $locked: {
-              lockedBy: record.lockedBy,
-              expiresOn: record.expiresOn,
-              lockedOn: record.lockedOn,
-              actions: record.actions
-            }
-          });
-        };
-        for (_iterator.s(); !(_step = _iterator.n()).done;) {
-          if (await _loop()) continue;
+      this.records[index] = {
+        ...this.records[index],
+        $locked: {
+          lockedBy: record.lockedBy,
+          expiresOn: record.expiresOn,
+          lockedOn: record.lockedOn,
+          actions: record.actions
         }
-      } catch (err) {
-        _iterator.e(err);
-      } finally {
-        _iterator.f();
-      }
-      return this.records;
+      };
     }
+    return this.records;
+  }
+  /**
+   * Assign records and return the assigned ID list.
+   */
+  async assignRecords(folderId, type, records) {
     /**
-     * Assign records and return the assigned ID list.
+     * First we check the record keys against ones in the local cache.
      */
-  }, {
-    key: "assignRecords",
-    value: async function assignRecords(folderId, type, records) {
-      var _this2 = this;
-      /**
-       * First we check the record keys against ones in the local cache.
-       */
-      var keys = records.map(function (record) {
-        if (record.entryId) {
-          return record.entryId;
-        }
-        var _parseIdentifier7 = (0, _parseIdentifier9.parseIdentifier)(record.id),
-          entryId = _parseIdentifier7.id;
-        return entryId;
-      });
-      var cacheKey = await (0, _createCacheKey.createCacheKey)(keys);
-      if (this.currentRecordsCacheKey === cacheKey) {
-        return [];
+    const keys = records.map(record => {
+      if (record.entryId) {
+        return record.entryId;
       }
-      this.currentRecordsCacheKey = cacheKey;
+      const {
+        id: entryId
+      } = parseIdentifier(record.id);
+      return entryId;
+    });
+    const cacheKey = await createCacheKey(keys);
+    if (this.currentRecordsCacheKey === cacheKey) {
+      return [];
+    }
+    this.currentRecordsCacheKey = cacheKey;
 
-      /**
-       * Reset records if new type is not as same as the old type / folderId.
-       */
-      if (this.currentRecordType !== type || this.currentFolderId !== folderId) {
-        this.records = [];
-        this.currentRecordType = type;
-        this.currentFolderId = folderId;
+    /**
+     * Reset records if new type is not as same as the old type / folderId.
+     */
+    if (this.currentRecordType !== type || this.currentFolderId !== folderId) {
+      this.records = [];
+      this.currentRecordType = type;
+      this.currentFolderId = folderId;
+    }
+    return records.reduce((collection, record) => {
+      const {
+        id: entryId
+      } = parseIdentifier(record.id);
+      const index = this.records.findIndex(r => r.entryId === entryId);
+      if (index >= 0) {
+        return collection;
       }
-      return records.reduce(function (collection, record) {
-        var _parseIdentifier8 = (0, _parseIdentifier9.parseIdentifier)(record.id),
-          entryId = _parseIdentifier8.id;
-        var index = _this2.records.findIndex(function (r) {
-          return r.entryId === entryId;
-        });
-        if (index >= 0) {
-          return collection;
-        }
-        _this2.records.push((0, _objectSpread2.default)((0, _objectSpread2.default)({}, record), {}, {
-          entryId: entryId,
-          $lockingType: type,
-          $locked: undefined
-        }));
-        if (record.$type !== "RECORD") {
-          return collection;
-        }
-        collection.push(entryId);
+      this.records.push({
+        ...record,
+        entryId,
+        $lockingType: type,
+        $locked: undefined
+      });
+      if (record.$type !== "RECORD") {
         return collection;
-      }, []);
-    }
-  }]);
-}();
-var createRecordLocking = exports.createRecordLocking = function createRecordLocking(config) {
-  var client = new _RecordLockingClient.RecordLockingClient({
+      }
+      collection.push(entryId);
+      return collection;
+    }, []);
+  }
+}
+export const createRecordLocking = config => {
+  const client = new RecordLockingClient({
     client: config.client
   });
-  var getLockRecord = new _RecordLockingGetLockRecord.RecordLockingGetLockRecord({
-    client: client
-  });
-  var getLockedEntryLockRecord = new _RecordLockingGetLockedEntryLockRecord.RecordLockingGetLockedEntryLockRecord({
-    client: client
+  const getLockRecord = new RecordLockingGetLockRecord({
+    client
   });
-  var isEntryLocked = new _RecordLockingIsEntryLocked.RecordLockingIsEntryLocked({
-    client: client
+  const getLockedEntryLockRecord = new RecordLockingGetLockedEntryLockRecord({
+    client
   });
-  var listLockRecords = new _RecordLockingListLockRecords.RecordLockingListLockRecords({
-    client: client
+  const isEntryLocked = new RecordLockingIsEntryLocked({
+    client
   });
-  var lockEntry = new _RecordLockingLockEntry.RecordLockingLockEntry({
-    client: client
+  const listLockRecords = new RecordLockingListLockRecords({
+    client
   });
-  var unlockEntry = new _RecordLockingUnlockEntry.RecordLockingUnlockEntry({
-    client: client
+  const lockEntry = new RecordLockingLockEntry({
+    client
   });
-  var unlockEntryRequest = new _RecordLockingUnlockEntryRequest.RecordLockingUnlockEntryRequest({
-    client: client
+  const unlockEntry = new RecordLockingUnlockEntry({
+    client
   });
-  var updateEntryLock = new _RecordLockingUpdateEntryLock.RecordLockingUpdateEntryLock({
-    client: client
+  const updateEntryLock = new RecordLockingUpdateEntryLock({
+    client
   });
   return new RecordLocking({
-    client: client,
     setLoading: config.setLoading,
-    getLockRecord: getLockRecord,
-    getLockedEntryLockRecord: getLockedEntryLockRecord,
-    isEntryLocked: isEntryLocked,
-    listLockRecords: listLockRecords,
-    updateEntryLock: updateEntryLock,
-    lockEntry: lockEntry,
-    unlockEntry: unlockEntry,
-    unlockEntryRequest: unlockEntryRequest
+    getLockRecord,
+    getLockedEntryLockRecord,
+    isEntryLocked,
+    listLockRecords,
+    updateEntryLock,
+    lockEntry,
+    unlockEntry
   });
 };