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

package/operations/entry/dataLoaders.js

@@ -13,49 +13,46 @@ var _dataloader = _interopRequireDefault(require("dataloader"));
 
 var _error = _interopRequireDefault(require("@webiny/error"));
 
-var _lodash = _interopRequireDefault(require("lodash.chunk"));
+var _query = require("@webiny/db-dynamodb/utils/query");
 
-var _configurations = _interopRequireDefault(require("../../configurations"));
+var _keys = require("./keys");
 
-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; }
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
 
-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 _utils = require("@webiny/utils");
 
-// Used in functions below. Ensures we are batch getting 100 keys at most.
-const batchLoadKeys = loadChunk => {
-  return new _dataloader.default(async keys => {
-    // DynamoDB allows getting a maximum of 100 items in a single database call.
-    // So, we are creating chunks that consist of a maximum of 100 keys.
-    const keysChunks = (0, _lodash.default)(keys, 100);
-    const promises = [];
-    keysChunks.forEach(chunk => {
-      promises.push(new Promise(resolve => resolve(loadChunk(chunk))));
-    });
-    const entriesChunks = await Promise.all(promises);
-    return entriesChunks.reduce((current, items) => current.concat(items), []);
-  });
-};
+var _batchRead = require("@webiny/db-dynamodb/utils/batchRead");
 
-const flattenResults = results => {
-  return results.reduce((collection, items) => {
-    collection.push(...items);
-    return collection;
-  }, []);
-};
+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 = (context, model, storageOperations) => {
+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 [entries] = await context.db.read(_objectSpread(_objectSpread({}, _configurations.default.db()), {}, {
-        query: {
-          PK: storageOperations.getPartitionKey(id),
-          SK: {
-            $beginsWith: "REV#"
-          }
+      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);
     }
 
@@ -63,93 +60,136 @@ const getAllEntryRevisions = (context, model, storageOperations) => {
   });
 };
 
-const getRevisionById = (context, model, storageOperations) => {
-  return batchLoadKeys(keys => {
-    const queries = keys.reduce((collection, id) => {
-      const partitionKey = storageOperations.getPartitionKey(id);
-      const sortKey = storageOperations.getSortKeyRevision(id);
+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] = _objectSpread(_objectSpread({}, _configurations.default.db()), {}, {
-        query: {
-          PK: storageOperations.getPartitionKey(id),
-          SK: storageOperations.getSortKeyRevision(id)
-        }
+      collection[keys] = entity.getBatch({
+        PK: partitionKey,
+        SK: sortKey
       });
       return collection;
     }, {});
-    return context.db.batch().read(...Object.values(queries)).execute().then(results => results.map(result => result[0])).then(results => {
-      const items = flattenResults(results);
-      return keys.map(id => {
-        return items.filter(item => {
-          const partitionKey = storageOperations.getPartitionKey(id);
-          const sortKey = storageOperations.getSortKeyRevision(id);
-          return item.PK === partitionKey && item.SK === sortKey;
-        });
+    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 = (context, model, storageOperations) => {
-  return batchLoadKeys(keys => {
-    const sortKey = storageOperations.getSortKeyPublished();
-    const queries = keys.reduce((collection, id) => {
-      const partitionKey = storageOperations.getPartitionKey(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] = _objectSpread(_objectSpread({}, _configurations.default.db()), {}, {
-        query: {
-          PK: partitionKey,
-          SK: sortKey
-        }
+      collection[partitionKey] = entity.getBatch({
+        PK: partitionKey,
+        SK: publishedKey
       });
       return collection;
     }, {});
-    return context.db.batch().read(...Object.values(queries)).execute().then(results => results.map(result => result[0])).then(results => {
-      const items = flattenResults(results);
-      return keys.map(id => {
-        return items.filter(item => {
-          const partitionKey = storageOperations.getPartitionKey(id);
-          return item.PK === partitionKey && item.SK === sortKey;
-        });
+    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 = (context, model, storageOperations) => {
-  return batchLoadKeys(keys => {
-    const sortKey = storageOperations.getSortKeyLatest();
-    const queries = keys.reduce((collection, id) => {
-      const partitionKey = storageOperations.getPartitionKey(id);
+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] = _objectSpread(_objectSpread({}, _configurations.default.db()), {}, {
-        query: {
-          PK: storageOperations.getPartitionKey(id),
-          SK: sortKey
-        }
+      collection[partitionKey] = entity.getBatch({
+        PK: partitionKey,
+        SK: latestKey
       });
       return collection;
     }, {});
-    return context.db.batch().read(...Object.values(queries)).execute().then(results => results.map(result => result[0])).then(results => {
-      const items = flattenResults(results);
-      return keys.map(id => {
-        return items.filter(item => {
-          const partitionKey = storageOperations.getPartitionKey(id);
-          return item.PK === partitionKey && item.SK === sortKey;
-        });
+    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;
       });
     });
   });
@@ -161,80 +201,90 @@ 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);
+  clearAllEntryRevisions(params) {
+    this.clear("getAllEntryRevisions", params);
   }
 
-  async getRevisionById(model, ids) {
-    return await this.loadMany("getRevisionById", model, ids);
+  async getRevisionById(params) {
+    return await this.loadMany("getRevisionById", params, params.ids);
   }
 
-  clearRevisionById(model, entry) {
-    this.clear("getRevisionById", model, entry);
+  clearRevisionById(params) {
+    this.clear("getRevisionById", params);
   }
 
-  async getPublishedRevisionByEntryId(model, ids) {
-    return await this.loadMany("getPublishedRevisionByEntryId", model, ids);
+  async getPublishedRevisionByEntryId(params) {
+    return await this.loadMany("getPublishedRevisionByEntryId", params, params.ids);
   }
 
-  clearPublishedRevisionByEntryId(model, entry) {
-    this.clear("getPublishedRevisionByEntryId", model, entry);
+  clearPublishedRevisionByEntryId(params) {
+    this.clear("getPublishedRevisionByEntryId", params);
   }
 
-  async getLatestRevisionByEntryId(model, ids) {
-    return await this.loadMany("getLatestRevisionByEntryId", model, ids);
+  async getLatestRevisionByEntryId(params) {
+    return await this.loadMany("getLatestRevisionByEntryId", params, params.ids);
   }
 
-  clearLatestRevisionByEntryId(model, entry) {
-    this.clear("getLatestRevisionByEntryId", model, entry);
+  clearLatestRevisionByEntryId(params) {
+    this.clear("getLatestRevisionByEntryId", params);
   }
 
-  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);
@@ -242,11 +292,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
-      });
+        ids
+      }));
     }
 
     throw new _error.default(`Data loader did not return array of items or empty array.`, "INVALID_DATA_LOADER_RESULT", {
@@ -255,14 +306,24 @@ class DataLoadersHandler {
       results
     });
   }
+
+  clearAll(params) {
+    for (const name of loaderNames) {
+      const loader = this.getLoader(name, params);
+      loader.clearAll();
+    }
+  }
   /**
    * 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);
+  clear(name, params) {
+    const {
+      entry
+    } = params;
+    const loader = this.getLoader(name, params);
 
     if (!entry) {
       loader.clearAll();
@@ -270,10 +331,17 @@ class DataLoadersHandler {
     }
 
     loader.clear(entry.id);
-    loader.clear(this._storageOperations.getPartitionKey(entry.id));
+    const {
+      tenant,
+      locale
+    } = params.model;
+    loader.clear((0, _keys.createPartitionKey)({
+      tenant,
+      locale,
+      id: entry.id
+    }));
   }
 
 }
 
-exports.DataLoadersHandler = DataLoadersHandler;
-//# sourceMappingURL=dataLoaders.js.map
+exports.DataLoadersHandler = DataLoadersHandler;

package/operations/entry/elasticsearchFields.d.ts

@@ -0,0 +1,2 @@
+import { CmsEntryElasticsearchFieldPlugin } from "../../plugins/CmsEntryElasticsearchFieldPlugin";
+export declare const elasticsearchFields: CmsEntryElasticsearchFieldPlugin[];

package/operations/entry/elasticsearchFields.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.elasticsearchFields = void 0;
+
+var _CmsEntryElasticsearchFieldPlugin = require("../../plugins/CmsEntryElasticsearchFieldPlugin");
+
+const elasticsearchFields = [new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+  field: "createdOn",
+  unmappedType: "date"
+}), new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+  field: "savedOn",
+  unmappedType: "date"
+}), new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+  field: "publishedOn",
+  unmappedType: "date"
+}), new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+  field: "ownedBy",
+  path: "ownedBy.id"
+}), new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+  field: "createdBy",
+  path: "createdBy.id"
+}),
+/**
+ * Always add the ALL fields plugin because of the keyword/path build.
+ */
+new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+  field: _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin.ALL
+})];
+exports.elasticsearchFields = elasticsearchFields;

package/operations/entry/fields.d.ts

@@ -1,3 +1,3 @@
-import { CmsContentModel } from "@webiny/api-headless-cms/types";
+import { CmsModel } from "@webiny/api-headless-cms/types";
 import { CmsEntryElasticsearchFieldPlugin } from "../../plugins/CmsEntryElasticsearchFieldPlugin";
-export declare const createElasticsearchFields: (model: CmsContentModel) => Record<string, CmsEntryElasticsearchFieldPlugin>;
+export declare const createElasticsearchFields: (model: CmsModel) => Record<string, CmsEntryElasticsearchFieldPlugin>;

package/operations/entry/fields.js

@@ -57,5 +57,4 @@ const createElasticsearchFields = model => {
   }, systemFields);
 };
 
-exports.createElasticsearchFields = createElasticsearchFields;
-//# sourceMappingURL=fields.js.map
+exports.createElasticsearchFields = createElasticsearchFields;

package/operations/entry/index.d.ts

@@ -1,3 +1,13 @@
-import { CmsContentEntryStorageOperationsProvider } from "@webiny/api-headless-cms/types";
-declare const contentEntryStorageOperationsProvider: () => CmsContentEntryStorageOperationsProvider;
-export default contentEntryStorageOperationsProvider;
+import { CmsEntryStorageOperations } from "@webiny/api-headless-cms/types";
+import { Entity } from "dynamodb-toolbox";
+import { Client } from "@elastic/elasticsearch";
+import { PluginsContainer } from "@webiny/plugins";
+export declare const createLatestType: () => string;
+export declare const createPublishedType: () => string;
+export interface Params {
+    entity: Entity<any>;
+    esEntity: Entity<any>;
+    elasticsearch: Client;
+    plugins: PluginsContainer;
+}
+export declare const createEntriesStorageOperations: (params: Params) => CmsEntryStorageOperations;