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

package/operations/entry/keys.d.ts

@@ -0,0 +1,12 @@
+export interface PartitionKeyParams {
+    id: string;
+    tenant: string;
+    locale: string;
+}
+export declare const createPartitionKey: (params: PartitionKeyParams) => string;
+export interface SortKeyParams {
+    version: number;
+}
+export declare const createRevisionSortKey: (params: SortKeyParams) => string;
+export declare const createLatestSortKey: () => string;
+export declare const createPublishedSortKey: () => string;

package/operations/entry/keys.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createRevisionSortKey = exports.createPublishedSortKey = exports.createPartitionKey = exports.createLatestSortKey = void 0;
+
+var _utils = require("@webiny/utils");
+
+const createPartitionKey = params => {
+  const {
+    tenant,
+    locale,
+    id: initialId
+  } = params;
+  const {
+    id
+  } = (0, _utils.parseIdentifier)(initialId);
+  return `T#${tenant}#L#${locale}#CMS#CME#${id}`;
+};
+
+exports.createPartitionKey = createPartitionKey;
+
+const createRevisionSortKey = params => {
+  return `REV#${(0, _utils.zeroPad)(params.version)}`;
+};
+
+exports.createRevisionSortKey = createRevisionSortKey;
+
+const createLatestSortKey = () => {
+  return "L";
+};
+
+exports.createLatestSortKey = createLatestSortKey;
+
+const createPublishedSortKey = () => {
+  return "P";
+};
+
+exports.createPublishedSortKey = createPublishedSortKey;

package/operations/group/index.d.ts

@@ -0,0 +1,8 @@
+import { CmsGroupStorageOperations } 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 createGroupsStorageOperations: (params: Params) => CmsGroupStorageOperations;

package/operations/group/index.js

@@ -0,0 +1,202 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createGroupsStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _get = require("@webiny/db-dynamodb/utils/get");
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _query = require("@webiny/db-dynamodb/utils/query");
+
+var _filter = require("@webiny/db-dynamodb/utils/filter");
+
+var _ValueFilterPlugin = require("@webiny/db-dynamodb/plugins/definitions/ValueFilterPlugin");
+
+var _sort = require("@webiny/db-dynamodb/utils/sort");
+
+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 createPartitionKey = params => {
+  const {
+    tenant,
+    locale
+  } = params;
+  return `T#${tenant}#L#${locale}#CMS#CMG`;
+};
+
+const createSortKeys = params => {
+  const {
+    id
+  } = params;
+  return id;
+};
+
+const createKeys = params => {
+  return {
+    PK: createPartitionKey(params),
+    SK: createSortKeys(params)
+  };
+};
+
+const createType = () => {
+  return "cms.group";
+};
+
+const createGroupsStorageOperations = params => {
+  const {
+    entity,
+    plugins
+  } = params;
+  const filteringPlugins = plugins.byType(_ValueFilterPlugin.ValueFilterPlugin.type);
+
+  if (filteringPlugins.length === 0) {
+    throw new _error.default("DynamoDB filtering plugins not loaded.", "MISSING_DYNAMODB_FILTERING_PLUGINS");
+  }
+
+  const create = async params => {
+    const {
+      group
+    } = params;
+    const keys = createKeys(group);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread({}, group), {}, {
+        TYPE: createType()
+      }, keys));
+      return group;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create group.", ex.code || "CREATE_GROUP_ERROR", {
+        error: ex,
+        group,
+        keys
+      });
+    }
+  };
+
+  const update = async params => {
+    const {
+      group,
+      original
+    } = params;
+    const keys = createKeys(group);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread({}, group), {}, {
+        TYPE: createType()
+      }, keys));
+      return group;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update group.", ex.code || "UPDATE_GROUP_ERROR", {
+        error: ex,
+        group,
+        original,
+        keys
+      });
+    }
+  };
+
+  const deleteGroup = async params => {
+    const {
+      group
+    } = params; // TODO make sure that group has locale and tenant on it - add it in the crud just in case
+
+    const keys = createKeys(group);
+
+    try {
+      await entity.delete(keys);
+      return group;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete group.", ex.code || "DELETE_GROUP_ERROR", {
+        error: ex,
+        group,
+        keys
+      });
+    }
+  };
+
+  const get = async params => {
+    const keys = createKeys(params);
+
+    try {
+      const group = await (0, _get.get)({
+        entity,
+        keys
+      });
+      return (0, _cleanup.cleanupItem)(entity, group);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not get group.", ex.code || "GET_GROUP_ERROR", _objectSpread(_objectSpread({
+        error: ex
+      }, params), {}, {
+        keys
+      }));
+    }
+  };
+
+  const list = async params => {
+    const {
+      sort,
+      where: initialWhere
+    } = params;
+    const queryAllParams = {
+      entity,
+      partitionKey: createPartitionKey(initialWhere),
+      options: {
+        gte: " "
+      }
+    };
+    let records = [];
+
+    try {
+      records = await (0, _query.queryAll)(queryAllParams);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not list groups.", ex.code || "LIST_GROUP_ERROR", _objectSpread(_objectSpread({
+        error: ex
+      }, params), {}, {
+        sort,
+        where: initialWhere
+      }));
+    }
+
+    const where = _objectSpread({}, initialWhere);
+
+    delete where["tenant"];
+    delete where["locale"];
+    const filteredItems = (0, _filter.filterItems)({
+      items: records,
+      where,
+      fields: [],
+      plugins
+    });
+
+    if (!sort || sort.length === 0 || filteredItems.length === 0) {
+      return filteredItems;
+    }
+
+    return (0, _sort.sortItems)({
+      items: filteredItems,
+      sort,
+      fields: []
+    });
+  };
+
+  return {
+    create,
+    update,
+    delete: deleteGroup,
+    get,
+    list
+  };
+};
+
+exports.createGroupsStorageOperations = createGroupsStorageOperations;

package/operations/model/index.d.ts

@@ -0,0 +1,8 @@
+import { CmsModelStorageOperations } from "@webiny/api-headless-cms/types";
+import { Entity } from "dynamodb-toolbox";
+import { Client } from "@elastic/elasticsearch";
+export interface Params {
+    entity: Entity<any>;
+    elasticsearch: Client;
+}
+export declare const createModelsStorageOperations: (params: Params) => CmsModelStorageOperations;

package/operations/model/index.js

@@ -0,0 +1,205 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createModelsStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _configurations = _interopRequireDefault(require("../../configurations"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _get = require("@webiny/db-dynamodb/utils/get");
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _query = require("@webiny/db-dynamodb/utils/query");
+
+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 createPartitionKey = params => {
+  const {
+    tenant,
+    locale
+  } = params;
+  return `T#${tenant}#L#${locale}#CMS#CM`;
+};
+
+const createSortKey = params => {
+  return params.modelId;
+};
+
+const createKeys = params => {
+  return {
+    PK: createPartitionKey(params),
+    SK: createSortKey(params)
+  };
+};
+
+const createType = () => {
+  return "cms.model";
+};
+
+const createModelsStorageOperations = params => {
+  const {
+    entity,
+    elasticsearch
+  } = params;
+
+  const create = async params => {
+    const {
+      model
+    } = params;
+
+    const {
+      index
+    } = _configurations.default.es({
+      model
+    });
+
+    try {
+      const {
+        body: exists
+      } = await elasticsearch.indices.exists({
+        index
+      });
+
+      if (!exists) {
+        await elasticsearch.indices.create({
+          index
+        });
+      }
+    } catch (ex) {
+      throw new _error.default("Could not create Elasticsearch indice.", "ELASTICSEARCH_INDICE_CREATE_ERROR", {
+        error: ex,
+        index,
+        model
+      });
+    }
+
+    const keys = createKeys(model);
+    let error;
+
+    try {
+      await entity.put(_objectSpread(_objectSpread(_objectSpread({}, model), keys), {}, {
+        TYPE: createType()
+      }));
+      return model;
+    } catch (ex) {
+      error = ex;
+    }
+    /**
+     * In case of DynamoDB error we need to remove the index we created.
+     */
+
+
+    try {
+      await elasticsearch.indices.delete({
+        index
+      });
+    } catch (ex) {
+      throw new _error.default(`Could not delete elasticsearch index "${index}" after model record failed to be created.`, "DELETE_MODEL_INDICE_ERROR", {
+        dynamodbError: error,
+        elasticsearchError: ex
+      });
+    }
+
+    throw error;
+  };
+
+  const update = async params => {
+    const {
+      original,
+      model
+    } = params;
+    const keys = createKeys(model);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread(_objectSpread({}, model), keys), {}, {
+        TYPE: createType()
+      }));
+      return model;
+    } catch (ex) {
+      throw new _error.default(ex.messatge || "Could not update model.", ex.code || "MODEL_UPDATE_ERROR", {
+        error: ex,
+        model,
+        original,
+        keys
+      });
+    }
+  };
+
+  const deleteModel = async params => {
+    const {
+      model
+    } = params;
+    const keys = createKeys(model);
+
+    try {
+      await entity.delete(keys);
+      return model;
+    } catch (ex) {
+      throw new _error.default(ex.messatge || "Could not delete model.", ex.code || "MODEL_DELETE_ERROR", {
+        error: ex,
+        model,
+        keys
+      });
+    }
+  };
+
+  const get = async params => {
+    const keys = createKeys(params);
+
+    try {
+      const item = await (0, _get.get)({
+        entity,
+        keys
+      });
+      return (0, _cleanup.cleanupItem)(entity, item);
+    } catch (ex) {
+      throw new _error.default(ex.messatge || "Could not get model.", ex.code || "MODEL_GET_ERROR", {
+        error: ex,
+        keys
+      });
+    }
+  };
+
+  const list = async params => {
+    const {
+      where
+    } = params;
+    const queryAllParams = {
+      entity,
+      partitionKey: createPartitionKey(where),
+      options: {
+        gte: " "
+      }
+    };
+
+    try {
+      const items = await (0, _query.queryAll)(queryAllParams);
+      return (0, _cleanup.cleanupItems)(entity, items);
+    } catch (ex) {
+      throw new _error.default(ex.messatge || "Could not list models.", ex.code || "MODEL_LIST_ERROR", {
+        error: ex,
+        partitionKey: queryAllParams.partitionKey
+      });
+    }
+  };
+
+  return {
+    create,
+    update,
+    delete: deleteModel,
+    get,
+    list
+  };
+};
+
+exports.createModelsStorageOperations = createModelsStorageOperations;

package/operations/settings/index.d.ts

@@ -0,0 +1,6 @@
+import { CmsSettingsStorageOperations } from "@webiny/api-headless-cms/types";
+import { Entity } from "dynamodb-toolbox";
+export interface Params {
+    entity: Entity<any>;
+}
+export declare const createSettingsStorageOperations: (params: Params) => CmsSettingsStorageOperations;

package/operations/settings/index.js

@@ -0,0 +1,141 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSettingsStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _get = require("@webiny/db-dynamodb/utils/get");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+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 convertToDbData = settings => {
+  return _objectSpread(_objectSpread({}, settings), {}, {
+    contentModelLastChange: settings.contentModelLastChange.toISOString()
+  });
+};
+
+const convertFromDbData = settings => {
+  if (!settings) {
+    return null;
+  }
+
+  let contentModelLastChange;
+
+  try {
+    contentModelLastChange = new Date(settings.contentModelLastChange);
+  } catch {
+    contentModelLastChange = new Date();
+  }
+
+  return _objectSpread(_objectSpread({}, settings), {}, {
+    contentModelLastChange
+  });
+};
+
+const createPartitionKey = ({
+  tenant,
+  locale
+}) => {
+  return `T#${tenant}#L#${locale}#CMS#SETTINGS`;
+};
+
+const createSortKey = () => {
+  return "settings";
+};
+
+const createKeys = params => {
+  return {
+    PK: createPartitionKey(params),
+    SK: createSortKey()
+  };
+};
+
+const createSettingsStorageOperations = params => {
+  const {
+    entity
+  } = params;
+
+  const create = async params => {
+    const {
+      settings
+    } = params;
+    const keys = createKeys(settings);
+    const dbSettings = convertToDbData(settings);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread({}, dbSettings), keys));
+      return settings;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create settings.", ex.code || "CREATE_SETTINGS_ERROR", {
+        error: ex,
+        settings,
+        dbSettings,
+        keys
+      });
+    }
+  };
+
+  const update = async params => {
+    const {
+      settings,
+      original
+    } = params;
+    const keys = createKeys(settings);
+    const dbSettings = convertToDbData(settings);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread({}, dbSettings), keys));
+      return settings;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update settings.", ex.code || "UPDATE_SETTINGS_ERROR", {
+        error: ex,
+        settings,
+        dbSettings,
+        original,
+        keys
+      });
+    }
+  };
+
+  const get = async params => {
+    const keys = createKeys(params);
+
+    try {
+      const record = await (0, _get.get)({
+        entity,
+        keys
+      });
+
+      if (!record) {
+        return null;
+      }
+
+      const settings = (0, _cleanup.cleanupItem)(entity, record);
+      return convertFromDbData(settings);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not get settings.", ex.code || "GET_SETTINGS_ERROR", {
+        error: ex,
+        keys
+      });
+    }
+  };
+
+  return {
+    create,
+    get,
+    update
+  };
+};
+
+exports.createSettingsStorageOperations = createSettingsStorageOperations;

package/operations/system/createElasticsearchTemplate.d.ts

@@ -0,0 +1,5 @@
+import { Client } from "@elastic/elasticsearch";
+export interface Params {
+    elasticsearch: Client;
+}
+export declare const createElasticsearchTemplate: (params: Params) => Promise<void>;

package/operations/system/createElasticsearchTemplate.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createElasticsearchTemplate = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const createElasticsearchTemplate = async params => {
+  const {
+    elasticsearch
+  } = params;
+  const options = {
+    name: "headless-cms-entries-index",
+    body: {
+      index_patterns: ["*headless-cms*"],
+      settings: {
+        analysis: {
+          analyzer: {
+            lowercase_analyzer: {
+              type: "custom",
+              filter: ["lowercase", "trim"],
+              tokenizer: "keyword"
+            }
+          }
+        }
+      },
+      mappings: {
+        properties: {
+          property: {
+            type: "text",
+            fields: {
+              keyword: {
+                type: "keyword",
+                ignore_above: 256
+              }
+            },
+            analyzer: "lowercase_analyzer"
+          },
+          rawValues: {
+            type: "object",
+            enabled: false
+          }
+        }
+      }
+    }
+  };
+
+  try {
+    await elasticsearch.indices.putTemplate(options);
+  } catch (ex) {
+    throw new _error.default(ex.message || "Could not create Elasticsearch index template for the Headless CMS.", ex.code || "CMS_ELASTICSEARCH_TEMPLATE_ERROR", {
+      error: ex,
+      options
+    });
+  }
+};
+
+exports.createElasticsearchTemplate = createElasticsearchTemplate;

package/operations/system/index.d.ts

@@ -0,0 +1,6 @@
+import { CmsSystemStorageOperations } from "@webiny/api-headless-cms/types";
+import { Entity } from "dynamodb-toolbox";
+export interface Params {
+    entity: Entity<any>;
+}
+export declare const createSystemStorageOperations: (params: Params) => CmsSystemStorageOperations;