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

package/operations/settings/index.d.ts

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

package/operations/settings/index.js

@@ -0,0 +1,122 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSettingsStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+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 createSettingsStorageOperations = params => {
+  const {
+    entity
+  } = params;
+
+  const createSettingsPartitionKey = ({
+    tenant,
+    locale
+  }) => {
+    return `T#${tenant}#L#${locale}#FB#SETTINGS`;
+  };
+
+  const createSettingsSortKey = () => {
+    return "default";
+  };
+
+  const createKeys = params => {
+    return {
+      PK: createSettingsPartitionKey(params),
+      SK: createSettingsSortKey()
+    };
+  };
+
+  const createSettings = async params => {
+    const {
+      settings
+    } = params;
+    const keys = createKeys(settings);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread({}, settings), keys));
+      return settings;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create the settings record by given keys.", ex.code || "CREATE_SETTINGS_ERROR", {
+        keys,
+        settings
+      });
+    }
+  };
+
+  const getSettings = 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 settings record by given keys.", ex.code || "LOAD_SETTINGS_ERROR", {
+        keys
+      });
+    }
+  };
+
+  const updateSettings = async params => {
+    const {
+      settings,
+      original
+    } = params;
+    const keys = createKeys(settings);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread({}, settings), keys));
+      return settings;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update the settings record by given keys.", ex.code || "UPDATE_SETTINGS_ERROR", {
+        keys,
+        original,
+        settings
+      });
+    }
+  };
+
+  const deleteSettings = async params => {
+    const {
+      settings
+    } = params;
+    const keys = createKeys(settings);
+
+    try {
+      await entity.delete();
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete the settings record by given keys.", ex.code || "DELETE_SETTINGS_ERROR", {
+        keys
+      });
+    }
+  };
+
+  return {
+    createSettings,
+    getSettings,
+    updateSettings,
+    deleteSettings,
+    createSettingsPartitionKey,
+    createSettingsSortKey
+  };
+};
+
+exports.createSettingsStorageOperations = createSettingsStorageOperations;

package/operations/submission/elasticsearchBody.d.ts

@@ -0,0 +1,13 @@
+import { SearchBody as esSearchBody } from "elastic-ts";
+import { FormBuilderStorageOperationsListSubmissionsParams } from "@webiny/api-form-builder/types";
+import { PluginsContainer } from "@webiny/plugins";
+export declare const createSubmissionElasticType: () => string;
+interface CreateElasticsearchBodyParams {
+    plugins: PluginsContainer;
+    where: FormBuilderStorageOperationsListSubmissionsParams["where"];
+    limit: number;
+    after?: string;
+    sort: string[];
+}
+export declare const createElasticsearchBody: (params: CreateElasticsearchBodyParams) => esSearchBody;
+export {};

package/operations/submission/elasticsearchBody.js

@@ -0,0 +1,197 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSubmissionElasticType = exports.createElasticsearchBody = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _cursors = require("@webiny/api-elasticsearch/cursors");
+
+var _sort = require("@webiny/api-elasticsearch/sort");
+
+var _limit = require("@webiny/api-elasticsearch/limit");
+
+var _ElasticsearchQueryBuilderOperatorPlugin = require("@webiny/api-elasticsearch/plugins/definition/ElasticsearchQueryBuilderOperatorPlugin");
+
+var _SubmissionElasticsearchFieldPlugin = require("../../plugins/SubmissionElasticsearchFieldPlugin");
+
+var _SubmissionElasticsearchSortModifierPlugin = require("../../plugins/SubmissionElasticsearchSortModifierPlugin");
+
+var _SubmissionElasticsearchBodyModifierPlugin = require("../../plugins/SubmissionElasticsearchBodyModifierPlugin");
+
+var _SubmissionElasticsearchQueryModifierPlugin = require("../../plugins/SubmissionElasticsearchQueryModifierPlugin");
+
+var _where = require("@webiny/api-elasticsearch/where");
+
+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 createInitialQueryValue = () => {
+  return {
+    must: [
+    /**
+     * We add the __type filtering in the initial query because it must be applied.
+     */
+    {
+      term: {
+        "__type.keyword": "fb.submission"
+      }
+    }],
+    must_not: [],
+    should: [],
+    filter: []
+  };
+};
+
+const createSubmissionElasticType = () => {
+  return "fb.submission";
+};
+
+exports.createSubmissionElasticType = createSubmissionElasticType;
+
+const createElasticsearchQuery = params => {
+  const {
+    plugins,
+    where: initialWhere,
+    fieldPlugins
+  } = params;
+  const query = createInitialQueryValue();
+  /**
+   * Be aware that, if having more registered operator plugins of same type, the last one will be used.
+   */
+
+  const operatorPlugins = plugins.byType(_ElasticsearchQueryBuilderOperatorPlugin.ElasticsearchQueryBuilderOperatorPlugin.type).reduce((acc, plugin) => {
+    acc[plugin.getOperator()] = plugin;
+    return acc;
+  }, {});
+
+  const where = _objectSpread({}, initialWhere);
+  /**
+   * !!! IMPORTANT !!! There are few specific cases where we hardcode the query conditions.
+   *
+   * When ES index is shared between tenants, we need to filter records by tenant ID.
+   * No need for the tenant filtering otherwise as each index is for single tenant.
+   */
+
+
+  const sharedIndex = process.env.ELASTICSEARCH_SHARED_INDEXES === "true";
+
+  if (sharedIndex) {
+    query.must.push({
+      term: {
+        "tenant.keyword": where.tenant
+      }
+    });
+  }
+  /**
+   * Remove tenant so it is not applied again later.
+   * Possibly tenant is not defined, but just in case, remove it.
+   */
+
+
+  delete where.tenant;
+  /**
+   * Add the locale to filtering.
+   */
+
+  query.must.push({
+    term: {
+      "locale.keyword": where.locale
+    }
+  });
+  delete where.locale;
+  /**
+   * And add the parent (form) to the filtering, if it exists.
+   */
+
+  query.must.push({
+    term: {
+      "form.parent.keyword": where.formId
+    }
+  });
+  delete where.formId;
+  /**
+   * We apply other conditions as they are passed via the where value.
+   */
+
+  (0, _where.applyWhere)({
+    query,
+    where,
+    fields: fieldPlugins,
+    operators: operatorPlugins
+  });
+  return query;
+};
+
+const createElasticsearchBody = params => {
+  const {
+    plugins,
+    where,
+    limit: initialLimit,
+    sort: initialSort,
+    after
+  } = params;
+  const fieldPlugins = plugins.byType(_SubmissionElasticsearchFieldPlugin.SubmissionElasticsearchFieldPlugin.type).reduce((acc, plugin) => {
+    acc[plugin.field] = plugin;
+    return acc;
+  }, {});
+  const limit = (0, _limit.createLimit)(initialLimit, 100);
+  const query = createElasticsearchQuery(_objectSpread(_objectSpread({}, params), {}, {
+    fieldPlugins
+  }));
+  const sort = (0, _sort.createSort)({
+    sort: initialSort,
+    fieldPlugins
+  });
+  const queryModifiers = plugins.byType(_SubmissionElasticsearchQueryModifierPlugin.SubmissionElasticsearchQueryModifierPlugin.type);
+
+  for (const plugin of queryModifiers) {
+    plugin.modifyQuery({
+      query,
+      where
+    });
+  }
+
+  const sortModifiers = plugins.byType(_SubmissionElasticsearchSortModifierPlugin.SubmissionElasticsearchSortModifierPlugin.type);
+
+  for (const plugin of sortModifiers) {
+    plugin.modifySort({
+      sort
+    });
+  }
+
+  const body = {
+    query: {
+      constant_score: {
+        filter: {
+          bool: _objectSpread({}, query)
+        }
+      }
+    },
+    size: limit + 1,
+
+    /**
+     * Casting as any is required due to search_after is accepting an array of values.
+     * Which is correct in some cases. In our case, it is not.
+     * https://www.elastic.co/guide/en/elasticsearch/reference/7.13/paginate-search-results.html
+     */
+    search_after: (0, _cursors.decodeCursor)(after),
+    sort
+  };
+  const bodyModifiers = plugins.byType(_SubmissionElasticsearchBodyModifierPlugin.SubmissionElasticsearchBodyModifierPlugin.type);
+
+  for (const plugin of bodyModifiers) {
+    plugin.modifyBody({
+      body
+    });
+  }
+
+  return body;
+};
+
+exports.createElasticsearchBody = createElasticsearchBody;

package/operations/submission/elasticsearchFields.d.ts

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

package/operations/submission/elasticsearchFields.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _SubmissionElasticsearchFieldPlugin = require("../../plugins/SubmissionElasticsearchFieldPlugin");
+
+var _default = () => [new _SubmissionElasticsearchFieldPlugin.SubmissionElasticsearchFieldPlugin({
+  field: "parent",
+  path: "form.parent"
+}), new _SubmissionElasticsearchFieldPlugin.SubmissionElasticsearchFieldPlugin({
+  field: "ownedBy",
+  path: "ownedBy.id"
+}), new _SubmissionElasticsearchFieldPlugin.SubmissionElasticsearchFieldPlugin({
+  field: "createdOn",
+  unmappedType: "date"
+}), new _SubmissionElasticsearchFieldPlugin.SubmissionElasticsearchFieldPlugin({
+  field: "savedOn",
+  unmappedType: "date"
+}),
+/**
+ * Always add the ALL fields plugin because of the keyword/path build.
+ */
+new _SubmissionElasticsearchFieldPlugin.SubmissionElasticsearchFieldPlugin({
+  field: _SubmissionElasticsearchFieldPlugin.SubmissionElasticsearchFieldPlugin.ALL
+})];
+
+exports.default = _default;

package/operations/submission/index.d.ts

@@ -0,0 +1,12 @@
+import { Entity, Table } from "dynamodb-toolbox";
+import { Client } from "@elastic/elasticsearch";
+import { PluginsContainer } from "@webiny/plugins";
+import { FormBuilderSubmissionStorageOperations } from "../../types";
+export interface Params {
+    entity: Entity<any>;
+    esEntity: Entity<any>;
+    table: Table;
+    elasticsearch: Client;
+    plugins: PluginsContainer;
+}
+export declare const createSubmissionStorageOperations: (params: Params) => FormBuilderSubmissionStorageOperations;