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

package/operations/settings/SettingsStorageOperations.js

@@ -0,0 +1,191 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SettingsStorageOperationsDdbEs = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _settingsEntity = require("../../definitions/settingsEntity");
+
+var _table = require("../../definitions/table");
+
+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 extractFromStorage = settings => {
+  return _objectSpread(_objectSpread({}, settings), {}, {
+    tenant: !settings.tenant ? false : settings.tenant,
+    locale: !settings.locale ? false : settings.locale
+  });
+};
+
+const prepareForStorage = settings => {
+  return _objectSpread(_objectSpread({}, settings), {}, {
+    tenant: !settings.tenant ? null : settings.tenant,
+    locale: !settings.locale ? null : settings.locale
+  });
+};
+
+class SettingsStorageOperationsDdbEs {
+  constructor({
+    context
+  }) {
+    (0, _defineProperty2.default)(this, "context", void 0);
+    (0, _defineProperty2.default)(this, "table", void 0);
+    (0, _defineProperty2.default)(this, "entity", void 0);
+    this.context = context;
+    this.table = (0, _table.defineTable)({
+      context
+    });
+    this.entity = (0, _settingsEntity.defineSettingsEntity)({
+      context,
+      table: this.table
+    });
+  }
+  /**
+   * We can simply return the partition key for this storage operations.
+   */
+
+
+  createCacheKey(options) {
+    return this.createPartitionKey(options);
+  }
+
+  async get(params) {
+    const {
+      where
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(where),
+      SK: this.createSortKey(where)
+    };
+
+    try {
+      const result = await this.entity.get(keys);
+
+      if (!result || !result.Item) {
+        return null;
+      }
+
+      const settings = (0, _cleanup.cleanupItem)(this.entity, result.Item);
+      return extractFromStorage(settings);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not load settings record.", ex.code || "SETTINGS_GET_ERROR", {
+        keys
+      });
+    }
+  }
+
+  async create(params) {
+    const {
+      settings
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(settings),
+      SK: this.createSortKey(settings)
+    };
+
+    try {
+      await this.entity.put(_objectSpread(_objectSpread({}, prepareForStorage(settings)), {}, {
+        TYPE: this.createType()
+      }, keys));
+      return settings;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create settings record.", ex.code || "SETTINGS_CREATE_ERROR", {
+        settings,
+        keys
+      });
+    }
+  }
+
+  async update(params) {
+    const {
+      original,
+      settings
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(settings),
+      SK: this.createSortKey(settings)
+    };
+
+    try {
+      await this.entity.put(_objectSpread(_objectSpread({}, prepareForStorage(settings)), {}, {
+        TYPE: this.createType()
+      }, keys));
+      return settings;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update settings record.", ex.code || "SETTINGS_UPDATE_ERROR", {
+        original,
+        settings,
+        keys
+      });
+    }
+  }
+  /**
+   * Because it is a possibility that tenant and locale are set as false (for the global settings) we must take
+   * it in consideration and create the partition key for the global settings.
+   */
+
+
+  createPartitionKey(options) {
+    let {
+      tenant,
+      locale
+    } = options;
+    const parts = [];
+
+    if (tenant !== false) {
+      if (!tenant) {
+        tenant = this.context.tenancy.getCurrentTenant().id;
+      }
+
+      parts.push(`T#${tenant}`);
+    }
+
+    if (locale !== false) {
+      if (!locale) {
+        locale = this.context.i18nContent.getLocale().code;
+      }
+
+      parts.push(`L#${locale}`);
+    }
+
+    parts.push("PB#SETTINGS");
+    return parts.join("#");
+  }
+  /**
+   * We expect any object that has type property in it.
+   * This way we can either receive a settings object or where conditions
+   */
+
+
+  createSortKey({
+    type
+  }) {
+    switch (type) {
+      case "default":
+        return type;
+
+      default:
+        throw new _error.default("Unsupported type for the sort key.", "UNSUPPORTED_TYPE", {
+          type
+        });
+    }
+  }
+
+  createType() {
+    return "pb.settings";
+  }
+
+}
+
+exports.SettingsStorageOperationsDdbEs = SettingsStorageOperationsDdbEs;

package/operations/settings/index.d.ts

@@ -0,0 +1,7 @@
+import { SettingsStorageOperationsProviderPlugin } from "@webiny/api-page-builder/plugins/SettingsStorageOperationsProviderPlugin";
+import { SettingsStorageOperations } from "@webiny/api-page-builder/types";
+export declare class SettingsStorageOperationsDdbEsProviderPlugin extends SettingsStorageOperationsProviderPlugin {
+    provide({ context }: {
+        context: any;
+    }): Promise<SettingsStorageOperations>;
+}

package/operations/settings/index.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SettingsStorageOperationsDdbEsProviderPlugin = void 0;
+
+var _SettingsStorageOperationsProviderPlugin = require("@webiny/api-page-builder/plugins/SettingsStorageOperationsProviderPlugin");
+
+var _SettingsStorageOperations = require("./SettingsStorageOperations");
+
+class SettingsStorageOperationsDdbEsProviderPlugin extends _SettingsStorageOperationsProviderPlugin.SettingsStorageOperationsProviderPlugin {
+  async provide({
+    context
+  }) {
+    return new _SettingsStorageOperations.SettingsStorageOperationsDdbEs({
+      context
+    });
+  }
+
+}
+
+exports.SettingsStorageOperationsDdbEsProviderPlugin = SettingsStorageOperationsDdbEsProviderPlugin;

package/operations/system/InstallationDdbEsPlugin.d.ts

@@ -0,0 +1,2 @@
+import { InstallationPlugin } from "@webiny/api-page-builder/plugins/InstallationPlugin";
+export declare const installation: () => InstallationPlugin;

package/operations/system/InstallationDdbEsPlugin.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.installation = void 0;
+
+var _InstallationPlugin = require("@webiny/api-page-builder/plugins/InstallationPlugin");
+
+var _configurations = _interopRequireDefault(require("../configurations"));
+
+const installation = () => {
+  return new _InstallationPlugin.InstallationPlugin({
+    beforeInstall: async params => {
+      const {
+        context
+      } = params;
+      const {
+        elasticsearch
+      } = context;
+
+      const {
+        index
+      } = _configurations.default.es(context);
+
+      const {
+        body: exists
+      } = await elasticsearch.indices.exists({
+        index
+      });
+
+      if (exists) {
+        return;
+      }
+
+      await elasticsearch.indices.create({
+        index,
+        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.installation = installation;

package/operations/system/SystemStorageOperations.d.ts

@@ -0,0 +1,16 @@
+import { PbContext, System, SystemStorageOperations, SystemStorageOperationsCreateParams, SystemStorageOperationsUpdateParams } from "@webiny/api-page-builder/types";
+import { Entity, Table } from "dynamodb-toolbox";
+export interface Params {
+    context: PbContext;
+}
+export declare class SystemStorageOperationsDdbEs implements SystemStorageOperations {
+    protected readonly context: PbContext;
+    readonly table: Table;
+    readonly entity: Entity<any>;
+    constructor({ context }: Params);
+    get(): Promise<System>;
+    create(params: SystemStorageOperationsCreateParams): Promise<System>;
+    update(params: SystemStorageOperationsUpdateParams): Promise<System>;
+    protected createPartitionKey(): string;
+    protected createSortKey(): string;
+}

package/operations/system/SystemStorageOperations.js

@@ -0,0 +1,114 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SystemStorageOperationsDdbEs = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _cleanup = require("@webiny/db-dynamodb/utils/cleanup");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _systemEntity = require("../../definitions/systemEntity");
+
+var _table = require("../../definitions/table");
+
+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; }
+
+class SystemStorageOperationsDdbEs {
+  constructor({
+    context
+  }) {
+    (0, _defineProperty2.default)(this, "context", void 0);
+    (0, _defineProperty2.default)(this, "table", void 0);
+    (0, _defineProperty2.default)(this, "entity", void 0);
+    this.context = context;
+    this.table = (0, _table.defineTable)({
+      context
+    });
+    this.entity = (0, _systemEntity.defineSystemEntity)({
+      context,
+      table: this.table
+    });
+  }
+
+  async get() {
+    const keys = {
+      PK: this.createPartitionKey(),
+      SK: this.createSortKey()
+    };
+
+    try {
+      const result = await this.entity.get(keys);
+
+      if (!result || !result.Item) {
+        return null;
+      }
+
+      return (0, _cleanup.cleanupItem)(this.entity, result.Item);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not load system record.", ex.code || "SYSTEM_GET_ERROR", {
+        keys
+      });
+    }
+  }
+
+  async create(params) {
+    const {
+      system
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(),
+      SK: this.createSortKey()
+    };
+
+    try {
+      await this.entity.put(_objectSpread(_objectSpread({}, system), keys));
+      return system;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create system record.", ex.code || "SYSTEM_CREATE_ERROR", {
+        system,
+        keys
+      });
+    }
+  }
+
+  async update(params) {
+    const {
+      original,
+      system
+    } = params;
+    const keys = {
+      PK: this.createPartitionKey(),
+      SK: this.createSortKey()
+    };
+
+    try {
+      await this.entity.put(_objectSpread(_objectSpread({}, system), keys));
+      return system;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update system record.", ex.code || "SYSTEM_UPDATE_ERROR", {
+        original,
+        system,
+        keys
+      });
+    }
+  }
+
+  createPartitionKey() {
+    return `T#${this.context.tenancy.getCurrentTenant().id}#SYSTEM`;
+  }
+
+  createSortKey() {
+    return "PB";
+  }
+
+}
+
+exports.SystemStorageOperationsDdbEs = SystemStorageOperationsDdbEs;

package/operations/system/index.d.ts

@@ -0,0 +1,5 @@
+import { Params, SystemStorageOperationsProviderPlugin } from "@webiny/api-page-builder/plugins/SystemStorageOperationsProviderPlugin";
+import { SystemStorageOperations } from "@webiny/api-page-builder/types";
+export declare class SystemStorageOperationsDdbEsProviderPlugin extends SystemStorageOperationsProviderPlugin {
+    provide({ context }: Params): Promise<SystemStorageOperations>;
+}

package/operations/system/index.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.SystemStorageOperationsDdbEsProviderPlugin = void 0;
+
+var _SystemStorageOperationsProviderPlugin = require("@webiny/api-page-builder/plugins/SystemStorageOperationsProviderPlugin");
+
+var _SystemStorageOperations = require("./SystemStorageOperations");
+
+var _InstallationDdbEsPlugin = require("./InstallationDdbEsPlugin");
+
+class SystemStorageOperationsDdbEsProviderPlugin extends _SystemStorageOperationsProviderPlugin.SystemStorageOperationsProviderPlugin {
+  async provide({
+    context
+  }) {
+    /**
+     * We need the installation plugin to insert the page builder elasticsearch index on before install.
+     */
+    context.plugins.register([(0, _InstallationDdbEsPlugin.installation)()]);
+    return new _SystemStorageOperations.SystemStorageOperationsDdbEs({
+      context
+    });
+  }
+
+}
+
+exports.SystemStorageOperationsDdbEsProviderPlugin = SystemStorageOperationsDdbEsProviderPlugin;

package/package.json

@@ -0,0 +1,65 @@
+{
+	"name": "@webiny/api-page-builder-so-ddb-es",
+	"version": "0.0.0-mt-1",
+	"main": "index.js",
+	"keywords": [
+		"@webiny/api-page-builder",
+		"storage-operations",
+		"dynamodb",
+		"pb:ddb-es"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-page-builder-so-ddb-es"
+	},
+	"author": "Webiny Ltd",
+	"description": "The DynamoDB + Elasticsearch storage operations Webiny Page Builder API.",
+	"license": "MIT",
+	"dependencies": {
+		"@babel/runtime": "7.15.4",
+		"@webiny/api-elasticsearch": "0.0.0-mt-1",
+		"@webiny/api-page-builder": "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-db": "0.0.0-mt-1",
+		"@webiny/plugins": "0.0.0-mt-1",
+		"dataloader": "2.0.0",
+		"dynamodb-toolbox": "0.3.4",
+		"elastic-ts": "0.7.0",
+		"lodash": "4.17.21"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.5.5",
+		"@babel/core": "^7.5.5",
+		"@babel/preset-env": "^7.5.5",
+		"@babel/preset-typescript": "^7.8.3",
+		"@elastic/elasticsearch": "7.12.0",
+		"@elastic/elasticsearch-mock": "0.3.0",
+		"@shelf/jest-elasticsearch": "^1.0.0",
+		"@webiny/api-dynamodb-to-elasticsearch": "^0.0.0-mt-1",
+		"@webiny/api-security": "^0.0.0-mt-1",
+		"@webiny/api-tenancy": "^0.0.0-mt-1",
+		"@webiny/cli": "^0.0.0-mt-1",
+		"@webiny/handler": "^0.0.0-mt-1",
+		"@webiny/handler-aws": "^0.0.0-mt-1",
+		"@webiny/handler-graphql": "^0.0.0-mt-1",
+		"@webiny/project-utils": "^0.0.0-mt-1",
+		"jest": "^26.6.3",
+		"jest-dynalite": "^3.2.0",
+		"jest-environment-node": "^27.0.6",
+		"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/definitions/CategoryDynamoDbElasticFieldPlugin.d.ts

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

package/plugins/definitions/CategoryDynamoDbElasticFieldPlugin.js

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

package/plugins/definitions/IndexPageDataPlugin.d.ts

@@ -0,0 +1,18 @@
+import { Plugin } from "@webiny/plugins";
+import { PbContext } from "@webiny/api-page-builder/graphql/types";
+import { Page } from "@webiny/api-page-builder/types";
+interface ApplyPageDataParams<TPage> {
+    data: Record<string, any>;
+    page: TPage;
+    context: PbContext;
+}
+interface ApplyPageDataCallable<TPage> {
+    (params: ApplyPageDataParams<TPage>): void;
+}
+export declare class IndexPageDataPlugin<TPage extends Page = Page> extends Plugin {
+    static readonly type = "pb.elasticsearch.index-page-data";
+    private readonly callable;
+    constructor(callable: ApplyPageDataCallable<TPage>);
+    apply(params: ApplyPageDataParams<TPage>): void;
+}
+export {};

package/plugins/definitions/IndexPageDataPlugin.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.IndexPageDataPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class IndexPageDataPlugin extends _plugins.Plugin {
+  constructor(callable) {
+    super();
+    (0, _defineProperty2.default)(this, "callable", void 0);
+    this.callable = callable;
+  }
+
+  apply(params) {
+    if (typeof this.callable !== "function") {
+      return;
+    }
+
+    this.callable(params);
+  }
+
+}
+
+exports.IndexPageDataPlugin = IndexPageDataPlugin;
+(0, _defineProperty2.default)(IndexPageDataPlugin, "type", "pb.elasticsearch.index-page-data");

package/plugins/definitions/MenuDynamoDbElasticFieldPlugin.d.ts

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

package/plugins/definitions/MenuDynamoDbElasticFieldPlugin.js

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

package/plugins/definitions/PageElasticsearchBodyModifierPlugin.d.ts

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

package/plugins/definitions/PageElasticsearchBodyModifierPlugin.js

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

package/plugins/definitions/PageElasticsearchFieldPlugin.d.ts

@@ -0,0 +1,5 @@
+import { ElasticsearchFieldPlugin, Params } from "@webiny/api-elasticsearch/plugins/definition/ElasticsearchFieldPlugin";
+export declare class PageElasticsearchFieldPlugin extends ElasticsearchFieldPlugin {
+    static readonly type: string;
+    constructor(params: Params);
+}