@webiny/api-form-builder-so-ddb/operations/submission/index.js

[](https://www.npmjs.com/package/@webiny/api-form-builder-so-ddb) [](https://www.npmjs.com/package/@webiny/api-form

"use strict";

var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
Object.defineProperty(exports, "__esModule", {
  value: true
});
exports.createSubmissionStorageOperations = void 0;
var _error = _interopRequireDefault(require("@webiny/error"));
var _utils = require("@webiny/utils");
var _query = require("@webiny/db-dynamodb/utils/query");
var _cursor = require("@webiny/db-dynamodb/utils/cursor");
var _sort = require("@webiny/db-dynamodb/utils/sort");
var _filter = require("@webiny/db-dynamodb/utils/filter");
var _FormSubmissionDynamoDbFieldPlugin = require("../../plugins/FormSubmissionDynamoDbFieldPlugin");
var _get = require("@webiny/db-dynamodb/utils/get");
var _dbDynamodb = require("@webiny/db-dynamodb");
const createSubmissionStorageOperations = params => {
  const {
    entity,
    plugins
  } = params;
  const createSubmissionPartitionKey = params => {
    const {
      tenant,
      locale,
      formId
    } = params;
    const {
      id
    } = (0, _utils.parseIdentifier)(formId);
    return `T#${tenant}#L#${locale}#FB#FS#${id}`;
  };
  const createSubmissionSortKey = id => {
    return 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 (0, _dbDynamodb.put)({
        entity,
        item: {
          ...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
      });
    }
    return submission;
  };
  const updateSubmission = async params => {
    const {
      submission,
      form,
      original
    } = params;
    const keys = {
      PK: createSubmissionPartitionKey(form),
      SK: createSubmissionSortKey(submission.id)
    };
    try {
      await (0, _dbDynamodb.put)({
        entity,
        item: {
          ...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 (0, _dbDynamodb.deleteItem)({
        entity,
        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
      });
    }
    return submission;
  };
  const listSubmissions = async params => {
    const {
      where: initialWhere,
      sort,
      limit = 100000,
      after
    } = params;
    const {
      tenant,
      locale,
      formId
    } = initialWhere;
    const where = {
      ...initialWhere
    };
    /**
     * We need to remove conditions so we do not filter by them again.
     */
    delete where.tenant;
    delete where.locale;
    delete where.formId;
    const queryAllParams = {
      entity,
      partitionKey: createSubmissionPartitionKey({
        tenant,
        locale,
        formId
      }),
      options: {
        gte: " ",
        reverse: true
      }
    };
    let results;
    try {
      results = await (0, _query.queryAll)(queryAllParams);
    } catch (ex) {
      throw new _error.default(ex.message || "Could list form submissions.", ex.code || "LIST_SUBMISSIONS_ERROR", {
        where: initialWhere,
        partitionKey: queryAllParams.partitionKey
      });
    }
    const fields = plugins.byType(_FormSubmissionDynamoDbFieldPlugin.FormSubmissionDynamoDbFieldPlugin.type);
    const filteredSubmissions = (0, _filter.filterItems)({
      plugins,
      items: results,
      where,
      fields
    });
    const sortedSubmissions = (0, _sort.sortItems)({
      items: filteredSubmissions,
      sort,
      fields
    });
    const totalCount = sortedSubmissions.length;
    const start = parseInt((0, _cursor.decodeCursor)(after) || "0") || 0;
    const hasMoreItems = totalCount > start + limit;
    const end = limit > totalCount + start + limit ? undefined : start + limit;
    const items = sortedSubmissions.slice(start, end);
    /**
     * Although we do not need a cursor here, we will use it as such to keep it standardized.
     * Number is simply encoded.
     */
    const cursor = items.length > 0 ? (0, _cursor.encodeCursor)(start + limit) : null;
    const meta = {
      hasMoreItems,
      totalCount,
      cursor
    };
    return {
      items,
      meta
    };
  };
  const getSubmission = async params => {
    const {
      where
    } = params;
    const keys = {
      PK: createSubmissionPartitionKey(where),
      SK: createSubmissionSortKey(where.id)
    };
    try {
      return await (0, _get.getClean)({
        entity,
        keys
      });
    } 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;

//# sourceMappingURL=index.js.map