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

package/operations/form/index.js

@@ -0,0 +1,903 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFormStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _query = require("@webiny/db-dynamodb/utils/query");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _batchWrite = require("@webiny/db-dynamodb/utils/batchWrite");
+
+var _configurations = _interopRequireDefault(require("../../configurations"));
+
+var _filter = require("@webiny/db-dynamodb/utils/filter");
+
+var _fields = _interopRequireDefault(require("./fields"));
+
+var _sort = require("@webiny/db-dynamodb/utils/sort");
+
+var _utils = require("@webiny/utils");
+
+var _elasticsearchBody = require("./elasticsearchBody");
+
+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 getESDataForLatestRevision = form => ({
+  __type: (0, _elasticsearchBody.createFormElasticType)(),
+  id: form.id,
+  createdOn: form.createdOn,
+  savedOn: form.savedOn,
+  name: form.name,
+  slug: form.slug,
+  published: form.published,
+  publishedOn: form.publishedOn,
+  version: form.version,
+  locked: form.locked,
+  status: form.status,
+  createdBy: form.createdBy,
+  ownedBy: form.ownedBy,
+  tenant: form.tenant,
+  locale: form.locale,
+  webinyVersion: form.webinyVersion,
+  formId: form.formId
+});
+
+const createFormStorageOperations = params => {
+  const {
+    entity,
+    esEntity,
+    table,
+    plugins,
+    elasticsearch
+  } = params;
+  const formDynamoDbFields = (0, _fields.default)();
+
+  const createFormPartitionKey = params => {
+    const {
+      tenant,
+      locale,
+      id: targetId
+    } = params;
+    const {
+      id
+    } = (0, _utils.parseIdentifier)(targetId);
+    return `T#${tenant}#L#${locale}#FB#F#${id}`;
+  };
+
+  const createRevisionSortKey = value => {
+    const version = typeof value === "number" ? Number(value) : (0, _utils.parseIdentifier)(value).version;
+    return `REV#${(0, _utils.zeroPad)(version)}`;
+  };
+
+  const createLatestSortKey = () => {
+    return "L";
+  };
+
+  const createLatestPublishedSortKey = () => {
+    return "LP";
+  };
+
+  const createFormType = () => {
+    return "fb.form";
+  };
+
+  const createFormLatestType = () => {
+    return "fb.form.latest";
+  };
+
+  const createFormLatestPublishedType = () => {
+    return "fb.form.latestPublished";
+  };
+
+  const createForm = async params => {
+    const {
+      form
+    } = params;
+    const revisionKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createRevisionSortKey(form.id)
+    };
+    const latestKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createLatestSortKey()
+    };
+    const items = [entity.putBatch(_objectSpread(_objectSpread({}, form), {}, {
+      TYPE: createFormType()
+    }, revisionKeys)), entity.putBatch(_objectSpread(_objectSpread({}, form), {}, {
+      TYPE: createFormLatestType()
+    }, latestKeys))];
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not insert form data into regular table.", ex.code || "CREATE_FORM_ERROR", {
+        revisionKeys,
+        latestKeys,
+        form
+      });
+    }
+
+    try {
+      const {
+        index
+      } = _configurations.default.es({
+        tenant: form.tenant
+      });
+
+      await esEntity.put(_objectSpread({
+        index,
+        data: getESDataForLatestRevision(form),
+        TYPE: createFormType()
+      }, latestKeys));
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not insert form data into Elasticsearch table.", ex.code || "CREATE_FORM_ERROR", {
+        latestKeys,
+        form
+      });
+    }
+
+    return form;
+  };
+
+  const createFormFrom = async params => {
+    const {
+      form,
+      original,
+      latest
+    } = params;
+    const revisionKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createRevisionSortKey(form.version)
+    };
+    const latestKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createLatestSortKey()
+    };
+    const items = [entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, form), revisionKeys), {}, {
+      TYPE: createFormType()
+    })), entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, form), latestKeys), {}, {
+      TYPE: createFormLatestType()
+    }))];
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create form data in the regular table, from existing form.", ex.code || "CREATE_FORM_FROM_ERROR", {
+        revisionKeys,
+        latestKeys,
+        original,
+        form,
+        latest
+      });
+    }
+
+    try {
+      const {
+        index
+      } = _configurations.default.es({
+        tenant: form.tenant
+      });
+
+      await esEntity.put(_objectSpread({
+        index,
+        data: getESDataForLatestRevision(form),
+        TYPE: createFormLatestType()
+      }, latestKeys));
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create form in the Elasticsearch table, from existing form.", ex.code || "CREATE_FORM_FROM_ERROR", {
+        latestKeys,
+        form,
+        latest,
+        original
+      });
+    }
+
+    return form;
+  };
+
+  const updateForm = async params => {
+    const {
+      form,
+      original
+    } = params;
+    const revisionKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createRevisionSortKey(form.id)
+    };
+    const latestKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createLatestSortKey()
+    };
+    const {
+      formId,
+      tenant,
+      locale
+    } = form;
+    const latestForm = await getForm({
+      where: {
+        formId,
+        tenant,
+        locale,
+        latest: true
+      }
+    });
+    const isLatestForm = latestForm ? latestForm.id === form.id : false;
+    const items = [entity.putBatch(_objectSpread(_objectSpread({}, form), {}, {
+      TYPE: createFormType()
+    }, revisionKeys))];
+
+    if (isLatestForm) {
+      items.push(entity.putBatch(_objectSpread(_objectSpread({}, form), {}, {
+        TYPE: createFormLatestType()
+      }, latestKeys)));
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update form data in the regular table.", ex.code || "UPDATE_FORM_ERROR", {
+        revisionKeys,
+        latestKeys,
+        original,
+        form,
+        latestForm
+      });
+    }
+    /**
+     * No need to go further if its not latest form.
+     */
+
+
+    if (!isLatestForm) {
+      return form;
+    }
+
+    try {
+      const {
+        index
+      } = _configurations.default.es({
+        tenant: form.tenant
+      });
+
+      await esEntity.put(_objectSpread({
+        index,
+        data: getESDataForLatestRevision(form),
+        TYPE: createFormLatestType()
+      }, latestKeys));
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update form data in the Elasticsearch table.", ex.code || "UPDATE_FORM_ERROR", {
+        latestKeys,
+        form,
+        latestForm,
+        original
+      });
+    }
+
+    return form;
+  };
+
+  const getForm = async params => {
+    const {
+      where
+    } = params;
+    const {
+      id,
+      formId,
+      latest,
+      published,
+      version,
+      tenant,
+      locale
+    } = where;
+
+    if (latest && published) {
+      throw new _error.default("Cannot have both latest and published params.");
+    }
+
+    let sortKey;
+
+    if (latest) {
+      sortKey = createLatestSortKey();
+    } else if (published && !version) {
+      /**
+       * Because of the specifics how DynamoDB works, we must not load the published record if version is sent.
+       */
+      sortKey = createLatestPublishedSortKey();
+    } else if (id || version) {
+      sortKey = createRevisionSortKey(version || id);
+    } else {
+      throw new _error.default("Missing parameter to create a sort key.", "MISSING_WHERE_PARAMETER", {
+        where
+      });
+    }
+
+    const keys = {
+      PK: createFormPartitionKey({
+        tenant,
+        locale,
+        id: formId || id
+      }),
+      SK: sortKey
+    };
+
+    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 form by keys.", ex.code || "GET_FORM_ERROR", {
+        keys
+      });
+    }
+  };
+
+  const listForms = async params => {
+    const {
+      sort,
+      limit,
+      where,
+      after
+    } = params;
+    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 forms.", ex.code || "LIST_FORMS_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 listFormRevisions = async params => {
+    const {
+      where: initialWhere,
+      sort
+    } = params;
+    const {
+      id,
+      formId,
+      tenant,
+      locale
+    } = initialWhere;
+    const queryAllParams = {
+      entity,
+      partitionKey: createFormPartitionKey({
+        tenant,
+        locale,
+        id: id || formId
+      }),
+      options: {
+        beginsWith: "REV#"
+      }
+    };
+    let items = [];
+
+    try {
+      items = await (0, _query.queryAll)(queryAllParams);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not query forms by given params.", ex.code || "QUERY_FORMS_ERROR", {
+        partitionKey: queryAllParams.partitionKey,
+        options: queryAllParams.options
+      });
+    }
+
+    const where = _objectSpread(_objectSpread({}, initialWhere), {}, {
+      id: undefined,
+      formId: undefined
+    });
+
+    const filteredItems = (0, _filter.filterItems)({
+      plugins,
+      items,
+      where,
+      fields: formDynamoDbFields
+    });
+
+    if (Array.isArray(sort) === false || sort.length === 0) {
+      return filteredItems;
+    }
+
+    return (0, _sort.sortItems)({
+      items: filteredItems,
+      sort,
+      fields: formDynamoDbFields
+    });
+  };
+
+  const deleteForm = async params => {
+    const {
+      form
+    } = params;
+    let items;
+    /**
+     * This will find all form and submission records.
+     */
+
+    const queryAllParams = {
+      entity,
+      partitionKey: createFormPartitionKey(form),
+      options: {
+        gte: " "
+      }
+    };
+
+    try {
+      items = await (0, _query.queryAll)(queryAllParams);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not query forms and submissions by given params.", ex.code || "QUERY_FORM_AND_SUBMISSIONS_ERROR", {
+        partitionKey: queryAllParams.partitionKey,
+        options: queryAllParams.options
+      });
+    }
+
+    const deleteItems = items.map(item => {
+      return entity.deleteBatch({
+        PK: item.PK,
+        SK: item.SK
+      });
+    });
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table,
+        items: deleteItems
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete form and it's submissions.", ex.code || "DELETE_FORM_AND_SUBMISSIONS_ERROR");
+    }
+
+    const latestKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createLatestSortKey()
+    };
+
+    try {
+      await esEntity.delete(latestKeys);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete latest form record from Elasticsearch.", ex.code || "DELETE_FORM_ERROR", {
+        latestKeys
+      });
+    }
+
+    return form;
+  };
+  /**
+   * We need to:
+   * - delete current revision
+   * - get previously published revision and update the record if it exists or delete if it does not
+   * - update latest record if current one is the latest
+   */
+
+
+  const deleteFormRevision = async params => {
+    const {
+      form,
+      revisions,
+      previous
+    } = params;
+    const revisionKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createRevisionSortKey(form.id)
+    };
+    const latestKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createLatestSortKey()
+    };
+    const latestForm = revisions[0];
+    const latestPublishedForm = revisions.find(rev => rev.published === true);
+    const isLatest = latestForm ? latestForm.id === form.id : false;
+    const isLatestPublished = latestPublishedForm ? latestPublishedForm.id === form.id : false;
+    const items = [entity.deleteBatch(revisionKeys)];
+    let esDataItem = undefined;
+
+    if (isLatest || isLatestPublished) {
+      /**
+       * Sort out the latest published record.
+       */
+      if (isLatestPublished) {
+        const previouslyPublishedForm = revisions.filter(f => !!f.publishedOn && f.version !== form.version).sort((a, b) => {
+          return new Date(b.publishedOn).getTime() - new Date(a.publishedOn).getTime();
+        }).shift();
+
+        if (previouslyPublishedForm) {
+          items.push(entity.putBatch(_objectSpread(_objectSpread({}, previouslyPublishedForm), {}, {
+            PK: createFormPartitionKey(previouslyPublishedForm),
+            SK: createLatestPublishedSortKey(),
+            TYPE: createFormLatestPublishedType()
+          })));
+        } else {
+          items.push(entity.deleteBatch({
+            PK: createFormPartitionKey(previouslyPublishedForm),
+            SK: createLatestPublishedSortKey()
+          }));
+        }
+      }
+      /**
+       * Sort out the latest record.
+       */
+
+
+      if (isLatest) {
+        items.push(entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, previous), latestKeys), {}, {
+          TYPE: createFormLatestType()
+        })));
+
+        const {
+          index
+        } = _configurations.default.es({
+          tenant: previous.tenant
+        });
+
+        esDataItem = _objectSpread(_objectSpread({
+          index
+        }, latestKeys), {}, {
+          data: getESDataForLatestRevision(previous)
+        });
+      }
+    }
+    /**
+     * Now save the batch data.
+     */
+
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete form revision from regular table.", ex.code || "DELETE_FORM_REVISION_ERROR", {
+        form,
+        latestForm,
+        revisionKeys,
+        latestKeys
+      });
+    }
+    /**
+     * And then the Elasticsearch data, if any.
+     */
+
+
+    if (!esDataItem) {
+      return form;
+    }
+
+    try {
+      await esEntity.put(esDataItem);
+      return form;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete form from to the Elasticsearch table.", ex.code || "DELETE_FORM_REVISION_ERROR", {
+        form,
+        latestForm,
+        revisionKeys,
+        latestKeys
+      });
+    }
+  };
+  /**
+   * We need to save form in:
+   * - regular form record
+   * - latest published form record
+   * - latest form record - if form is latest one
+   * - elasticsearch latest form record
+   */
+
+
+  const publishForm = async params => {
+    const {
+      form,
+      original
+    } = params;
+    const revisionKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createRevisionSortKey(form.version)
+    };
+    const latestKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createLatestSortKey()
+    };
+    const latestPublishedKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createLatestPublishedSortKey()
+    };
+    const {
+      locale,
+      tenant,
+      formId
+    } = form;
+    const latestForm = await getForm({
+      where: {
+        formId,
+        tenant,
+        locale,
+        latest: true
+      }
+    });
+    const isLatestForm = latestForm ? latestForm.id === form.id : false;
+    /**
+     * Update revision and latest published records
+     */
+
+    const items = [entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, form), revisionKeys), {}, {
+      TYPE: createFormType()
+    })), entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, form), latestPublishedKeys), {}, {
+      TYPE: createFormLatestPublishedType()
+    }))];
+    /**
+     * Update the latest form as well
+     */
+
+    if (isLatestForm) {
+      items.push(entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, form), latestKeys), {}, {
+        TYPE: createFormLatestType()
+      })));
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not publish form.", ex.code || "PUBLISH_FORM_ERROR", {
+        form,
+        original,
+        latestForm,
+        revisionKeys,
+        latestKeys,
+        latestPublishedKeys
+      });
+    }
+
+    if (!isLatestForm) {
+      return form;
+    }
+
+    const {
+      index
+    } = _configurations.default.es({
+      tenant: form.tenant
+    });
+
+    const esData = getESDataForLatestRevision(form);
+
+    try {
+      await esEntity.put(_objectSpread(_objectSpread({}, latestKeys), {}, {
+        index,
+        TYPE: createFormLatestType(),
+        data: esData
+      }));
+      return form;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not publish form to the Elasticsearch.", ex.code || "PUBLISH_FORM_ERROR", {
+        form,
+        original,
+        latestForm,
+        revisionKeys,
+        latestKeys,
+        latestPublishedKeys
+      });
+    }
+  };
+  /**
+   * We need to:
+   * - update form revision record
+   * - if latest published (LP) is current form, find the previously published record and update LP if there is some previously published, delete otherwise
+   * - if is latest update the Elasticsearch record
+   */
+
+
+  const unpublishForm = async params => {
+    const {
+      form,
+      original
+    } = params;
+    const revisionKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createRevisionSortKey(form.version)
+    };
+    const latestKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createLatestSortKey()
+    };
+    const latestPublishedKeys = {
+      PK: createFormPartitionKey(form),
+      SK: createLatestPublishedSortKey()
+    };
+    const {
+      formId,
+      tenant,
+      locale
+    } = form;
+    const latestForm = await getForm({
+      where: {
+        formId,
+        tenant,
+        locale,
+        latest: true
+      }
+    });
+    const latestPublishedForm = await getForm({
+      where: {
+        formId,
+        tenant,
+        locale,
+        published: true
+      }
+    });
+    const isLatest = latestForm ? latestForm.id === form.id : false;
+    const isLatestPublished = latestPublishedForm ? latestPublishedForm.id === form.id : false;
+    const items = [entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, form), revisionKeys), {}, {
+      TYPE: createFormType()
+    }))];
+    let esData = undefined;
+
+    if (isLatest) {
+      esData = getESDataForLatestRevision(form);
+    }
+    /**
+     * In case previously published revision exists, replace current one with that one.
+     * And if it does not, delete the record.
+     */
+
+
+    if (isLatestPublished) {
+      const revisions = await listFormRevisions({
+        where: {
+          formId,
+          tenant,
+          locale,
+          version_not: form.version,
+          publishedOn_not: null
+        },
+        sort: ["savedOn_DESC"]
+      });
+      const previouslyPublishedRevision = revisions.shift();
+
+      if (previouslyPublishedRevision) {
+        items.push(entity.putBatch(_objectSpread(_objectSpread(_objectSpread({}, previouslyPublishedRevision), latestPublishedKeys), {}, {
+          TYPE: createFormLatestPublishedType()
+        })));
+      } else {
+        items.push(entity.deleteBatch(latestPublishedKeys));
+      }
+    }
+
+    try {
+      await (0, _batchWrite.batchWriteAll)({
+        table,
+        items
+      });
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not unpublish form.", ex.code || "UNPUBLISH_FORM_ERROR", {
+        form,
+        original,
+        latestForm,
+        revisionKeys,
+        latestKeys,
+        latestPublishedKeys
+      });
+    }
+    /**
+     * No need to go further in case of non-existing Elasticsearch data.
+     */
+
+
+    if (!esData) {
+      return form;
+    }
+
+    const {
+      index
+    } = _configurations.default.es({
+      tenant: form.tenant
+    });
+
+    try {
+      await esEntity.put(_objectSpread(_objectSpread({}, latestKeys), {}, {
+        index,
+        TYPE: createFormLatestType(),
+        data: esData
+      }));
+      return form;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not unpublish form from the Elasticsearch.", ex.code || "UNPUBLISH_FORM_ERROR", {
+        form,
+        original,
+        latestForm,
+        revisionKeys,
+        latestKeys,
+        latestPublishedKeys
+      });
+    }
+  };
+
+  return {
+    createForm,
+    createFormFrom,
+    updateForm,
+    listForms,
+    listFormRevisions,
+    getForm,
+    deleteForm,
+    deleteFormRevision,
+    publishForm,
+    unpublishForm,
+    createFormPartitionKey
+  };
+};
+
+exports.createFormStorageOperations = createFormStorageOperations;