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

package/operations/submission/index.js

@@ -0,0 +1,340 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSubmissionStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _batchRead = require("@webiny/db-dynamodb/utils/batchRead");
+
+var _sort = require("@webiny/db-dynamodb/utils/sort");
+
+var _limit = require("@webiny/api-elasticsearch/limit");
+
+var _elasticsearchBody = require("./elasticsearchBody");
+
+var _configurations = _interopRequireDefault(require("../../configurations"));
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _utils = require("@webiny/utils");
+
+var _cursors = require("@webiny/api-elasticsearch/cursors");
+
+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 createSubmissionStorageOperations = params => {
+  const {
+    entity,
+    esEntity,
+    table,
+    elasticsearch,
+    plugins
+  } = params;
+
+  const createSubmissionPartitionKey = params => {
+    const {
+      tenant,
+      locale,
+      formId
+    } = params;
+    const {
+      id
+    } = (0, _utils.parseIdentifier)(formId);
+    return `T#${tenant}#L#${locale}#FB#F#${id}`;
+  };
+
+  const createSubmissionSortKey = id => {
+    return `FS#${id}`;
+  };
+
+  const createSubmissionType = () => {
+    return "fb.formSubmission";
+  };
+
+  const createSubmission = async params => {
+    const {
+      submission,
+      form
+    } = params;
+    const keys = {
+      PK: createSubmissionPartitionKey(form),
+      SK: createSubmissionSortKey(submission.id)
+    };
+
+    try {
+      await entity.put(_objectSpread(_objectSpread(_objectSpread({}, submission), keys), {}, {
+        TYPE: createSubmissionType()
+      }));
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create form submission in the DynamoDB.", ex.code || "UPDATE_FORM_SUBMISSION_ERROR", {
+        submission,
+        form,
+        keys
+      });
+    }
+
+    try {
+      const {
+        index
+      } = _configurations.default.es({
+        tenant: form.tenant
+      });
+
+      await esEntity.put(_objectSpread({
+        index,
+        data: _objectSpread(_objectSpread({}, submission), {}, {
+          __type: (0, _elasticsearchBody.createSubmissionElasticType)()
+        }),
+        TYPE: createSubmissionType()
+      }, keys));
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create form submission in the Elasticsearch.", ex.code || "UPDATE_FORM_SUBMISSION_ERROR", {
+        submission,
+        form,
+        keys
+      });
+    }
+
+    return submission;
+  };
+  /**
+   * We do not save the data in the Elasticsearch because there is no need for that.
+   */
+
+
+  const updateSubmission = async params => {
+    const {
+      submission,
+      form,
+      original
+    } = params;
+    const keys = {
+      PK: createSubmissionPartitionKey(form),
+      SK: createSubmissionSortKey(submission.id)
+    };
+
+    try {
+      await entity.put(_objectSpread(_objectSpread(_objectSpread({}, submission), keys), {}, {
+        TYPE: createSubmissionType()
+      }));
+      return submission;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update form submission in the DynamoDB.", ex.code || "UPDATE_FORM_SUBMISSION_ERROR", {
+        submission,
+        original,
+        form,
+        keys
+      });
+    }
+  };
+
+  const deleteSubmission = async params => {
+    const {
+      submission,
+      form
+    } = params;
+    const keys = {
+      PK: createSubmissionPartitionKey(form),
+      SK: createSubmissionSortKey(submission.id)
+    };
+
+    try {
+      await entity.delete(keys);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete form submission from DynamoDB.", ex.code || "DELETE_FORM_SUBMISSION_ERROR", {
+        submission,
+        form,
+        keys
+      });
+    }
+
+    try {
+      await esEntity.delete(keys);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete form submission from Elasticsearch.", ex.code || "DELETE_FORM_SUBMISSION_ERROR", {
+        submission,
+        form,
+        keys
+      });
+    }
+
+    return submission;
+  };
+  /**
+   *
+   * We are using this method because it is faster to fetch the exact data from the DynamoDB than Elasticsearch.
+   *
+   * @internal
+   */
+
+
+  const listSubmissionsByIds = async params => {
+    const {
+      where,
+      sort
+    } = params;
+    const items = where.id_in.map(id => {
+      return entity.getBatch({
+        PK: createSubmissionPartitionKey(_objectSpread({}, where)),
+        SK: createSubmissionSortKey(id)
+      });
+    });
+    let results = [];
+
+    try {
+      results = await (0, _batchRead.batchReadAll)({
+        table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not batch read form submissions.", ex.code || "BATCH_READ_SUBMISSIONS_ERROR", {
+        where,
+        sort
+      });
+    }
+    /**
+     * We need to remove empty results because it is a possibility that batch read returned null for non-existing record.
+     */
+
+
+    const submissions = results.filter(Boolean).map(submission => {
+      return (0, _cleanup.cleanupItem)(entity, submission);
+    });
+
+    if (!sort) {
+      return submissions;
+    }
+
+    return (0, _sort.sortItems)({
+      items: submissions,
+      sort,
+      fields: []
+    });
+  };
+
+  const listSubmissions = async params => {
+    const {
+      where,
+      sort,
+      limit: initialLimit,
+      after
+    } = params;
+
+    if (where.id_in) {
+      const items = await listSubmissionsByIds(params);
+      return {
+        items,
+        meta: {
+          hasMoreItems: false,
+          cursor: null,
+          totalCount: items.length
+        }
+      };
+    }
+
+    const limit = (0, _limit.createLimit)(initialLimit);
+    const body = (0, _elasticsearchBody.createElasticsearchBody)({
+      plugins,
+      sort,
+      limit: limit + 1,
+      where,
+      after: (0, _cursors.decodeCursor)(after)
+    });
+
+    const esConfig = _configurations.default.es({
+      tenant: where.tenant
+    });
+
+    const query = _objectSpread(_objectSpread({}, esConfig), {}, {
+      body
+    });
+
+    let response;
+
+    try {
+      response = await elasticsearch.search(query);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could list form submissions.", ex.code || "LIST_SUBMISSIONS_ERROR", {
+        where,
+        query
+      });
+    }
+
+    const {
+      hits,
+      total
+    } = response.body.hits;
+    const items = hits.map(item => item._source);
+    const hasMoreItems = items.length > limit;
+
+    if (hasMoreItems) {
+      /**
+       * Remove the last item from results, we don't want to include it.
+       */
+      items.pop();
+    }
+    /**
+     * Cursor is the `sort` value of the last item in the array.
+     * https://www.elastic.co/guide/en/elasticsearch/reference/current/paginate-search-results.html#search-after
+     */
+
+
+    const meta = {
+      hasMoreItems,
+      totalCount: total.value,
+      cursor: items.length > 0 ? (0, _cursors.encodeCursor)(hits[items.length - 1].sort) : null
+    };
+    return {
+      items,
+      meta
+    };
+  };
+
+  const getSubmission = async params => {
+    const {
+      where
+    } = params;
+    const keys = {
+      PK: createSubmissionPartitionKey(_objectSpread(_objectSpread({}, where), {}, {
+        formId: where.formId
+      })),
+      SK: createSubmissionSortKey(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 oad submission.", ex.code || "GET_SUBMISSION_ERROR", {
+        where,
+        keys
+      });
+    }
+  };
+
+  return {
+    createSubmission,
+    deleteSubmission,
+    updateSubmission,
+    listSubmissions,
+    getSubmission,
+    createSubmissionPartitionKey,
+    createSubmissionSortKey
+  };
+};
+
+exports.createSubmissionStorageOperations = createSubmissionStorageOperations;

package/operations/system/createElasticsearchIndex.d.ts

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

package/operations/system/createElasticsearchIndex.js

@@ -0,0 +1,70 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createElasticsearchIndex = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _configurations = _interopRequireDefault(require("../../configurations"));
+
+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 createElasticsearchIndex = async params => {
+  const {
+    tenant,
+    elasticsearch
+  } = params;
+
+  const esIndex = _configurations.default.es({
+    tenant
+  });
+
+  const {
+    body: exists
+  } = await elasticsearch.indices.exists(esIndex);
+
+  if (exists) {
+    return;
+  }
+
+  await elasticsearch.indices.create(_objectSpread(_objectSpread({}, esIndex), {}, {
+    body: {
+      /**
+       * need this part for sorting to work on text fields
+       */
+      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"
+          }
+        }
+      }
+    }
+  }));
+};
+
+exports.createElasticsearchIndex = createElasticsearchIndex;

package/operations/system/index.d.ts

@@ -0,0 +1,7 @@
+import { Entity, Table } from "dynamodb-toolbox";
+import { FormBuilderSystemStorageOperations } from "../../types";
+export interface Params {
+    entity: Entity<any>;
+    table: Table;
+}
+export declare const createSystemStorageOperations: (params: Params) => FormBuilderSystemStorageOperations;

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 _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+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 createSystemStorageOperations = params => {
+  const {
+    entity
+  } = params;
+
+  const createSystemPartitionKey = ({
+    tenant
+  }) => {
+    return `T#${tenant}#SYSTEM`;
+  };
+
+  const createSystemSortKey = () => {
+    return "FB";
+  };
+
+  const createKeys = params => {
+    return {
+      PK: createSystemPartitionKey(params),
+      SK: createSystemSortKey()
+    };
+  };
+
+  const createSystem = async params => {
+    const {
+      system
+    } = 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 create the system record by given keys.", ex.code || "CREATE_SYSTEM_ERROR", {
+        keys,
+        system
+      });
+    }
+  };
+
+  const getSystem = async params => {
+    const keys = createKeys(params);
+
+    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 get the system record by given keys.", ex.code || "LOAD_SYSTEM_ERROR", {
+        keys
+      });
+    }
+  };
+
+  const updateSystem = 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 the system record by given keys.", ex.code || "UPDATE_SYSTEM_ERROR", {
+        keys,
+        original,
+        system
+      });
+    }
+  };
+
+  return {
+    createSystem,
+    getSystem,
+    updateSystem,
+    createSystemPartitionKey,
+    createSystemSortKey
+  };
+};
+
+exports.createSystemStorageOperations = createSystemStorageOperations;

package/package.json

@@ -0,0 +1,67 @@
+{
+	"name": "@webiny/api-form-builder-so-ddb-es",
+	"version": "0.0.0-mt-1",
+	"main": "index.js",
+	"keywords": [
+		"@webiny/api-form-builder",
+		"storage-operations",
+		"dynamodb",
+		"elasticsearch",
+		"fb:ddb-es"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-form-builder-so-ddb-es"
+	},
+	"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",
+		"@elastic/elasticsearch": "7.12.0",
+		"@webiny/api-elasticsearch": "0.0.0-mt-1",
+		"@webiny/api-form-builder": "0.0.0-mt-1",
+		"@webiny/api-i18n": "0.0.0-mt-1",
+		"@webiny/api-tenancy": "0.0.0-mt-1",
+		"@webiny/api-upgrade": "0.0.0-mt-1",
+		"@webiny/db-dynamodb": "0.0.0-mt-1",
+		"@webiny/error": "0.0.0-mt-1",
+		"@webiny/handler": "0.0.0-mt-1",
+		"@webiny/handler-aws": "0.0.0-mt-1",
+		"@webiny/plugins": "0.0.0-mt-1",
+		"@webiny/utils": "0.0.0-mt-1",
+		"dynamodb-toolbox": "0.3.4",
+		"elastic-ts": "0.7.0"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.5.5",
+		"@babel/core": "^7.5.5",
+		"@babel/preset-env": "^7.5.5",
+		"@babel/preset-typescript": "^7.8.3",
+		"@shelf/jest-elasticsearch": "^1.0.0",
+		"@webiny/api-dynamodb-to-elasticsearch": "^0.0.0-mt-1",
+		"@webiny/cli": "^0.0.0-mt-1",
+		"@webiny/handler-db": "^0.0.0-mt-1",
+		"@webiny/project-utils": "^0.0.0-mt-1",
+		"csvtojson": "^2.0.10",
+		"jest": "^26.6.3",
+		"jest-dynalite": "^3.2.0",
+		"jest-environment-node": "^27.2.4",
+		"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/plugins/FormDynamoDbFieldPlugin.d.ts

@@ -0,0 +1,4 @@
+import { FieldPlugin } from "@webiny/db-dynamodb/plugins/definitions/FieldPlugin";
+export declare class FormDynamoDbFieldPlugin extends FieldPlugin {
+    static readonly type: string;
+}

package/plugins/FormDynamoDbFieldPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormDynamoDbFieldPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _FieldPlugin = require("@webiny/db-dynamodb/plugins/definitions/FieldPlugin");
+
+class FormDynamoDbFieldPlugin extends _FieldPlugin.FieldPlugin {}
+
+exports.FormDynamoDbFieldPlugin = FormDynamoDbFieldPlugin;
+(0, _defineProperty2.default)(FormDynamoDbFieldPlugin, "type", "formBuilder.dynamodb.field.form");

package/plugins/FormElasticsearchBodyModifierPlugin.d.ts

@@ -0,0 +1,4 @@
+import { ElasticsearchBodyModifierPlugin } from "@webiny/api-elasticsearch/plugins/definition/ElasticsearchBodyModifierPlugin";
+export declare class FormElasticsearchBodyModifierPlugin extends ElasticsearchBodyModifierPlugin {
+    static readonly type: string;
+}

package/plugins/FormElasticsearchBodyModifierPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormElasticsearchBodyModifierPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchBodyModifierPlugin = require("@webiny/api-elasticsearch/plugins/definition/ElasticsearchBodyModifierPlugin");
+
+class FormElasticsearchBodyModifierPlugin extends _ElasticsearchBodyModifierPlugin.ElasticsearchBodyModifierPlugin {}
+
+exports.FormElasticsearchBodyModifierPlugin = FormElasticsearchBodyModifierPlugin;
+(0, _defineProperty2.default)(FormElasticsearchBodyModifierPlugin, "type", "formBuilder.elasticsearch.modifier.body.form");

package/plugins/FormElasticsearchFieldPlugin.d.ts

@@ -0,0 +1,4 @@
+import { ElasticsearchFieldPlugin } from "@webiny/api-elasticsearch/plugins/definition/ElasticsearchFieldPlugin";
+export declare class FormElasticsearchFieldPlugin extends ElasticsearchFieldPlugin {
+    static readonly type: string;
+}

package/plugins/FormElasticsearchFieldPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormElasticsearchFieldPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchFieldPlugin = require("@webiny/api-elasticsearch/plugins/definition/ElasticsearchFieldPlugin");
+
+class FormElasticsearchFieldPlugin extends _ElasticsearchFieldPlugin.ElasticsearchFieldPlugin {}
+
+exports.FormElasticsearchFieldPlugin = FormElasticsearchFieldPlugin;
+(0, _defineProperty2.default)(FormElasticsearchFieldPlugin, "type", "formBuilder.elasticsearch.fieldDefinition.form");

package/plugins/FormElasticsearchQueryModifierPlugin.d.ts

@@ -0,0 +1,4 @@
+import { ElasticsearchQueryModifierPlugin } from "@webiny/api-elasticsearch/plugins/definition/ElasticsearchQueryModifierPlugin";
+export declare class FormElasticsearchQueryModifierPlugin extends ElasticsearchQueryModifierPlugin {
+    static readonly type: string;
+}

package/plugins/FormElasticsearchQueryModifierPlugin.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FormElasticsearchQueryModifierPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryModifierPlugin = require("@webiny/api-elasticsearch/plugins/definition/ElasticsearchQueryModifierPlugin");
+
+class FormElasticsearchQueryModifierPlugin extends _ElasticsearchQueryModifierPlugin.ElasticsearchQueryModifierPlugin {}
+
+exports.FormElasticsearchQueryModifierPlugin = FormElasticsearchQueryModifierPlugin;
+(0, _defineProperty2.default)(FormElasticsearchQueryModifierPlugin, "type", "formBuilder.elasticsearch.modifier.query.form");