@webiny/api-headless-cms-ddb 0.0.0-mt-1

package/operations/entry/dataLoaders.js

@@ -0,0 +1,303 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DataLoadersHandler = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _dataloader = _interopRequireDefault(require("dataloader"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _query = require("@webiny/db-dynamodb/utils/query");
+
+var _keys = require("./keys");
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _utils = require("@webiny/utils");
+
+var _batchRead = require("@webiny/db-dynamodb/utils/batchRead");
+
+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 getAllEntryRevisions = params => {
+  const {
+    entity,
+    model
+  } = params;
+  const {
+    tenant,
+    locale
+  } = model;
+  return new _dataloader.default(async ids => {
+    const results = [];
+
+    for (const id of ids) {
+      const queryAllParams = {
+        entity,
+        partitionKey: (0, _keys.createPartitionKey)({
+          tenant,
+          locale,
+          id
+        }),
+        options: {
+          beginsWith: "REV#"
+        }
+      };
+      const items = await (0, _query.queryAll)(queryAllParams);
+      const entries = (0, _cleanup.cleanupItems)(entity, items);
+      results.push(entries);
+    }
+
+    return results;
+  });
+};
+
+const getRevisionById = params => {
+  const {
+    entity,
+    model
+  } = params;
+  const {
+    locale,
+    tenant
+  } = model;
+  return new _dataloader.default(async ids => {
+    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] = entity.getBatch({
+        PK: partitionKey,
+        SK: sortKey
+      });
+      return collection;
+    }, {});
+    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 => {
+        return id === item.id;
+      });
+    });
+  });
+};
+
+const getPublishedRevisionByEntryId = params => {
+  const {
+    entity,
+    model
+  } = params;
+  const {
+    locale,
+    tenant
+  } = model;
+  const publishedKey = (0, _keys.createPublishedSortKey)();
+  return new _dataloader.default(async ids => {
+    const queries = ids.reduce((collection, id) => {
+      const partitionKey = (0, _keys.createPartitionKey)({
+        tenant,
+        locale,
+        id
+      });
+
+      if (collection[partitionKey]) {
+        return collection;
+      }
+
+      collection[partitionKey] = entity.getBatch({
+        PK: partitionKey,
+        SK: publishedKey
+      });
+      return collection;
+    }, {});
+    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 => {
+        return entryId === item.entryId;
+      });
+    });
+  });
+};
+
+const getLatestRevisionByEntryId = params => {
+  const {
+    entity,
+    model
+  } = params;
+  const {
+    locale,
+    tenant
+  } = model;
+  const latestKey = (0, _keys.createLatestSortKey)();
+  return new _dataloader.default(async ids => {
+    const queries = ids.reduce((collection, id) => {
+      const partitionKey = (0, _keys.createPartitionKey)({
+        tenant,
+        locale,
+        id
+      });
+
+      if (collection[partitionKey]) {
+        return collection;
+      }
+
+      collection[partitionKey] = entity.getBatch({
+        PK: partitionKey,
+        SK: latestKey
+      });
+      return collection;
+    }, {});
+    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 => {
+        return entryId === item.entryId;
+      });
+    });
+  });
+};
+
+const dataLoaders = {
+  getAllEntryRevisions,
+  getRevisionById,
+  getPublishedRevisionByEntryId,
+  getLatestRevisionByEntryId
+};
+const loaderNames = Object.keys(dataLoaders);
+
+class DataLoadersHandler {
+  constructor(params) {
+    (0, _defineProperty2.default)(this, "loaders", new Map());
+    (0, _defineProperty2.default)(this, "entity", void 0);
+    this.entity = params.entity;
+  }
+
+  async getAllEntryRevisions(params) {
+    return await this.loadMany("getAllEntryRevisions", params, params.ids);
+  }
+
+  async getRevisionById(params) {
+    return await this.loadMany("getRevisionById", params, params.ids);
+  }
+
+  async getPublishedRevisionByEntryId(params) {
+    return await this.loadMany("getPublishedRevisionByEntryId", params, params.ids);
+  }
+
+  async getLatestRevisionByEntryId(params) {
+    return await this.loadMany("getLatestRevisionByEntryId", params, params.ids);
+  }
+
+  getLoader(name, params) {
+    if (!dataLoaders[name]) {
+      throw new _error.default("Unknown data loader.", "UNKNOWN_DATA_LOADER", {
+        name
+      });
+    }
+
+    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);
+  }
+
+  async loadMany(loader, params, ids) {
+    let results;
+
+    try {
+      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 && 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.", "DATA_LOADER_RESULTS_ERROR", _objectSpread(_objectSpread({}, params), {}, {
+              loader
+            }));
+          }
+
+          acc.push(...res);
+          return acc;
+        }, []);
+      }
+    } catch (ex) {
+      throw new _error.default(ex.message || "Data loader error.", ex.code || "DATA_LOADER_ERROR", _objectSpread(_objectSpread({
+        error: ex
+      }, params), {}, {
+        loader,
+        ids
+      }));
+    }
+
+    throw new _error.default(`Data loader did not return array of items or empty array.`, "INVALID_DATA_LOADER_RESULT", {
+      loader,
+      ids,
+      results
+    });
+  }
+
+  clearAll(params) {
+    for (const name of loaderNames) {
+      const loader = this.getLoader(name, params);
+      loader.clearAll();
+    }
+  }
+
+}
+
+exports.DataLoadersHandler = DataLoadersHandler;

package/operations/entry/index.d.ts

@@ -0,0 +1,8 @@
+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;