@webiny/api-headless-cms-ddb-es 0.0.0-mt-1

package/operations/system/index.js

@@ -0,0 +1,105 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSystemStorageOperations = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _get = require("@webiny/db-dynamodb/utils/get");
+
+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 createPartitionKey = ({
+  tenant
+}) => {
+  return `T#${tenant.toLowerCase()}#SYSTEM`;
+};
+
+const createSortKey = () => {
+  return "CMS";
+};
+
+const createKeys = params => {
+  return {
+    PK: createPartitionKey(params),
+    SK: createSortKey()
+  };
+};
+
+const createSystemStorageOperations = params => {
+  const {
+    entity
+  } = params;
+
+  const create = async ({
+    system
+  }) => {
+    const keys = createKeys(system);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread({}, system), keys));
+      return system;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create system.", ex.code || "CREATE_SYSTEM_ERROR", {
+        error: ex,
+        system,
+        keys
+      });
+    }
+  };
+
+  const update = async params => {
+    const {
+      system,
+      original
+    } = params;
+    const keys = createKeys(system);
+
+    try {
+      await entity.put(_objectSpread(_objectSpread({}, system), keys));
+      return system;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update system.", ex.code || "UPDATE_SYSTEM_ERROR", {
+        error: ex,
+        system,
+        original,
+        keys
+      });
+    }
+  };
+
+  const get = async params => {
+    const keys = createKeys(params);
+
+    try {
+      const system = await (0, _get.get)({
+        entity,
+        keys
+      });
+      return (0, _cleanup.cleanupItem)(entity, system);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not get system.", ex.code || "GET_SYSTEM_ERROR", {
+        error: ex,
+        keys
+      });
+    }
+  };
+
+  return {
+    create,
+    update,
+    get
+  };
+};
+
+exports.createSystemStorageOperations = createSystemStorageOperations;

package/package.json

@@ -0,0 +1,73 @@
+{
+	"name": "@webiny/api-headless-cms-ddb-es",
+	"version": "0.0.0-mt-1",
+	"main": "index.js",
+	"keywords": [
+		"@webiny/api-headless-cms",
+		"storage-operations",
+		"dynamodb",
+		"elasticsearch",
+		"cms:ddb-es"
+	],
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git",
+		"directory": "packages/api-headless-cms-ddb-es"
+	},
+	"description": "DynamoDB and Elasticsearch storage operations plugin for Headless CMS API.",
+	"contributors": [
+		"Pavel Denisjuk <pavel@webiny.com>",
+		"Sven Al Hamad <sven@webiny.com>",
+		"Adrian Smijulj <adrian@webiny.com>"
+	],
+	"license": "MIT",
+	"dependencies": {
+		"@babel/runtime": "7.15.4",
+		"@webiny/api-headless-cms": "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": "0.0.0-mt-1",
+		"@webiny/handler-aws": "0.0.0-mt-1",
+		"@webiny/handler-db": "0.0.0-mt-1",
+		"@webiny/plugins": "0.0.0-mt-1",
+		"@webiny/utils": "0.0.0-mt-1",
+		"dataloader": "2.0.0",
+		"dynamodb-toolbox": "0.3.4",
+		"jsonpack": "1.1.5",
+		"lodash.chunk": "4.2.0",
+		"lodash.clonedeep": "4.5.0",
+		"lodash.omit": "4.5.0"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.5.5",
+		"@babel/core": "^7.5.5",
+		"@babel/preset-env": "^7.5.5",
+		"@babel/preset-flow": "^7.0.0",
+		"@elastic/elasticsearch": "7.12.0",
+		"@shelf/jest-elasticsearch": "^1.0.0",
+		"@types/jsonpack": "^1.1.0",
+		"@webiny/api-dynamodb-to-elasticsearch": "^0.0.0-mt-1",
+		"@webiny/api-elasticsearch": "^0.0.0-mt-1",
+		"@webiny/cli": "^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": "^26.6.2",
+		"mdbid": "^1.0.0",
+		"prettier": "^2.3.2",
+		"rimraf": "^3.0.2",
+		"sinon": "^9.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/CmsEntryElasticsearchBodyModifierPlugin.d.ts

@@ -0,0 +1,17 @@
+import { ElasticsearchBodyModifierPlugin, ModifyBodyCallable, ModifyBodyParams as BaseModifyBodyParams } from "@webiny/api-elasticsearch/plugins/definition/ElasticsearchBodyModifierPlugin";
+import { CmsModel } from "@webiny/api-headless-cms/types";
+export interface ModifyBodyParams extends BaseModifyBodyParams {
+    model: CmsModel;
+}
+export interface Config {
+    modifyBody: ModifyBodyCallable<ModifyBodyParams>;
+    /**
+     * If modelId is not passed, there is no filtering of plugins by it when plugin is applied during the runtime.
+     */
+    modelId?: string;
+}
+export declare class CmsEntryElasticsearchBodyModifierPlugin extends ElasticsearchBodyModifierPlugin<ModifyBodyParams> {
+    static readonly type: string;
+    readonly modelId?: string;
+    constructor(config: Config);
+}

package/plugins/CmsEntryElasticsearchBodyModifierPlugin.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CmsEntryElasticsearchBodyModifierPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchBodyModifierPlugin = require("@webiny/api-elasticsearch/plugins/definition/ElasticsearchBodyModifierPlugin");
+
+class CmsEntryElasticsearchBodyModifierPlugin extends _ElasticsearchBodyModifierPlugin.ElasticsearchBodyModifierPlugin {
+  constructor(config) {
+    super(config.modifyBody);
+    (0, _defineProperty2.default)(this, "modelId", void 0);
+    this.modelId = config.modelId;
+  }
+
+}
+
+exports.CmsEntryElasticsearchBodyModifierPlugin = CmsEntryElasticsearchBodyModifierPlugin;
+(0, _defineProperty2.default)(CmsEntryElasticsearchBodyModifierPlugin, "type", "cms.elasticsearch.modifier.body.entry");

package/plugins/CmsEntryElasticsearchFieldPlugin.d.ts

@@ -0,0 +1,12 @@
+import { ElasticsearchFieldPlugin, Params as BaseParams } from "@webiny/api-elasticsearch/plugins/definition/ElasticsearchFieldPlugin";
+export interface Params extends BaseParams {
+    /**
+     * If modelId is not passed, there is no filtering of plugins by it when plugin is applied during the runtime.
+     */
+    modelId?: string;
+}
+export declare class CmsEntryElasticsearchFieldPlugin extends ElasticsearchFieldPlugin {
+    static readonly type: string;
+    readonly modelId?: string;
+    constructor(params: Params);
+}

package/plugins/CmsEntryElasticsearchFieldPlugin.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CmsEntryElasticsearchFieldPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchFieldPlugin = require("@webiny/api-elasticsearch/plugins/definition/ElasticsearchFieldPlugin");
+
+class CmsEntryElasticsearchFieldPlugin extends _ElasticsearchFieldPlugin.ElasticsearchFieldPlugin {
+  constructor(params) {
+    super(params);
+    (0, _defineProperty2.default)(this, "modelId", void 0);
+    this.modelId = params.modelId;
+  }
+
+}
+
+exports.CmsEntryElasticsearchFieldPlugin = CmsEntryElasticsearchFieldPlugin;
+(0, _defineProperty2.default)(CmsEntryElasticsearchFieldPlugin, "type", "elasticsearch.fieldDefinition.cms.entry");

package/plugins/CmsEntryElasticsearchQueryModifierPlugin.d.ts

@@ -0,0 +1,17 @@
+import { ElasticsearchQueryModifierPlugin, ModifyQueryCallable, ModifyQueryParams as BaseModifyQueryParams } from "@webiny/api-elasticsearch/plugins/definition/ElasticsearchQueryModifierPlugin";
+import { CmsModel } from "@webiny/api-headless-cms/types";
+export interface ModifyQueryParams extends BaseModifyQueryParams {
+    model: CmsModel;
+}
+export interface Config {
+    modifyQuery: ModifyQueryCallable<ModifyQueryParams>;
+    /**
+     * If modelId is not passed, there is no filtering of plugins by it when plugin is applied during the runtime.
+     */
+    modelId?: string;
+}
+export declare class CmsEntryElasticsearchQueryModifierPlugin extends ElasticsearchQueryModifierPlugin<ModifyQueryParams> {
+    static readonly type: string;
+    readonly modelId?: string;
+    constructor(config: Config);
+}

package/plugins/CmsEntryElasticsearchQueryModifierPlugin.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CmsEntryElasticsearchQueryModifierPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchQueryModifierPlugin = require("@webiny/api-elasticsearch/plugins/definition/ElasticsearchQueryModifierPlugin");
+
+class CmsEntryElasticsearchQueryModifierPlugin extends _ElasticsearchQueryModifierPlugin.ElasticsearchQueryModifierPlugin {
+  constructor(config) {
+    super(config.modifyQuery);
+    (0, _defineProperty2.default)(this, "modelId", void 0);
+    this.modelId = config.modelId;
+  }
+
+}
+
+exports.CmsEntryElasticsearchQueryModifierPlugin = CmsEntryElasticsearchQueryModifierPlugin;
+(0, _defineProperty2.default)(CmsEntryElasticsearchQueryModifierPlugin, "type", "cms.elasticsearch.modifier.query.entry");

package/plugins/CmsEntryElasticsearchSortModifierPlugin.d.ts

@@ -0,0 +1,17 @@
+import { ElasticsearchSortModifierPlugin, ModifySortCallable, ModifySortParams as BaseModifySortParams } from "@webiny/api-elasticsearch/plugins/definition/ElasticsearchSortModifierPlugin";
+import { CmsModel } from "@webiny/api-headless-cms/types";
+export interface ModifySortParams extends BaseModifySortParams {
+    model: CmsModel;
+}
+export interface Config {
+    modifySort: ModifySortCallable<ModifySortParams>;
+    /**
+     * If modelId is not passed, there is no filtering of plugins by it when plugin is applied during the runtime.
+     */
+    modelId?: string;
+}
+export declare class CmsEntryElasticsearchSortModifierPlugin extends ElasticsearchSortModifierPlugin<ModifySortParams> {
+    static readonly type: string;
+    readonly modelId?: string;
+    constructor(config: Config);
+}

package/plugins/CmsEntryElasticsearchSortModifierPlugin.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CmsEntryElasticsearchSortModifierPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ElasticsearchSortModifierPlugin = require("@webiny/api-elasticsearch/plugins/definition/ElasticsearchSortModifierPlugin");
+
+class CmsEntryElasticsearchSortModifierPlugin extends _ElasticsearchSortModifierPlugin.ElasticsearchSortModifierPlugin {
+  constructor(config) {
+    super(config.modifySort);
+    (0, _defineProperty2.default)(this, "modelId", void 0);
+    this.modelId = config.modelId;
+  }
+
+}
+
+exports.CmsEntryElasticsearchSortModifierPlugin = CmsEntryElasticsearchSortModifierPlugin;
+(0, _defineProperty2.default)(CmsEntryElasticsearchSortModifierPlugin, "type", "cms.elasticsearch.modifier.sort.entry");

package/types.d.ts

@@ -0,0 +1,191 @@
+import { Plugin } from "@webiny/plugins/types";
+import { CmsEntry, CmsModel, CmsModelField, CmsModelFieldToGraphQLPlugin, HeadlessCmsStorageOperations as BaseHeadlessCmsStorageOperations } from "@webiny/api-headless-cms/types";
+import { DynamoDBTypes, TableConstructor } from "dynamodb-toolbox/dist/classes/Table";
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
+import { EntityAttributeConfig, EntityCompositeAttributes } from "dynamodb-toolbox/dist/classes/Entity";
+import { Client } from "@elastic/elasticsearch";
+import { Entity, Table } from "dynamodb-toolbox";
+import { PluginsContainer } from "@webiny/plugins";
+/**
+ * Arguments for ElasticsearchQueryBuilderValueSearchPlugin.
+ *
+ * @see ElasticsearchQueryBuilderValueSearchPlugin.transform
+ */
+interface ElasticsearchQueryBuilderValueSearchPluginArgs {
+    field: CmsModelField;
+    value: any;
+}
+/**
+ * A plugin definition for transforming the search value for Elasticsearch.
+ *
+ * @category Plugin
+ * @category Elasticsearch
+ */
+export interface ElasticsearchQueryBuilderValueSearchPlugin extends Plugin {
+    /**
+     * A plugin type.
+     */
+    type: "cms-elastic-search-query-builder-value-search";
+    /**
+     * A field type for plugin to target.
+     */
+    fieldType: string;
+    /**
+     * Transform value that is going to be searched for in the Elasticsearch.
+     */
+    transform: (args: ElasticsearchQueryBuilderValueSearchPluginArgs) => any;
+}
+/**
+ * A definition of the entry that is being prepared for the Elasticsearch.
+ *
+ * @category Elasticsearch
+ * @category CmsEntry
+ */
+export interface CmsIndexEntry extends CmsEntry {
+    /**
+     * Values that are not going to be indexed.
+     */
+    rawValues: Record<string, any>;
+    /**
+     * A first part of the ID, without the revision.
+     * For example, we can search for all the revisions of the given entry.
+     */
+    primaryId: string;
+    /**
+     * Dev can add what ever keys they want and need. Just need to be careful not to break the entry.
+     */
+    [key: string]: any;
+}
+/**
+ * Arguments for the method that is transforming content entry in its original form to the one we are storing to the Elasticsearch.
+ *
+ * @category Elasticsearch
+ * @category CmsEntry
+ */
+interface CmsModelFieldToElasticsearchToParams {
+    plugins: PluginsContainer;
+    model: CmsModel;
+    field: CmsModelField;
+    /**
+     * Raw value on the entry - before prepare for storage.
+     */
+    rawValue: any;
+    /**
+     * Value prepared for storage received from base api-headless-cms package.
+     */
+    value: any;
+    getFieldIndexPlugin(fieldType: string): CmsModelFieldToElasticsearchPlugin;
+    getFieldTypePlugin(fieldType: string): CmsModelFieldToGraphQLPlugin;
+}
+/**
+ * Arguments for the method that is transforming content entry from Elasticsearch into the original one.
+ *
+ * @category Elasticsearch
+ * @category CmsEntry
+ */
+interface CmsModelFieldToElasticsearchFromParams {
+    plugins: PluginsContainer;
+    model: CmsModel;
+    field: CmsModelField;
+    value: any;
+    rawValue: any;
+    getFieldIndexPlugin(fieldType: string): CmsModelFieldToElasticsearchPlugin;
+    getFieldTypePlugin(fieldType: string): CmsModelFieldToGraphQLPlugin;
+}
+interface ToIndexValue {
+    /**
+     * Use this key to store value for indexing.
+     */
+    value?: any;
+    /**
+     * Use this key to tell ES that this value should not be indexed.
+     */
+    rawValue?: any;
+}
+/**
+ * A plugin defining transformation of entry for Elasticsearch.
+ *
+ * @category Plugin
+ * @category ContentModelField
+ * @category CmsEntry
+ * @category Elasticsearch
+ */
+export interface CmsModelFieldToElasticsearchPlugin extends Plugin {
+    /**
+     * A plugin type
+     */
+    type: "cms-model-field-to-elastic-search";
+    /**
+     * A unique identifier of the field type (text, number, json, myField, ...).
+     *
+     * ```ts
+     * fieldType: "myField"
+     * ```
+     */
+    fieldType: string;
+    /**
+     * If you need to define a type when building an Elasticsearch query.
+     * Check [dateTimeIndexing](https://github.com/webiny/webiny-js/blob/3074165701b8b45e5fc6ac2444caace7d04ada66/packages/api-headless-cms/src/content/plugins/es/indexing/dateTimeIndexing.ts) plugin for usage example.
+     *
+     * ```ts
+     * unmappedType: "date"
+     * ```
+     */
+    unmappedType?: (field: CmsModelField) => string;
+    /**
+     * This is meant to do some transformation of the entry, preferably only to fieldType it was defined for. Nothing is stopping you to do anything you want to other fields, but try to separate field transformations.
+     * It returns `Partial<CmsContentIndexEntryType>`. Always return a top-level property of the entry since it is merged via spread operator.
+     *
+     * ```ts
+     * toIndex({ value }) {
+     *    return {
+     *        value: value, // This will be stored and indexed
+     *        rawValue: JSON.stringify(value) // This will be stored but excluded from indexing
+     *    };
+     * }
+     * ```
+     */
+    toIndex?: (params: CmsModelFieldToElasticsearchToParams) => ToIndexValue;
+    /**
+     * This is meant to revert a transformation done in the `toIndex` method.
+     * You have access to "value" or a "rawValue", depending on what you returned from `toIndex`.
+     *
+     * ```ts
+     * fromIndex({ value, rawValue }) {
+     *     return JSON.parse(rawValue);
+     * }
+     * ```
+     */
+    fromIndex?: (params: CmsModelFieldToElasticsearchFromParams) => any;
+}
+export declare type AttributeDefinition = DynamoDBTypes | EntityAttributeConfig | EntityCompositeAttributes;
+export declare type Attributes = Record<string, AttributeDefinition>;
+export declare enum ENTITIES {
+    SYSTEM = "CmsSystem",
+    SETTINGS = "CmsSettings",
+    GROUPS = "CmsGroups",
+    MODELS = "CmsModels",
+    ENTRIES = "CmsEntries",
+    ENTRIES_ES = "CmsEntriesElasticsearch"
+}
+export interface TableModifier {
+    (table: TableConstructor): TableConstructor;
+}
+export interface StorageOperationsFactoryParams {
+    documentClient: DocumentClient;
+    elasticsearch: Client;
+    table?: TableModifier;
+    esTable?: TableModifier;
+    modelFieldToGraphQLPlugins: CmsModelFieldToGraphQLPlugin[];
+    attributes?: Record<ENTITIES, Attributes>;
+    plugins?: Plugin[] | Plugin[][];
+}
+export interface HeadlessCmsStorageOperations extends BaseHeadlessCmsStorageOperations {
+    getTable: () => Table;
+    getEsTable: () => Table;
+    getEntities: () => Record<"system" | "settings" | "groups" | "models" | "entries" | "entriesEs", Entity<any>>;
+}
+export interface StorageOperationsFactory {
+    (params: StorageOperationsFactoryParams): HeadlessCmsStorageOperations;
+}
+export {};

package/types.js

@@ -0,0 +1,60 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ENTITIES = void 0;
+
+/**
+ * Arguments for ElasticsearchQueryBuilderValueSearchPlugin.
+ *
+ * @see ElasticsearchQueryBuilderValueSearchPlugin.transform
+ */
+
+/**
+ * A plugin definition for transforming the search value for Elasticsearch.
+ *
+ * @category Plugin
+ * @category Elasticsearch
+ */
+
+/**
+ * A definition of the entry that is being prepared for the Elasticsearch.
+ *
+ * @category Elasticsearch
+ * @category CmsEntry
+ */
+
+/**
+ * Arguments for the method that is transforming content entry in its original form to the one we are storing to the Elasticsearch.
+ *
+ * @category Elasticsearch
+ * @category CmsEntry
+ */
+
+/**
+ * Arguments for the method that is transforming content entry from Elasticsearch into the original one.
+ *
+ * @category Elasticsearch
+ * @category CmsEntry
+ */
+
+/**
+ * A plugin defining transformation of entry for Elasticsearch.
+ *
+ * @category Plugin
+ * @category ContentModelField
+ * @category CmsEntry
+ * @category Elasticsearch
+ */
+let ENTITIES;
+exports.ENTITIES = ENTITIES;
+
+(function (ENTITIES) {
+  ENTITIES["SYSTEM"] = "CmsSystem";
+  ENTITIES["SETTINGS"] = "CmsSettings";
+  ENTITIES["GROUPS"] = "CmsGroups";
+  ENTITIES["MODELS"] = "CmsModels";
+  ENTITIES["ENTRIES"] = "CmsEntries";
+  ENTITIES["ENTRIES_ES"] = "CmsEntriesElasticsearch";
+})(ENTITIES || (exports.ENTITIES = ENTITIES = {}));

package/upgrades/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("@webiny/api-upgrade").UpgradePlugin<import("@webiny/api-headless-cms/types").CmsContext>[];
+export default _default;

package/upgrades/index.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _index = _interopRequireDefault(require("./v5.0.0/index"));
+
+var _index2 = _interopRequireDefault(require("./v5.8.0/index"));
+
+var _default = () => [(0, _index.default)(), (0, _index2.default)()];
+
+exports.default = _default;

package/upgrades/utils.d.ts

@@ -0,0 +1 @@
+export declare const paginateBatch: (items: any, perPage: any, execute: any) => Promise<void>;

package/upgrades/utils.js

@@ -0,0 +1,16 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.paginateBatch = void 0;
+
+const paginateBatch = async (items, perPage, execute) => {
+  const pages = Math.ceil(items.length / perPage);
+
+  for (let i = 0; i < pages; i++) {
+    await execute(items.slice(i * perPage, i * perPage + perPage));
+  }
+};
+
+exports.paginateBatch = paginateBatch;

package/upgrades/v5.0.0/cleanDatabaseRecord.d.ts

@@ -0,0 +1,6 @@
+import { CmsEntry, CmsModel } from "@webiny/api-headless-cms/types";
+export declare const cleanDatabaseRecord: <T extends CmsModel | CmsEntry>(record: T & {
+    PK?: string;
+    SK?: string;
+    TYPE?: string;
+}) => T;

package/upgrades/v5.0.0/cleanDatabaseRecord.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanDatabaseRecord = void 0;
+
+var _lodash = _interopRequireDefault(require("lodash.omit"));
+
+const cleanDatabaseRecord = record => {
+  return (0, _lodash.default)(record, ["PK", "SK", "TYPE"]);
+};
+
+exports.cleanDatabaseRecord = cleanDatabaseRecord;

package/upgrades/v5.0.0/createOldVersionIndiceName.d.ts

@@ -0,0 +1,2 @@
+import { CmsContext } from "@webiny/api-headless-cms/types";
+export declare const createOldVersionIndiceName: (context: CmsContext) => string;