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

package/index.js

@@ -0,0 +1,171 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createStorageOperations = void 0;
+
+var _filters = _interopRequireDefault(require("@webiny/db-dynamodb/plugins/filters"));
+
+var _elasticsearch = _interopRequireDefault(require("./elasticsearch"));
+
+var _dynamoDb = _interopRequireDefault(require("./dynamoDb"));
+
+var _settings = require("./operations/settings");
+
+var _system = require("./operations/system");
+
+var _model = require("./operations/model");
+
+var _entry = require("./operations/entry");
+
+var _types = require("./types");
+
+var _table = require("./definitions/table");
+
+var _tableElasticsearch = require("./definitions/tableElasticsearch");
+
+var _group = require("./definitions/group");
+
+var _model2 = require("./definitions/model");
+
+var _entry2 = require("./definitions/entry");
+
+var _entryElasticsearch = require("./definitions/entryElasticsearch");
+
+var _system2 = require("./definitions/system");
+
+var _settings2 = require("./definitions/settings");
+
+var _createElasticsearchTemplate = require("./operations/system/createElasticsearchTemplate");
+
+var _plugins = require("@webiny/plugins");
+
+var _group2 = require("./operations/group");
+
+var _operators = require("@webiny/api-elasticsearch/operators");
+
+var _elasticsearchFields = require("./operations/entry/elasticsearchFields");
+
+const createStorageOperations = params => {
+  const {
+    attributes = {},
+    table,
+    esTable,
+    documentClient,
+    elasticsearch,
+    plugins: customPlugins,
+    modelFieldToGraphQLPlugins
+  } = params;
+  const tableInstance = (0, _table.createTable)({
+    table,
+    documentClient
+  });
+  const tableElasticsearchInstance = (0, _tableElasticsearch.createElasticsearchTable)({
+    table: esTable,
+    documentClient
+  });
+  const entities = {
+    settings: (0, _settings2.createSettingsEntity)({
+      entityName: _types.ENTITIES.SETTINGS,
+      table: tableInstance,
+      attributes: attributes[_types.ENTITIES.SETTINGS]
+    }),
+    system: (0, _system2.createSystemEntity)({
+      entityName: _types.ENTITIES.SYSTEM,
+      table: tableInstance,
+      attributes: attributes[_types.ENTITIES.SYSTEM]
+    }),
+    groups: (0, _group.createGroupEntity)({
+      entityName: _types.ENTITIES.GROUPS,
+      table: tableInstance,
+      attributes: attributes[_types.ENTITIES.GROUPS]
+    }),
+    models: (0, _model2.createModelEntity)({
+      entityName: _types.ENTITIES.MODELS,
+      table: tableInstance,
+      attributes: attributes[_types.ENTITIES.MODELS]
+    }),
+    entries: (0, _entry2.createEntryEntity)({
+      entityName: _types.ENTITIES.ENTRIES,
+      table: tableInstance,
+      attributes: attributes[_types.ENTITIES.ENTRIES]
+    }),
+    entriesEs: (0, _entryElasticsearch.createEntryElasticsearchEntity)({
+      entityName: _types.ENTITIES.ENTRIES_ES,
+      table: tableElasticsearchInstance,
+      attributes: attributes[_types.ENTITIES.ENTRIES_ES]
+    })
+  };
+  const plugins = new _plugins.PluginsContainer([
+  /**
+   * User defined custom plugins.
+   */
+  ...(customPlugins || []),
+  /**
+   * Plugins of type CmsModelFieldToGraphQLPlugin.
+   */
+  modelFieldToGraphQLPlugins,
+  /**
+   * Elasticsearch field definitions for the entry record.
+   */
+  _elasticsearchFields.elasticsearchFields,
+  /**
+   * DynamoDB filter plugins for the where conditions.
+   */
+  (0, _filters.default)(),
+  /**
+   * Elasticsearch operators.
+   */
+  (0, _operators.getElasticsearchOperators)(),
+  /**
+   * Field plugins for DynamoDB.
+   */
+  (0, _dynamoDb.default)(),
+  /**
+   * Field plugins for Elasticsearch.
+   */
+  (0, _elasticsearch.default)()]);
+  return {
+    init: async cms => {
+      cms.onBeforeSystemInstall.subscribe(async () => {
+        await (0, _createElasticsearchTemplate.createElasticsearchTemplate)({
+          elasticsearch
+        });
+      });
+    },
+    plugins: [
+    /**
+     * Field plugins for DynamoDB.
+     * We must pass them to the base application.
+     */
+    (0, _dynamoDb.default)()],
+    getEntities: () => entities,
+    getTable: () => tableInstance,
+    getEsTable: () => tableElasticsearchInstance,
+    system: (0, _system.createSystemStorageOperations)({
+      entity: entities.system
+    }),
+    settings: (0, _settings.createSettingsStorageOperations)({
+      entity: entities.settings
+    }),
+    groups: (0, _group2.createGroupsStorageOperations)({
+      entity: entities.groups,
+      plugins
+    }),
+    models: (0, _model.createModelsStorageOperations)({
+      entity: entities.models,
+      elasticsearch
+    }),
+    entries: (0, _entry.createEntriesStorageOperations)({
+      entity: entities.entries,
+      esEntity: entities.entriesEs,
+      plugins,
+      elasticsearch
+    })
+  };
+};
+
+exports.createStorageOperations = createStorageOperations;

package/operations/entry/dataLoaders.d.ts

@@ -0,0 +1,47 @@
+import { CmsEntry, CmsModel } from "@webiny/api-headless-cms/types";
+import { Entity } from "dynamodb-toolbox";
+export interface GetAllEntryRevisionsParams {
+    ids: readonly string[];
+    model: CmsModel;
+}
+export interface GetRevisionByIdParams {
+    ids: readonly string[];
+    model: CmsModel;
+}
+export interface GetPublishedRevisionByEntryIdParams {
+    ids: readonly string[];
+    model: CmsModel;
+}
+export interface GetLatestRevisionByEntryIdParams {
+    ids: readonly string[];
+    model: CmsModel;
+}
+interface ClearLoaderParams {
+    model: CmsModel;
+    entry?: CmsEntry;
+}
+export interface Params {
+    entity: Entity<any>;
+}
+export declare class DataLoadersHandler {
+    private readonly loaders;
+    private readonly entity;
+    constructor(params: any);
+    getAllEntryRevisions(params: GetAllEntryRevisionsParams): Promise<CmsEntry[]>;
+    clearAllEntryRevisions(params: ClearLoaderParams): void;
+    getRevisionById(params: GetRevisionByIdParams): Promise<CmsEntry[]>;
+    clearRevisionById(params: ClearLoaderParams): void;
+    getPublishedRevisionByEntryId(params: GetPublishedRevisionByEntryIdParams): Promise<CmsEntry[]>;
+    clearPublishedRevisionByEntryId(params: ClearLoaderParams): void;
+    getLatestRevisionByEntryId(params: GetLatestRevisionByEntryIdParams): Promise<CmsEntry[]>;
+    clearLatestRevisionByEntryId(params: ClearLoaderParams): void;
+    private getLoader;
+    private loadMany;
+    clearAll(params: Omit<ClearLoaderParams, "entry">): void;
+    /**
+     * Helper to clear the cache for certain data loader.
+     * If entry is passed then clear target key only.
+     */
+    private clear;
+}
+export {};

package/operations/entry/dataLoaders.js

@@ -0,0 +1,347 @@
+"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);
+  }
+
+  clearAllEntryRevisions(params) {
+    this.clear("getAllEntryRevisions", params);
+  }
+
+  async getRevisionById(params) {
+    return await this.loadMany("getRevisionById", params, params.ids);
+  }
+
+  clearRevisionById(params) {
+    this.clear("getRevisionById", params);
+  }
+
+  async getPublishedRevisionByEntryId(params) {
+    return await this.loadMany("getPublishedRevisionByEntryId", params, params.ids);
+  }
+
+  clearPublishedRevisionByEntryId(params) {
+    this.clear("getPublishedRevisionByEntryId", params);
+  }
+
+  async getLatestRevisionByEntryId(params) {
+    return await this.loadMany("getLatestRevisionByEntryId", params, params.ids);
+  }
+
+  clearLatestRevisionByEntryId(params) {
+    this.clear("getLatestRevisionByEntryId", params);
+  }
+
+  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();
+    }
+  }
+  /**
+   * Helper to clear the cache for certain data loader.
+   * If entry is passed then clear target key only.
+   */
+
+
+  clear(name, params) {
+    const {
+      entry
+    } = params;
+    const loader = this.getLoader(name, params);
+
+    if (!entry) {
+      loader.clearAll();
+      return;
+    }
+
+    loader.clear(entry.id);
+    const {
+      tenant,
+      locale
+    } = params.model;
+    loader.clear((0, _keys.createPartitionKey)({
+      tenant,
+      locale,
+      id: entry.id
+    }));
+  }
+
+}
+
+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

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

package/operations/entry/fields.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createElasticsearchFields = void 0;
+
+var _CmsEntryElasticsearchFieldPlugin = require("../../plugins/CmsEntryElasticsearchFieldPlugin");
+
+const fieldsWithKeywords = ["text", "long-text", "rich-text", "id", "ref"];
+/**
+ * We need to map entry system fields that have different paths, no keyword or not sortable.
+ */
+
+const systemFields = {
+  createdBy: new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+    field: "createdBy",
+    path: "createdBy.id",
+    searchable: true,
+    keyword: true,
+    sortable: false
+  }),
+  ownedBy: new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+    field: "ownedBy",
+    path: "ownedBy.id",
+    searchable: true,
+    keyword: true,
+    sortable: false
+  }),
+  createdOn: new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+    field: "createdOn",
+    path: "createdOn",
+    searchable: true,
+    keyword: false,
+    sortable: false,
+    unmappedType: "date"
+  }),
+  savedOn: new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+    field: "savedOn",
+    path: "savedOn",
+    searchable: true,
+    keyword: false,
+    sortable: false,
+    unmappedType: "date"
+  })
+};
+
+const createElasticsearchFields = model => {
+  return model.fields.reduce((fields, field) => {
+    fields[field.fieldId] = new _CmsEntryElasticsearchFieldPlugin.CmsEntryElasticsearchFieldPlugin({
+      field: field.fieldId,
+      path: `values.${field.fieldId}`,
+      searchable: true,
+      keyword: fieldsWithKeywords.includes(field.type)
+    });
+    return fields;
+  }, systemFields);
+};
+
+exports.createElasticsearchFields = createElasticsearchFields;

package/operations/entry/index.d.ts

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