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

package/operations/group/index.js

@@ -0,0 +1,198 @@
+"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
+    } = params;
+    const queryAllParams = {
+      entity,
+      partitionKey: createPartitionKey(where),
+      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
+      }));
+    }
+
+    const filteredItems = (0, _filter.filterItems)({
+      items: records,
+      where,
+      fields: [],
+      plugins
+    });
+
+    if (!sort || sort.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,6 @@
+import { CmsModelStorageOperations } from "@webiny/api-headless-cms/types";
+import { Entity } from "dynamodb-toolbox";
+export interface Params {
+    entity: Entity<any>;
+}
+export declare const createModelsStorageOperations: (params: Params) => CmsModelStorageOperations;

package/operations/model/index.js

@@ -0,0 +1,161 @@
+"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 _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
+  } = params;
+
+  const create = async params => {
+    const {
+      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(`Could not create CMS Content Model.`, "CREATE_MODEL_ERROR", {
+        error: ex,
+        model,
+        keys
+      });
+    }
+  };
+
+  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/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;

package/operations/system/index.js

@@ -0,0 +1,105 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSystemStorageOperations = 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");
+
+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 = ({
+  tenant
+}) => {
+  return `T#${tenant.toLowerCase()}#SYSTEM`;
+};
+
+const createSortKey = () => {
+  return "CMS";
+};
+
+const createKeys = params => {
+  return {
+    PK: createPartitionKey(params),
+    SK: createSortKey()
+  };
+};
+
+const createSystemStorageOperations = params => {
+  const {
+    entity
+  } = params;
+
+  const create = async ({
+    system
+  }) => {
+    const keys = createKeys(system);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread({}, system), keys));
+      return system;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create system.", ex.code || "CREATE_SYSTEM_ERROR", {
+        error: ex,
+        system,
+        keys
+      });
+    }
+  };
+
+  const update = async params => {
+    const {
+      system,
+      original
+    } = params;
+    const keys = createKeys(system);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread({}, system), keys));
+      return system;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update system.", ex.code || "UPDATE_SYSTEM_ERROR", {
+        error: ex,
+        system,
+        original,
+        keys
+      });
+    }
+  };
+
+  const get = async params => {
+    const keys = createKeys(params);
+
+    try {
+      const system = await (0, _get.get)({
+        entity,
+        keys
+      });
+      return (0, _cleanup.cleanupItem)(entity, system);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not get system.", ex.code || "GET_SYSTEM_ERROR", {
+        error: ex,
+        keys
+      });
+    }
+  };
+
+  return {
+    create,
+    update,
+    get
+  };
+};
+
+exports.createSystemStorageOperations = createSystemStorageOperations;

package/package.json

@@ -0,0 +1,61 @@
+{
+	"name": "@webiny/api-headless-cms-ddb",
+	"version": "0.0.0-mt-1",
+	"main": "index.js",
+	"keywords": [
+		"@webiny/api-headless-cms",
+		"storage-operations",
+		"dynamodb",
+		"cms:ddb"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-headless-cms-ddb"
+	},
+	"description": "DynamoDB storage operations plugin for Headless CMS API.",
+	"contributors": [
+		"Pavel Denisjuk <pavel@webiny.com>",
+		"Sven Al Hamad <sven@webiny.com>",
+		"Adrian Smijulj <adrian@webiny.com>"
+	],
+	"license": "MIT",
+	"dependencies": {
+		"@babel/runtime": "7.15.4",
+		"@webiny/api-headless-cms": "0.0.0-mt-1",
+		"@webiny/db-dynamodb": "0.0.0-mt-1",
+		"@webiny/error": "0.0.0-mt-1",
+		"@webiny/handler-db": "0.0.0-mt-1",
+		"@webiny/utils": "0.0.0-mt-1",
+		"aws-sdk": "2.1026.0",
+		"dataloader": "2.0.0",
+		"dot-prop": "5.3.0",
+		"dynamodb-toolbox": "0.3.4",
+		"jsonpack": "1.1.5",
+		"lodash.sortby": "4.7.0"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.5.5",
+		"@babel/core": "^7.5.5",
+		"@babel/preset-env": "^7.5.5",
+		"@babel/preset-flow": "^7.0.0",
+		"@types/jsonpack": "^1.1.0",
+		"@webiny/cli": "^0.0.0-mt-1",
+		"@webiny/plugins": "^0.0.0-mt-1",
+		"@webiny/project-utils": "^0.0.0-mt-1",
+		"jest": "^26.6.3",
+		"jest-dynalite": "^3.2.0",
+		"jest-environment-node": "^26.6.2",
+		"ttypescript": "^1.5.12",
+		"typescript": "^4.1.3"
+	},
+	"publishConfig": {
+		"access": "public",
+		"directory": "dist"
+	},
+	"scripts": {
+		"build": "yarn webiny run build",
+		"watch": "yarn webiny run watch"
+	},
+	"gitHead": "37736d8456a6ecb342a6c3645060bd9a3f2d4bb0"
+}