@webiny/api-page-builder-so-ddb-es 0.0.0-mt-1

package/operations/menu/MenuStorageOperations.js

@@ -0,0 +1,235 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MenuStorageOperationsDdbEs = void 0;
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+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 _sort = require("@webiny/db-dynamodb/utils/sort");
+
+var _listResponse = require("@webiny/db-dynamodb/utils/listResponse");
+
+var _table = require("../../definitions/table");
+
+var _menuEntity = require("../../definitions/menuEntity");
+
+var _MenuDynamoDbElasticFieldPlugin = require("../../plugins/definitions/MenuDynamoDbElasticFieldPlugin");
+
+const _excluded = ["tenant", "locale"];
+
+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; }
+
+class MenuStorageOperationsDdbEs {
+  constructor({
+    context
+  }) {
+    (0, _defineProperty2.default)(this, "context", void 0);
+    (0, _defineProperty2.default)(this, "table", void 0);
+    (0, _defineProperty2.default)(this, "entity", void 0);
+    this.context = context;
+    this.table = (0, _table.defineTable)({
+      context
+    });
+    this.entity = (0, _menuEntity.defineMenuEntity)({
+      context,
+      table: this.table
+    });
+  }
+
+  async get(params) {
+    const {
+      where
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(where),
+      SK: this.createSortKey(where)
+    };
+
+    try {
+      const result = await this.entity.get(keys);
+
+      if (!result || !result.Item) {
+        return null;
+      }
+
+      return (0, _cleanup.cleanupItem)(this.entity, result.Item);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not load menu by given parameters.", ex.code || "MENU_GET_ERROR", {
+        where
+      });
+    }
+  }
+
+  async list(params) {
+    const {
+      where,
+      sort,
+      limit
+    } = params;
+    const {
+      tenant,
+      locale
+    } = where,
+          restWhere = (0, _objectWithoutProperties2.default)(where, _excluded);
+    const queryAllParams = {
+      entity: this.entity,
+      partitionKey: this.createPartitionKey({
+        tenant,
+        locale
+      }),
+      options: {
+        limit: limit || undefined,
+        gt: " "
+      }
+    };
+    let items = [];
+
+    try {
+      items = await (0, _query.queryAll)(queryAllParams);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not list menus by given parameters.", ex.code || "MENUS_LIST_ERROR", {
+        partitionKey: queryAllParams.partitionKey,
+        options: queryAllParams.options
+      });
+    }
+
+    const fields = this.context.plugins.byType(_MenuDynamoDbElasticFieldPlugin.MenuDynamoDbElasticFieldPlugin.type);
+    const filteredItems = (0, _filter.filterItems)({
+      plugins: this.context.plugins,
+      where: restWhere,
+      items,
+      fields
+    }).map(item => {
+      return (0, _cleanup.cleanupItem)(this.entity, item);
+    });
+    const sortedItems = (0, _sort.sortItems)({
+      items: filteredItems,
+      sort,
+      fields ///: ["createdOn", "id", "title", "slug"]
+
+    });
+    return (0, _listResponse.createListResponse)({
+      items: sortedItems,
+      limit,
+      totalCount: filteredItems.length,
+      after: null
+    });
+  }
+
+  async create(params) {
+    const {
+      menu
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey({
+        tenant: menu.tenant,
+        locale: menu.locale
+      }),
+      SK: this.createSortKey(menu)
+    };
+
+    try {
+      await this.entity.put(_objectSpread(_objectSpread({}, menu), {}, {
+        TYPE: this.createType()
+      }, keys));
+      return menu;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create menu.", ex.code || "MENU_CREATE_ERROR", {
+        keys,
+        menu
+      });
+    }
+  }
+
+  async update(params) {
+    const {
+      menu,
+      original
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey({
+        tenant: menu.tenant,
+        locale: menu.locale
+      }),
+      SK: this.createSortKey(menu)
+    };
+
+    try {
+      await this.entity.put(_objectSpread(_objectSpread({}, menu), {}, {
+        TYPE: this.createType()
+      }, keys));
+      return menu;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update menu.", ex.code || "MENU_UPDATE_ERROR", {
+        keys,
+        original,
+        menu
+      });
+    }
+  }
+
+  async delete(params) {
+    const {
+      menu
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey({
+        tenant: menu.tenant,
+        locale: menu.locale
+      }),
+      SK: this.createSortKey(menu)
+    };
+
+    try {
+      await this.entity.delete(_objectSpread(_objectSpread({}, menu), keys));
+      return menu;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete menu.", ex.code || "MENU_DELETE_ERROR", {
+        keys,
+        menu
+      });
+    }
+  }
+
+  createPartitionKey({
+    tenant,
+    locale
+  }) {
+    return `T#${tenant}#L#${locale}#PB#M`;
+  }
+
+  createSortKey(input) {
+    if (typeof input === "string") {
+      return input;
+    } else if (input.slug) {
+      return input.slug;
+    }
+
+    throw new _error.default("Could not determine the menu sort key from the input.", "MALFORMED_SORT_KEY", {
+      input
+    });
+  }
+
+  createType() {
+    return "pb.menu";
+  }
+
+}
+
+exports.MenuStorageOperationsDdbEs = MenuStorageOperationsDdbEs;

package/operations/menu/fields.d.ts

@@ -0,0 +1,3 @@
+import { MenuDynamoDbElasticFieldPlugin } from "../../plugins/definitions/MenuDynamoDbElasticFieldPlugin";
+declare const _default: () => MenuDynamoDbElasticFieldPlugin[];
+export default _default;

package/operations/menu/fields.js

@@ -0,0 +1,25 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _MenuDynamoDbElasticFieldPlugin = require("../../plugins/definitions/MenuDynamoDbElasticFieldPlugin");
+
+var _default = () => [new _MenuDynamoDbElasticFieldPlugin.MenuDynamoDbElasticFieldPlugin({
+  field: "id"
+}), new _MenuDynamoDbElasticFieldPlugin.MenuDynamoDbElasticFieldPlugin({
+  field: "title"
+}), new _MenuDynamoDbElasticFieldPlugin.MenuDynamoDbElasticFieldPlugin({
+  field: "slug"
+}), new _MenuDynamoDbElasticFieldPlugin.MenuDynamoDbElasticFieldPlugin({
+  field: "createdOn",
+  type: "date"
+}), new _MenuDynamoDbElasticFieldPlugin.MenuDynamoDbElasticFieldPlugin({
+  field: "createdBy",
+  path: "createdBy.id",
+  sortable: false
+})];
+
+exports.default = _default;

package/operations/menu/index.d.ts

@@ -0,0 +1,5 @@
+import { MenuStorageOperationsProviderPlugin, Params } from "@webiny/api-page-builder/plugins/MenuStorageOperationsProviderPlugin";
+import { MenuStorageOperations } from "@webiny/api-page-builder/types";
+export declare class MenuStorageOperationsDdbEsProviderPlugin extends MenuStorageOperationsProviderPlugin {
+    provide({ context }: Params): Promise<MenuStorageOperations>;
+}

package/operations/menu/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.MenuStorageOperationsDdbEsProviderPlugin = void 0;
+
+var _MenuStorageOperationsProviderPlugin = require("@webiny/api-page-builder/plugins/MenuStorageOperationsProviderPlugin");
+
+var _MenuStorageOperations = require("./MenuStorageOperations");
+
+var _fields = _interopRequireDefault(require("./fields"));
+
+class MenuStorageOperationsDdbEsProviderPlugin extends _MenuStorageOperationsProviderPlugin.MenuStorageOperationsProviderPlugin {
+  async provide({
+    context
+  }) {
+    context.plugins.register((0, _fields.default)());
+    return new _MenuStorageOperations.MenuStorageOperationsDdbEs({
+      context
+    });
+  }
+
+}
+
+exports.MenuStorageOperationsDdbEsProviderPlugin = MenuStorageOperationsDdbEsProviderPlugin;

package/operations/pageElement/PageElementStorageOperations.d.ts

@@ -0,0 +1,23 @@
+import { PageElement, PageElementStorageOperations, PageElementStorageOperationsCreateParams, PageElementStorageOperationsDeleteParams, PageElementStorageOperationsGetParams, PageElementStorageOperationsListParams, PageElementStorageOperationsListResponse, PageElementStorageOperationsUpdateParams, PbContext } from "@webiny/api-page-builder/types";
+import { Entity, Table } from "dynamodb-toolbox";
+export interface Params {
+    context: PbContext;
+}
+export interface PartitionKeyOptions {
+    tenant: string;
+    locale: string;
+}
+export declare class PageElementStorageOperationsDdbEs implements PageElementStorageOperations {
+    protected readonly context: PbContext;
+    readonly table: Table;
+    readonly entity: Entity<any>;
+    constructor({ context }: Params);
+    get(params: PageElementStorageOperationsGetParams): Promise<PageElement | null>;
+    list(params: PageElementStorageOperationsListParams): Promise<PageElementStorageOperationsListResponse>;
+    create(params: PageElementStorageOperationsCreateParams): Promise<PageElement>;
+    update(params: PageElementStorageOperationsUpdateParams): Promise<PageElement>;
+    delete(params: PageElementStorageOperationsDeleteParams): Promise<PageElement>;
+    createPartitionKey({ tenant, locale }: PartitionKeyOptions): string;
+    createSortKey(input: Pick<PageElement, "id"> | string): string;
+    createType(): string;
+}

package/operations/pageElement/PageElementStorageOperations.js

@@ -0,0 +1,234 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PageElementStorageOperationsDdbEs = void 0;
+
+var _objectWithoutProperties2 = _interopRequireDefault(require("@babel/runtime/helpers/objectWithoutProperties"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _query = require("@webiny/db-dynamodb/utils/query");
+
+var _filter = require("@webiny/db-dynamodb/utils/filter");
+
+var _sort = require("@webiny/db-dynamodb/utils/sort");
+
+var _listResponse = require("@webiny/db-dynamodb/utils/listResponse");
+
+var _table = require("../../definitions/table");
+
+var _pageElementEntity = require("../../definitions/pageElementEntity");
+
+var _PageElementDynamoDbElasticFieldPlugin = require("../../plugins/definitions/PageElementDynamoDbElasticFieldPlugin");
+
+const _excluded = ["tenant", "locale"];
+
+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; }
+
+class PageElementStorageOperationsDdbEs {
+  constructor({
+    context
+  }) {
+    (0, _defineProperty2.default)(this, "context", void 0);
+    (0, _defineProperty2.default)(this, "table", void 0);
+    (0, _defineProperty2.default)(this, "entity", void 0);
+    this.context = context;
+    this.table = (0, _table.defineTable)({
+      context
+    });
+    this.entity = (0, _pageElementEntity.definePageElementEntity)({
+      context,
+      table: this.table
+    });
+  }
+
+  async get(params) {
+    const {
+      where
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(where),
+      SK: this.createSortKey(where)
+    };
+
+    try {
+      const result = await this.entity.get(keys);
+
+      if (!result || !result.Item) {
+        return null;
+      }
+
+      return (0, _cleanup.cleanupItem)(this.entity, result.Item);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not load page element by given parameters.", ex.code || "PAGE_ELEMENT_GET_ERROR", {
+        where
+      });
+    }
+  }
+
+  async list(params) {
+    const {
+      where,
+      sort,
+      limit
+    } = params;
+    const {
+      tenant,
+      locale
+    } = where,
+          restWhere = (0, _objectWithoutProperties2.default)(where, _excluded);
+    const queryAllParams = {
+      entity: this.entity,
+      partitionKey: this.createPartitionKey({
+        tenant,
+        locale
+      }),
+      options: {
+        limit: limit || undefined,
+        gt: " "
+      }
+    };
+    let results = [];
+
+    try {
+      results = await (0, _query.queryAll)(queryAllParams);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not list page elements by given parameters.", ex.code || "PAGE_ELEMENTS_LIST_ERROR", {
+        partitionKey: queryAllParams.partitionKey,
+        options: queryAllParams.options
+      });
+    }
+
+    const fields = this.context.plugins.byType(_PageElementDynamoDbElasticFieldPlugin.PageElementDynamoDbElasticFieldPlugin.type);
+    const filteredItems = (0, _filter.filterItems)({
+      plugins: this.context.plugins,
+      where: restWhere,
+      items: results,
+      fields
+    }).map(item => {
+      return (0, _cleanup.cleanupItem)(this.entity, item);
+    });
+    const sortedItems = (0, _sort.sortItems)({
+      items: filteredItems,
+      sort,
+      fields
+    });
+    return (0, _listResponse.createListResponse)({
+      items: sortedItems,
+      limit,
+      totalCount: filteredItems.length,
+      after: null
+    });
+  }
+
+  async create(params) {
+    const {
+      pageElement
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey({
+        tenant: pageElement.tenant,
+        locale: pageElement.locale
+      }),
+      SK: this.createSortKey(pageElement)
+    };
+
+    try {
+      await this.entity.put(_objectSpread(_objectSpread({}, pageElement), {}, {
+        TYPE: this.createType()
+      }, keys));
+      return pageElement;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create pageElement.", ex.code || "PAGE_ELEMENT_CREATE_ERROR", {
+        keys,
+        pageElement
+      });
+    }
+  }
+
+  async update(params) {
+    const {
+      pageElement,
+      original
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey({
+        tenant: pageElement.tenant,
+        locale: pageElement.locale
+      }),
+      SK: this.createSortKey(pageElement)
+    };
+
+    try {
+      await this.entity.put(_objectSpread(_objectSpread({}, pageElement), {}, {
+        TYPE: this.createType()
+      }, keys));
+      return pageElement;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update pageElement.", ex.code || "PAGE_ELEMENT_UPDATE_ERROR", {
+        keys,
+        original,
+        pageElement
+      });
+    }
+  }
+
+  async delete(params) {
+    const {
+      pageElement
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey({
+        tenant: pageElement.tenant,
+        locale: pageElement.locale
+      }),
+      SK: this.createSortKey(pageElement)
+    };
+
+    try {
+      await this.entity.delete(keys);
+      return pageElement;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete pageElement.", ex.code || "PAGE_ELEMENT_DELETE_ERROR", {
+        keys,
+        pageElement
+      });
+    }
+  }
+
+  createPartitionKey({
+    tenant,
+    locale
+  }) {
+    return `T#${tenant}#L#${locale}#PB#PE`;
+  }
+
+  createSortKey(input) {
+    if (typeof input === "string") {
+      return input;
+    } else if (input.id) {
+      return input.id;
+    }
+
+    throw new _error.default("Could not determine the category sort key from the input.", "MALFORMED_SORT_KEY", {
+      input
+    });
+  }
+
+  createType() {
+    return "pb.pageElement";
+  }
+
+}
+
+exports.PageElementStorageOperationsDdbEs = PageElementStorageOperationsDdbEs;

package/operations/pageElement/fields.d.ts

@@ -0,0 +1,3 @@
+import { PageElementDynamoDbElasticFieldPlugin } from "../../plugins/definitions/PageElementDynamoDbElasticFieldPlugin";
+declare const _default: () => PageElementDynamoDbElasticFieldPlugin[];
+export default _default;

package/operations/pageElement/fields.js

@@ -0,0 +1,19 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _PageElementDynamoDbElasticFieldPlugin = require("../../plugins/definitions/PageElementDynamoDbElasticFieldPlugin");
+
+var _default = () => [new _PageElementDynamoDbElasticFieldPlugin.PageElementDynamoDbElasticFieldPlugin({
+  field: "createdOn",
+  type: "date"
+}), new _PageElementDynamoDbElasticFieldPlugin.PageElementDynamoDbElasticFieldPlugin({
+  field: "createdBy",
+  path: "createdBy.id",
+  sortable: false
+})];
+
+exports.default = _default;

package/operations/pageElement/index.d.ts

@@ -0,0 +1,7 @@
+import { PageElementStorageOperationsProviderPlugin } from "@webiny/api-page-builder/plugins/PageElementStorageOperationsProviderPlugin";
+import { PageElementStorageOperations } from "@webiny/api-page-builder/types";
+export declare class PageElementStorageOperationsDdbEsProviderPlugin extends PageElementStorageOperationsProviderPlugin {
+    provide({ context }: {
+        context: any;
+    }): Promise<PageElementStorageOperations>;
+}

package/operations/pageElement/index.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PageElementStorageOperationsDdbEsProviderPlugin = void 0;
+
+var _PageElementStorageOperationsProviderPlugin = require("@webiny/api-page-builder/plugins/PageElementStorageOperationsProviderPlugin");
+
+var _PageElementStorageOperations = require("./PageElementStorageOperations");
+
+var _fields = _interopRequireDefault(require("./fields"));
+
+class PageElementStorageOperationsDdbEsProviderPlugin extends _PageElementStorageOperationsProviderPlugin.PageElementStorageOperationsProviderPlugin {
+  async provide({
+    context
+  }) {
+    context.plugins.register((0, _fields.default)());
+    return new _PageElementStorageOperations.PageElementStorageOperationsDdbEs({
+      context
+    });
+  }
+
+}
+
+exports.PageElementStorageOperationsDdbEsProviderPlugin = PageElementStorageOperationsDdbEsProviderPlugin;