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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+# @webiny/api-page-builder-import-export-so-ddb
+
+[![](https://img.shields.io/npm/dw/@webiny/api-page-builder-so-ddb.svg)](https://www.npmjs.com/package/@webiny/api-page-builder-so-ddb)
+[![](https://img.shields.io/npm/v/@webiny/api-page-builder-so-ddb.svg)](https://www.npmjs.com/package/@webiny/api-page-builder-so-ddb)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+## Install
+
+```
+npm install --save @webiny/api-page-builder-import-export-so-ddb
+```
+
+Or if you prefer yarn:
+
+```
+yarn add @webiny/api-page-builder-import-export-so-ddb
+```
+
+
+## Testing
+To run the tests only for this package you must filter it with keywords.
+
+### Env variables
+
+
+### Command
+````
+yarn test packages/api-page-builder-import-export --keyword=pbie:ddb --keyword=pbie:base
+````

package/definitions/pageImportExportTaskEntity.d.ts

@@ -0,0 +1,9 @@
+import { Entity, Table } from "dynamodb-toolbox";
+import { Attributes } from "../types";
+interface Params {
+    entityName: string;
+    table: Table;
+    attributes?: Attributes;
+}
+export declare const createPageImportExportTaskEntity: ({ entityName, table, attributes }: Params) => Entity<{}>;
+export {};

package/definitions/pageImportExportTaskEntity.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createPageImportExportTaskEntity = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _dynamodbToolbox = require("dynamodb-toolbox");
+
+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 createPageImportExportTaskEntity = ({
+  entityName,
+  table,
+  attributes
+}) => {
+  return new _dynamodbToolbox.Entity({
+    name: entityName,
+    table,
+    attributes: _objectSpread({
+      PK: {
+        partitionKey: true
+      },
+      SK: {
+        sortKey: true
+      },
+      GSI1_PK: {
+        type: "string"
+      },
+      GSI1_SK: {
+        type: "string"
+      },
+      TYPE: {
+        type: "string"
+      },
+      id: {
+        type: "string"
+      },
+      parent: {
+        type: "string"
+      },
+      status: {
+        type: "string"
+      },
+      data: {
+        type: "map"
+      },
+      input: {
+        type: "map"
+      },
+      stats: {
+        type: "map"
+      },
+      error: {
+        type: "map"
+      },
+      createdOn: {
+        type: "string"
+      },
+      createdBy: {
+        type: "map"
+      },
+      tenant: {
+        type: "string"
+      },
+      locale: {
+        type: "string"
+      }
+    }, attributes)
+  });
+};
+
+exports.createPageImportExportTaskEntity = createPageImportExportTaskEntity;

package/definitions/table.d.ts

@@ -0,0 +1,7 @@
+import { Table } from "dynamodb-toolbox";
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
+export interface Params {
+    table: string;
+    documentClient: DocumentClient;
+}
+export declare const createTable: ({ table, documentClient }: Params) => Table;

package/definitions/table.js

@@ -0,0 +1,28 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createTable = void 0;
+
+var _dynamodbToolbox = require("dynamodb-toolbox");
+
+const createTable = ({
+  table,
+  documentClient
+}) => {
+  return new _dynamodbToolbox.Table({
+    name: table || process.env.DB_TABLE_PAGE_BUILDER || process.env.DB_TABLE,
+    partitionKey: "PK",
+    sortKey: "SK",
+    DocumentClient: documentClient,
+    indexes: {
+      GSI1: {
+        partitionKey: "GSI1_PK",
+        sortKey: "GSI1_SK"
+      }
+    }
+  });
+};
+
+exports.createTable = createTable;

package/index.d.ts

@@ -0,0 +1,2 @@
+import { CreateStorageOperations } from "./types";
+export declare const createStorageOperations: CreateStorageOperations;

package/index.js

@@ -0,0 +1,400 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createStorageOperations = void 0;
+
+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 _listResponse = require("@webiny/db-dynamodb/utils/listResponse");
+
+var _table = require("./definitions/table");
+
+var _pageImportExportTaskEntity = require("./definitions/pageImportExportTaskEntity");
+
+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; }
+
+// @ts-ignore
+const createStorageOperations = params => {
+  const {
+    table: tableName,
+    documentClient,
+    attributes = {}
+  } = params;
+  const table = (0, _table.createTable)({
+    table: tableName,
+    documentClient
+  });
+  const entity = (0, _pageImportExportTaskEntity.createPageImportExportTaskEntity)({
+    entityName: "PageImportExportTask",
+    table,
+    attributes
+  });
+  const PARENT_TASK_GSI1_PK = "PB#IE_TASKS";
+  return {
+    getTable() {
+      return table;
+    },
+
+    getEntity() {
+      return entity;
+    },
+
+    createPartitionKey({
+      tenant,
+      locale,
+      id
+    }) {
+      return `T#${tenant}#L#${locale}#PB#IE_TASK#${id}`;
+    },
+
+    createSortKey(input) {
+      return `SUB#${input}`;
+    },
+
+    createGsiPartitionKey({
+      tenant,
+      locale,
+      id
+    }) {
+      return `T#${tenant}#L#${locale}#PB#IE_TASK#${id}`;
+    },
+
+    createGsiSortKey(status, id) {
+      return `S#${status}#${id}`;
+    },
+
+    createType() {
+      return "pb.pageImportExportTask";
+    },
+
+    async getTask(params) {
+      const {
+        where
+      } = params;
+      const keys = {
+        PK: this.createPartitionKey(where),
+        SK: "A"
+      };
+
+      try {
+        const result = await entity.get(keys);
+
+        if (!result || !result.Item) {
+          return null;
+        }
+
+        return (0, _cleanup.cleanupItem)(entity, result.Item);
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not load page element by given parameters.", ex.code || "PAGE_IMPORT_EXPORT_TASK_GET_ERROR", {
+          where
+        });
+      }
+    },
+
+    async listTasks(params) {
+      const {
+        limit
+      } = params;
+      const queryAllParams = {
+        entity: entity,
+        partitionKey: PARENT_TASK_GSI1_PK,
+        options: {
+          beginsWith: "",
+          index: "GSI1",
+          limit: limit || undefined
+        }
+      };
+      let results = [];
+
+      try {
+        results = await (0, _query.queryAll)(queryAllParams);
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not list page import export tasks by given parameters.", ex.code || "PAGE_IMPORT_EXPORT_TASKS_LIST_ERROR", {
+          partitionKey: queryAllParams.partitionKey,
+          options: queryAllParams.options
+        });
+      }
+
+      const items = results.map(item => (0, _cleanup.cleanupItem)(entity, item)); // TODO: Implement sort and filter
+
+      return (0, _listResponse.createListResponse)({
+        items: items,
+        limit,
+        totalCount: items.length,
+        after: null
+      });
+    },
+
+    async createTask(params) {
+      const {
+        task
+      } = params;
+      const keys = {
+        PK: this.createPartitionKey({
+          tenant: task.tenant,
+          locale: task.locale,
+          id: task.id
+        }),
+        SK: "A",
+        GSI1_PK: PARENT_TASK_GSI1_PK,
+        GSI1_SK: task.createdOn
+      };
+
+      try {
+        await entity.put(_objectSpread(_objectSpread({}, task), {}, {
+          TYPE: this.createType()
+        }, keys));
+        return task;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not create pageImportExportTask.", ex.code || "PAGE_IMPORT_EXPORT_TASK_CREATE_ERROR", {
+          keys,
+          pageImportExportTask: task
+        });
+      }
+    },
+
+    async updateTask(params) {
+      const {
+        task,
+        original
+      } = params;
+      const keys = {
+        PK: this.createPartitionKey({
+          tenant: task.tenant,
+          locale: task.locale,
+          id: task.id
+        }),
+        SK: "A",
+        GSI1_PK: PARENT_TASK_GSI1_PK,
+        GSI1_SK: task.createdOn
+      };
+
+      try {
+        await entity.put(_objectSpread(_objectSpread({}, task), {}, {
+          TYPE: this.createType()
+        }, keys));
+        return task;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not update pageImportExportTask.", ex.code || "PAGE_IMPORT_EXPORT_TASK_UPDATE_ERROR", {
+          keys,
+          original,
+          task: task
+        });
+      }
+    },
+
+    async deleteTask(params) {
+      const {
+        task
+      } = params;
+      const keys = {
+        PK: this.createPartitionKey({
+          tenant: task.tenant,
+          locale: task.locale,
+          id: task.id
+        }),
+        SK: "A"
+      };
+
+      try {
+        await entity.delete(keys);
+        return task;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not delete pageImportExportTask.", ex.code || "PAGE_IMPORT_EXPORT_TASK_DELETE_ERROR", {
+          keys,
+          task: task
+        });
+      }
+    },
+
+    async updateTaskStats(params) {
+      const {
+        original,
+        input: {
+          prevStatus,
+          nextStatus
+        }
+      } = params;
+      const keys = {
+        PK: this.createPartitionKey({
+          tenant: original.tenant,
+          locale: original.locale,
+          id: original.id
+        }),
+        SK: "A",
+        GSI1_PK: PARENT_TASK_GSI1_PK,
+        GSI1_SK: original.createdOn
+      };
+
+      try {
+        await entity.update(_objectSpread(_objectSpread({
+          TYPE: this.createType()
+        }, keys), {}, {
+          stats: {
+            $set: {
+              [prevStatus]: {
+                $add: -1
+              },
+              [nextStatus]: {
+                $add: 1
+              }
+            }
+          }
+        }));
+        return original;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not update pageImportExportTask.", ex.code || "PAGE_IMPORT_EXPORT_TASK_UPDATE_ERROR", {
+          keys,
+          original
+        });
+      }
+    },
+
+    async createSubTask(params) {
+      const {
+        subTask
+      } = params;
+      const pkParams = {
+        tenant: subTask.tenant,
+        locale: subTask.locale,
+        id: subTask.parent
+      };
+      const keys = {
+        PK: this.createPartitionKey(pkParams),
+        SK: this.createSortKey(subTask.id),
+        GSI1_PK: this.createGsiPartitionKey(pkParams),
+        GSI1_SK: this.createGsiSortKey(subTask.status, subTask.id)
+      };
+
+      try {
+        await entity.put(_objectSpread(_objectSpread({}, subTask), {}, {
+          TYPE: this.createType()
+        }, keys));
+        return subTask;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not create pageImportExportSubTask.", ex.code || "CREATE_PAGE_IMPORT_EXPORT_SUB_TASK_ERROR", {
+          keys,
+          subTask: subTask
+        });
+      }
+    },
+
+    async updateSubTask(params) {
+      const {
+        subTask,
+        original
+      } = params;
+      const pkParams = {
+        tenant: subTask.tenant,
+        locale: subTask.locale,
+        id: subTask.parent
+      };
+      const keys = {
+        PK: this.createPartitionKey(pkParams),
+        SK: this.createSortKey(subTask.id),
+        GSI1_PK: this.createGsiPartitionKey(pkParams),
+        GSI1_SK: this.createGsiSortKey(subTask.status, subTask.id)
+      };
+
+      try {
+        await entity.put(_objectSpread(_objectSpread({}, subTask), {}, {
+          TYPE: this.createType()
+        }, keys));
+        return subTask;
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not update pageImportExportSubTask.", ex.code || "UPDATE_PAGE_IMPORT_EXPORT_SUB_TASK_ERROR", {
+          keys,
+          original,
+          subTask: subTask
+        });
+      }
+    },
+
+    async getSubTask(params) {
+      const {
+        where
+      } = params;
+      const keys = {
+        PK: this.createPartitionKey({
+          tenant: where.tenant,
+          locale: where.locale,
+          id: where.parent
+        }),
+        SK: this.createSortKey(where.id)
+      };
+
+      try {
+        const result = await entity.get(keys);
+
+        if (!result || !result.Item) {
+          return null;
+        }
+
+        return (0, _cleanup.cleanupItem)(entity, result.Item);
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not load page import export subTask by given parameters.", ex.code || "PAGE_IMPORT_EXPORT_TASK_GET_ERROR", {
+          where
+        });
+      }
+    },
+
+    async listSubTasks(params) {
+      const {
+        where,
+        limit
+      } = params;
+      const {
+        tenant,
+        locale,
+        parent,
+        status
+      } = where;
+      const queryAllParams = {
+        entity: entity,
+        partitionKey: this.createGsiPartitionKey({
+          tenant,
+          locale,
+          id: parent
+        }),
+        options: {
+          beginsWith: `S#${status}`,
+          limit: limit || undefined,
+          index: "GSI1"
+        }
+      };
+      let results = [];
+
+      try {
+        results = await (0, _query.queryAll)(queryAllParams);
+      } catch (ex) {
+        throw new _error.default(ex.message || "Could not list page import export tasks by given parameters.", ex.code || "LIST_PAGE_IMPORT_EXPORT_SUB_TASKS_ERROR", {
+          partitionKey: queryAllParams.partitionKey,
+          options: queryAllParams.options
+        });
+      }
+
+      const items = results.map(item => (0, _cleanup.cleanupItem)(entity, item));
+      return (0, _listResponse.createListResponse)({
+        items: items,
+        limit,
+        totalCount: items.length,
+        after: null
+      });
+    }
+
+  };
+};
+
+exports.createStorageOperations = createStorageOperations;

package/package.json

@@ -0,0 +1,54 @@
+{
+	"name": "@webiny/api-page-builder-import-export-so-ddb",
+	"version": "0.0.0-mt-1",
+	"main": "index.js",
+	"keywords": [
+		"@webiny/api-page-builder-import-export",
+		"storage-operations",
+		"dynamodb",
+		"pbie:ddb"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-page-builder-import-export-so-ddb"
+	},
+	"author": "Webiny Ltd",
+	"description": "The DynamoDB storage operations for import export feature in the Webiny Page Builder API.",
+	"license": "MIT",
+	"dependencies": {
+		"@babel/runtime": "7.15.4",
+		"@webiny/api-page-builder-import-export": "0.0.0-mt-1",
+		"@webiny/db-dynamodb": "0.0.0-mt-1",
+		"@webiny/error": "0.0.0-mt-1",
+		"dynamodb-toolbox": "0.3.4"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.5.5",
+		"@babel/core": "^7.5.5",
+		"@babel/preset-env": "^7.5.5",
+		"@babel/preset-typescript": "^7.8.3",
+		"@webiny/api-security": "^0.0.0-mt-1",
+		"@webiny/api-tenancy": "^0.0.0-mt-1",
+		"@webiny/cli": "^0.0.0-mt-1",
+		"@webiny/handler": "^0.0.0-mt-1",
+		"@webiny/handler-aws": "^0.0.0-mt-1",
+		"@webiny/handler-graphql": "^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": "^27.0.6",
+		"rimraf": "^3.0.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"
+}

package/types.d.ts

@@ -0,0 +1,18 @@
+import { DynamoDBTypes } from "dynamodb-toolbox/dist/classes/Table";
+import { EntityAttributeConfig, EntityCompositeAttributes } from "dynamodb-toolbox/dist/classes/Entity";
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
+import { PageImportExportTaskStorageOperations } from "@webiny/api-page-builder-import-export/types";
+export declare type AttributeDefinition = DynamoDBTypes | EntityAttributeConfig | EntityCompositeAttributes;
+export declare type Attributes = Record<string, AttributeDefinition>;
+export interface PartitionKeyOptions {
+    tenant: string;
+    locale: string;
+    id?: string;
+}
+export interface CreateStorageOperations {
+    (params: {
+        documentClient: DocumentClient;
+        table?: string;
+        attributes?: Attributes;
+    }): PageImportExportTaskStorageOperations;
+}

package/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});