@webiny/api-headless-cms-ddb 5.17.4 → 5.18.0-beta.3

package/operations/entry/dataLoaders.js

@@ -13,146 +13,183 @@ var _dataloader = _interopRequireDefault(require("dataloader"));
 
 var _error = _interopRequireDefault(require("@webiny/error"));
 
-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; }
+var _query = require("@webiny/db-dynamodb/utils/query");
 
-/**
- * *** GLOBAL NOTE ***
- * When records are received from the batch get, we get them in all sorts of order.
- * What we need for DataLoader to work properly we must have id > records order.
- * So in the order IDs got into the DataLoader, its records must go out in the same order / bundle.
- */
-const flatResponses = responses => {
-  const entries = [];
-  const values = Object.values(responses);
-
-  for (const items of values) {
-    entries.push(...items);
-  }
+var _keys = require("./keys");
 
-  return entries;
-};
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
 
-const executeBatchGet = async (storageOperations, batch) => {
-  const items = [];
-  const result = await storageOperations.table.batchGet(batch);
+var _utils = require("@webiny/utils");
 
-  if (!result) {
-    return items;
-  }
+var _batchRead = require("@webiny/db-dynamodb/utils/batchRead");
 
-  if (result.Responses) {
-    items.push(...flatResponses(result.Responses));
-  }
-
-  if (typeof result.next === "function") {
-    let previous = result;
-    let nResult;
-
-    while (nResult = await previous.next()) {
-      items.push(...flatResponses(nResult.Responses));
-      previous = nResult;
-
-      if (!nResult || typeof nResult.next !== "function") {
-        return items;
-      }
-    }
-  }
+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; }
 
-  return items;
-};
+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 getAllEntryRevisions = (context, model, storageOperations) => {
+const getAllEntryRevisions = params => {
+  const {
+    entity,
+    model
+  } = params;
+  const {
+    tenant,
+    locale
+  } = model;
   return new _dataloader.default(async ids => {
-    const promises = ids.map(id => {
-      const partitionKey = storageOperations.getPartitionKey(id);
-      return storageOperations.runQuery({
-        partitionKey,
+    const results = [];
+
+    for (const id of ids) {
+      const queryAllParams = {
+        entity,
+        partitionKey: (0, _keys.createPartitionKey)({
+          tenant,
+          locale,
+          id
+        }),
         options: {
           beginsWith: "REV#"
         }
-      });
-    });
-    return Promise.all(promises);
+      };
+      const items = await (0, _query.queryAll)(queryAllParams);
+      const entries = (0, _cleanup.cleanupItems)(entity, items);
+      results.push(entries);
+    }
+
+    return results;
   });
 };
 
-const getRevisionById = (context, model, storageOperations) => {
+const getRevisionById = params => {
+  const {
+    entity,
+    model
+  } = params;
+  const {
+    locale,
+    tenant
+  } = model;
   return new _dataloader.default(async ids => {
-    const batch = ids.reduce((collection, id) => {
-      const partitionKey = storageOperations.getPartitionKey(id);
-      const sortKey = storageOperations.getSortKeyRevision(id);
+    const queries = ids.reduce((collection, id) => {
+      const partitionKey = (0, _keys.createPartitionKey)({
+        tenant,
+        locale,
+        id
+      });
+      const {
+        version
+      } = (0, _utils.parseIdentifier)(id);
+      const sortKey = (0, _keys.createRevisionSortKey)({
+        version
+      });
       const keys = `${partitionKey}__${sortKey}`;
 
       if (collection[keys]) {
         return collection;
       }
 
-      collection[keys] = storageOperations.entity.getBatch({
+      collection[keys] = entity.getBatch({
         PK: partitionKey,
         SK: sortKey
       });
       return collection;
     }, {});
-    const items = await executeBatchGet(storageOperations, Object.values(batch));
+    const records = await (0, _batchRead.batchReadAll)({
+      table: entity.table,
+      items: Object.values(queries)
+    });
+    const items = (0, _cleanup.cleanupItems)(entity, records);
     return ids.map(id => {
       return items.filter(item => {
-        const partitionKey = storageOperations.getPartitionKey(id);
-        const sortKey = storageOperations.getSortKeyRevision(id);
-        return item.PK === partitionKey && item.SK === sortKey;
+        return id === item.id;
       });
     });
   });
 };
 
-const getPublishedRevisionByEntryId = (context, model, storageOperations) => {
+const getPublishedRevisionByEntryId = params => {
+  const {
+    entity,
+    model
+  } = params;
+  const {
+    locale,
+    tenant
+  } = model;
+  const publishedKey = (0, _keys.createPublishedSortKey)();
   return new _dataloader.default(async ids => {
-    const sortKey = storageOperations.getSortKeyPublished();
-    const batch = ids.reduce((collection, id) => {
-      const partitionKey = storageOperations.getPartitionKey(id);
+    const queries = ids.reduce((collection, id) => {
+      const partitionKey = (0, _keys.createPartitionKey)({
+        tenant,
+        locale,
+        id
+      });
 
       if (collection[partitionKey]) {
         return collection;
       }
 
-      collection[partitionKey] = storageOperations.entity.getBatch({
+      collection[partitionKey] = entity.getBatch({
         PK: partitionKey,
-        SK: sortKey
+        SK: publishedKey
       });
       return collection;
     }, {});
-    const items = await executeBatchGet(storageOperations, Object.values(batch));
+    const records = await (0, _batchRead.batchReadAll)({
+      table: entity.table,
+      items: Object.values(queries)
+    });
+    const items = (0, _cleanup.cleanupItems)(entity, records);
     return ids.map(id => {
+      const {
+        id: entryId
+      } = (0, _utils.parseIdentifier)(id);
       return items.filter(item => {
-        const partitionKey = storageOperations.getPartitionKey(id);
-        return item.PK === partitionKey && item.SK === sortKey;
+        return entryId === item.entryId;
       });
     });
   });
 };
 
-const getLatestRevisionByEntryId = (context, model, storageOperations) => {
+const getLatestRevisionByEntryId = params => {
+  const {
+    entity,
+    model
+  } = params;
+  const {
+    locale,
+    tenant
+  } = model;
+  const latestKey = (0, _keys.createLatestSortKey)();
   return new _dataloader.default(async ids => {
-    const sortKey = storageOperations.getSortKeyLatest();
-    const batch = ids.reduce((collection, id) => {
-      const partitionKey = storageOperations.getPartitionKey(id);
+    const queries = ids.reduce((collection, id) => {
+      const partitionKey = (0, _keys.createPartitionKey)({
+        tenant,
+        locale,
+        id
+      });
 
       if (collection[partitionKey]) {
         return collection;
       }
 
-      collection[partitionKey] = storageOperations.entity.getBatch({
+      collection[partitionKey] = entity.getBatch({
         PK: partitionKey,
-        SK: sortKey
+        SK: latestKey
       });
       return collection;
     }, {});
-    const items = await executeBatchGet(storageOperations, Object.values(batch));
+    const records = await (0, _batchRead.batchReadAll)({
+      table: entity.table,
+      items: Object.values(queries)
+    });
+    const items = (0, _cleanup.cleanupItems)(entity, records);
     return ids.map(id => {
+      const {
+        id: entryId
+      } = (0, _utils.parseIdentifier)(id);
       return items.filter(item => {
-        const partitionKey = storageOperations.getPartitionKey(id);
-        return item.PK === partitionKey && item.SK === sortKey;
+        return entryId === item.entryId;
       });
     });
   });
@@ -164,80 +201,74 @@ const dataLoaders = {
   getPublishedRevisionByEntryId,
   getLatestRevisionByEntryId
 };
+const loaderNames = Object.keys(dataLoaders);
 
 class DataLoadersHandler {
-  constructor(context, storageOperations) {
-    (0, _defineProperty2.default)(this, "_loaders", new Map());
-    (0, _defineProperty2.default)(this, "_context", void 0);
-    (0, _defineProperty2.default)(this, "_storageOperations", void 0);
-    this._context = context;
-    this._storageOperations = storageOperations;
+  constructor(params) {
+    (0, _defineProperty2.default)(this, "loaders", new Map());
+    (0, _defineProperty2.default)(this, "entity", void 0);
+    this.entity = params.entity;
   }
 
-  async getAllEntryRevisions(model, ids) {
-    return await this.loadMany("getAllEntryRevisions", model, ids);
+  async getAllEntryRevisions(params) {
+    return await this.loadMany("getAllEntryRevisions", params, params.ids);
   }
 
-  clearAllEntryRevisions(model, entry) {
-    this.clear("getAllEntryRevisions", model, entry);
+  async getRevisionById(params) {
+    return await this.loadMany("getRevisionById", params, params.ids);
   }
 
-  async getRevisionById(model, ids) {
-    return await this.loadMany("getRevisionById", model, ids);
+  async getPublishedRevisionByEntryId(params) {
+    return await this.loadMany("getPublishedRevisionByEntryId", params, params.ids);
   }
 
-  clearRevisionById(model, entry) {
-    this.clear("getRevisionById", model, entry);
+  async getLatestRevisionByEntryId(params) {
+    return await this.loadMany("getLatestRevisionByEntryId", params, params.ids);
   }
 
-  async getPublishedRevisionByEntryId(model, ids) {
-    return await this.loadMany("getPublishedRevisionByEntryId", model, ids);
-  }
-
-  clearPublishedRevisionByEntryId(model, entry) {
-    this.clear("getPublishedRevisionByEntryId", model, entry);
-  }
-
-  async getLatestRevisionByEntryId(model, ids) {
-    return await this.loadMany("getLatestRevisionByEntryId", model, ids);
-  }
-
-  clearLatestRevisionByEntryId(model, entry) {
-    this.clear("getLatestRevisionByEntryId", model, entry);
-  }
-
-  getLoader(name, model) {
+  getLoader(name, params) {
     if (!dataLoaders[name]) {
       throw new _error.default("Unknown data loader.", "UNKNOWN_DATA_LOADER", {
         name
       });
     }
 
-    const loaderKey = `${name}-${model.modelId}`;
-
-    if (!this._loaders.has(loaderKey)) {
-      this._loaders.set(loaderKey, dataLoaders[name](this._context, model, this._storageOperations));
+    const {
+      model
+    } = params;
+    const {
+      tenant,
+      locale
+    } = model;
+    const loaderKey = `${name}-${tenant}-${locale}-${model.modelId}`;
+
+    if (!this.loaders.has(loaderKey)) {
+      this.loaders.set(loaderKey, dataLoaders[name](_objectSpread(_objectSpread({}, params), {}, {
+        entity: this.entity
+      })));
     }
 
-    return this._loaders.get(loaderKey);
+    return this.loaders.get(loaderKey);
   }
 
-  async loadMany(loader, model, ids) {
+  async loadMany(loader, params, ids) {
     let results;
 
     try {
-      results = await this.getLoader(loader, model).loadMany(ids);
+      results = await this.getLoader(loader, params).loadMany(ids);
 
       if (Array.isArray(results) === true) {
         return results.reduce((acc, res) => {
           if (Array.isArray(res) === false) {
-            if (res !== null && res !== void 0 && res.message) {
+            if (res && res.message) {
               throw new _error.default(res.message, res.code, _objectSpread(_objectSpread({}, res), {}, {
                 data: JSON.stringify(res.data || {})
               }));
             }
 
-            throw new _error.default("Result from the data loader must be an array of arrays which contain requested items.");
+            throw new _error.default("Result from the data loader must be an array of arrays which contain requested items.", "DATA_LOADER_RESULTS_ERROR", _objectSpread(_objectSpread({}, params), {}, {
+              loader
+            }));
           }
 
           acc.push(...res);
@@ -245,12 +276,12 @@ class DataLoadersHandler {
         }, []);
       }
     } catch (ex) {
-      throw new _error.default(ex.message || "Data loader error.", ex.code || "DATA_LOADER_ERROR", {
+      throw new _error.default(ex.message || "Data loader error.", ex.code || "DATA_LOADER_ERROR", _objectSpread(_objectSpread({
+        error: ex
+      }, params), {}, {
         loader,
-        ids,
-        model,
-        data: ex.data || {}
-      });
+        ids
+      }));
     }
 
     throw new _error.default(`Data loader did not return array of items or empty array.`, "INVALID_DATA_LOADER_RESULT", {
@@ -259,25 +290,14 @@ class DataLoadersHandler {
       results
     });
   }
-  /**
-   * Helper to clear the cache for certain data loader.
-   * If entry is passed then clear target key only.
-   */
-
 
-  clear(name, model, entry) {
-    const loader = this.getLoader(name, model);
-
-    if (!entry) {
+  clearAll(params) {
+    for (const name of loaderNames) {
+      const loader = this.getLoader(name, params);
       loader.clearAll();
-      return;
     }
-
-    loader.clear(entry.id);
-    loader.clear(this._storageOperations.getPartitionKey(entry.id));
   }
 
 }
 
-exports.DataLoadersHandler = DataLoadersHandler;
-//# sourceMappingURL=dataLoaders.js.map
+exports.DataLoadersHandler = DataLoadersHandler;

package/operations/entry/index.d.ts

@@ -1,4 +1,8 @@
-import { CmsContentEntryConfiguration } from "./CmsContentEntryDynamo";
-import { CmsContentEntryStorageOperationsProvider } from "@webiny/api-headless-cms/types";
-declare const contentEntryStorageOperationsProvider: (configuration?: CmsContentEntryConfiguration) => CmsContentEntryStorageOperationsProvider;
-export default contentEntryStorageOperationsProvider;
+import { CmsEntryStorageOperations } from "@webiny/api-headless-cms/types";
+import { Entity } from "dynamodb-toolbox";
+import { PluginsContainer } from "@webiny/plugins";
+export interface Params {
+    entity: Entity<any>;
+    plugins: PluginsContainer;
+}
+export declare const createEntriesStorageOperations: (params: Params) => CmsEntryStorageOperations;