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

package/index.js

@@ -0,0 +1,188 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFormBuilderStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _types = require("./types");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _table = require("./definitions/table");
+
+var _form = require("./definitions/form");
+
+var _submission = require("./definitions/submission");
+
+var _system = require("./definitions/system");
+
+var _settings = require("./definitions/settings");
+
+var _system2 = require("./operations/system");
+
+var _submission2 = require("./operations/submission");
+
+var _settings2 = require("./operations/settings");
+
+var _form2 = require("./operations/form");
+
+var _createElasticsearchIndex = require("./operations/system/createElasticsearchIndex");
+
+var _tableElasticsearch = require("./definitions/tableElasticsearch");
+
+var _plugins = require("@webiny/plugins");
+
+var _elasticsearch = require("./definitions/elasticsearch");
+
+var _elasticsearchFields = _interopRequireDefault(require("./operations/submission/elasticsearchFields"));
+
+var _elasticsearchFields2 = _interopRequireDefault(require("./operations/form/elasticsearchFields"));
+
+var _filters = _interopRequireDefault(require("@webiny/db-dynamodb/plugins/filters"));
+
+var _operators = require("@webiny/api-elasticsearch/operators");
+
+var _ = _interopRequireDefault(require("./upgrades/5.16.0"));
+
+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 reservedFields = ["PK", "SK", "index", "data", "TYPE", "__type", "GSI1_PK", "GSI1_SK"];
+
+const isReserved = name => {
+  if (reservedFields.includes(name) === false) {
+    return;
+  }
+
+  throw new _error.default(`Attribute name "${name}" is not allowed.`, "ATTRIBUTE_NOT_ALLOWED", {
+    name
+  });
+};
+
+const createFormBuilderStorageOperations = params => {
+  const {
+    attributes = {},
+    table: tableName,
+    esTable: esTableName,
+    documentClient,
+    elasticsearch,
+    plugins: pluginsInput
+  } = params;
+
+  if (attributes) {
+    Object.values(attributes).forEach(attrs => {
+      Object.keys(attrs).forEach(isReserved);
+    });
+  }
+
+  const plugins = new _plugins.PluginsContainer([
+  /**
+   * User defined plugins.
+   */
+  pluginsInput || [],
+  /**
+   * Elasticsearch field definitions for the submission record.
+   */
+  (0, _elasticsearchFields.default)(),
+  /**
+   * Elasticsearch field definitions for the form record.
+   */
+  (0, _elasticsearchFields2.default)(),
+  /**
+   * DynamoDB filter plugins for the where conditions.
+   */
+  (0, _filters.default)(),
+  /**
+   * Elasticsearch operators.
+   */
+  (0, _operators.getElasticsearchOperators)()]);
+  const table = (0, _table.createTable)({
+    tableName,
+    documentClient
+  });
+  const esTable = (0, _tableElasticsearch.createElasticsearchTable)({
+    tableName: esTableName,
+    documentClient
+  });
+  const entities = {
+    /**
+     * Regular entities.
+     */
+    form: (0, _form.createFormEntity)({
+      entityName: _types.ENTITIES.FORM,
+      table,
+      attributes: attributes[_types.ENTITIES.FORM]
+    }),
+    submission: (0, _submission.createSubmissionEntity)({
+      entityName: _types.ENTITIES.SUBMISSION,
+      table,
+      attributes: attributes[_types.ENTITIES.SUBMISSION]
+    }),
+    system: (0, _system.createSystemEntity)({
+      entityName: _types.ENTITIES.SYSTEM,
+      table,
+      attributes: attributes[_types.ENTITIES.SYSTEM]
+    }),
+    settings: (0, _settings.createSettingsEntity)({
+      entityName: _types.ENTITIES.SETTINGS,
+      table,
+      attributes: attributes[_types.ENTITIES.SETTINGS]
+    }),
+
+    /**
+     * Elasticsearch entities.
+     */
+    esForm: (0, _elasticsearch.createElasticsearchEntity)({
+      entityName: _types.ENTITIES.ES_FORM,
+      table: esTable,
+      attributes: attributes[_types.ENTITIES.ES_FORM]
+    }),
+    esSubmission: (0, _elasticsearch.createElasticsearchEntity)({
+      entityName: _types.ENTITIES.ES_SUBMISSION,
+      table: esTable,
+      attributes: attributes[_types.ENTITIES.ES_SUBMISSION]
+    })
+  };
+  return _objectSpread(_objectSpread(_objectSpread(_objectSpread({
+    init: async formBuilder => {
+      formBuilder.onAfterInstall.subscribe(async ({
+        tenant
+      }) => {
+        await (0, _createElasticsearchIndex.createElasticsearchIndex)({
+          elasticsearch,
+          tenant
+        });
+      });
+    },
+    upgrade: (0, _.default)(),
+    getTable: () => table,
+    getEsTable: () => esTable,
+    getEntities: () => entities
+  }, (0, _system2.createSystemStorageOperations)({
+    table,
+    entity: entities.system
+  })), (0, _settings2.createSettingsStorageOperations)({
+    table,
+    entity: entities.settings
+  })), (0, _form2.createFormStorageOperations)({
+    elasticsearch,
+    table,
+    entity: entities.form,
+    esEntity: entities.esForm,
+    plugins
+  })), (0, _submission2.createSubmissionStorageOperations)({
+    elasticsearch,
+    table,
+    entity: entities.submission,
+    esEntity: entities.esSubmission,
+    plugins
+  }));
+};
+
+exports.createFormBuilderStorageOperations = createFormBuilderStorageOperations;

package/operations/form/elasticsearchBody.d.ts

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

package/operations/form/elasticsearchBody.js

@@ -0,0 +1,187 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createFormElasticType = 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 _FormElasticsearchFieldPlugin = require("../../plugins/FormElasticsearchFieldPlugin");
+
+var _FormElasticsearchSortModifierPlugin = require("../../plugins/FormElasticsearchSortModifierPlugin");
+
+var _FormElasticsearchBodyModifierPlugin = require("../../plugins/FormElasticsearchBodyModifierPlugin");
+
+var _FormElasticsearchQueryModifierPlugin = require("../../plugins/FormElasticsearchQueryModifierPlugin");
+
+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 createFormElasticType = () => {
+  return "fb.form";
+};
+
+exports.createFormElasticType = createFormElasticType;
+
+const createInitialQueryValue = () => {
+  return {
+    must: [
+    /**
+     * We add the __type filtering in the initial query because it must be applied.
+     */
+    {
+      term: {
+        "__type.keyword": createFormElasticType()
+      }
+    }],
+    must_not: [],
+    should: [],
+    filter: []
+  };
+};
+
+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;
+  /**
+   * 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(_FormElasticsearchFieldPlugin.FormElasticsearchFieldPlugin.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(_FormElasticsearchQueryModifierPlugin.FormElasticsearchQueryModifierPlugin.type);
+
+  for (const plugin of queryModifiers) {
+    plugin.modifyQuery({
+      query,
+      where
+    });
+  }
+
+  const sortModifiers = plugins.byType(_FormElasticsearchSortModifierPlugin.FormElasticsearchSortModifierPlugin.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(_FormElasticsearchBodyModifierPlugin.FormElasticsearchBodyModifierPlugin.type);
+
+  for (const plugin of bodyModifiers) {
+    plugin.modifyBody({
+      body
+    });
+  }
+
+  return body;
+};
+
+exports.createElasticsearchBody = createElasticsearchBody;

package/operations/form/elasticsearchFields.d.ts

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

package/operations/form/elasticsearchFields.js

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

package/operations/form/fields.d.ts

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

package/operations/form/fields.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _FormDynamoDbFieldPlugin = require("../../plugins/FormDynamoDbFieldPlugin");
+
+var _default = () => [new _FormDynamoDbFieldPlugin.FormDynamoDbFieldPlugin({
+  field: "publishedOn",
+  type: "date"
+})];
+
+exports.default = _default;

package/operations/form/index.d.ts

@@ -0,0 +1,17 @@
+import { Entity, Table } from "dynamodb-toolbox";
+import { Client } from "@elastic/elasticsearch";
+import { PluginsContainer } from "@webiny/plugins";
+import { FormBuilderFormStorageOperations } from "../../types";
+export declare type DbRecord<T = any> = T & {
+    PK: string;
+    SK: string;
+    TYPE: string;
+};
+export interface Params {
+    entity: Entity<any>;
+    esEntity: Entity<any>;
+    table: Table;
+    elasticsearch: Client;
+    plugins: PluginsContainer;
+}
+export declare const createFormStorageOperations: (params: Params) => FormBuilderFormStorageOperations;