@webiny/api-headless-cms-ddb 5.15.0-beta.0

package/dynamoDb/storage/richText.js

@@ -0,0 +1,108 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _jsonpack = _interopRequireDefault(require("jsonpack"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+/**
+ * Remove when jsonpack gets PR with a fix merged
+ * https://github.com/rgcl/jsonpack/pull/25/files
+ * NOTE 2021-07-28: it seems PR is not going to be merged so keep this.
+ */
+const transformArray = value => {
+  let isArray = Array.isArray(value);
+  const shouldBeArray = value instanceof Array === false && isArray;
+
+  if (shouldBeArray) {
+    value = Array.from(value);
+    isArray = true;
+  }
+
+  if (typeof value === "object" || isArray) {
+    for (const k in value) {
+      value[k] = transformArray(value[k]);
+    }
+  }
+
+  return value;
+};
+
+var _default = () => {
+  return {
+    type: "cms-model-field-to-storage",
+    name: "cms-model-field-to-storage-rich-text",
+    fieldType: "rich-text",
+
+    async fromStorage({
+      field,
+      value: storageValue
+    }) {
+      if (!storageValue) {
+        return storageValue;
+      } else if (typeof storageValue !== "object") {
+        throw new _error.default(`Value received in "fromStorage" function is not an object in field "${field.fieldId}".`);
+      }
+      /**
+       * This is to circumvent a bug introduced with 5.8.0 storage operations.
+       * Do not remove.
+       */
+
+
+      if (storageValue.hasOwnProperty("compression") === false) {
+        return storageValue;
+      }
+
+      const {
+        compression,
+        value
+      } = storageValue;
+
+      if (!compression) {
+        throw new _error.default(`Missing compression in "fromStorage" function in field "${field.fieldId}": ${JSON.stringify(storageValue)}.`, "MISSING_COMPRESSION", {
+          value: storageValue
+        });
+      }
+
+      if (compression !== "jsonpack") {
+        throw new _error.default(`This plugin cannot transform something not packed with "jsonpack".`, "WRONG_COMPRESSION", {
+          compression
+        });
+      }
+
+      try {
+        return _jsonpack.default.unpack(value);
+      } catch {
+        return null;
+      }
+    },
+
+    async toStorage({
+      value
+    }) {
+      /**
+       * There is a possibility that we are trying to compress already compressed value.
+       * Introduced a bug with 5.8.0 storage operations, so just return the value to correct it.
+       */
+      if (value && value.hasOwnProperty("compression") === true) {
+        return value;
+      }
+
+      value = transformArray(value);
+      return {
+        compression: "jsonpack",
+        value: value ? _jsonpack.default.pack(value) : value
+      };
+    }
+
+  };
+};
+
+exports.default = _default;
+//# sourceMappingURL=richText.js.map

package/dynamoDb/storage/richText.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/dynamoDb/storage/richText.ts"],"names":["transformArray","value","isArray","Array","shouldBeArray","from","k","type","name","fieldType","fromStorage","field","storageValue","WebinyError","fieldId","hasOwnProperty","compression","JSON","stringify","jsonpack","unpack","toStorage","pack"],"mappings":";;;;;;;;;AAAA;;AACA;;AAUA;AACA;AACA;AACA;AACA;AACA,MAAMA,cAAc,GAAIC,KAAD,IAAwC;AAC3D,MAAIC,OAAO,GAAGC,KAAK,CAACD,OAAN,CAAcD,KAAd,CAAd;AACA,QAAMG,aAAa,GAAGH,KAAK,YAAYE,KAAjB,KAA2B,KAA3B,IAAoCD,OAA1D;;AACA,MAAIE,aAAJ,EAAmB;AACfH,IAAAA,KAAK,GAAGE,KAAK,CAACE,IAAN,CAAWJ,KAAX,CAAR;AACAC,IAAAA,OAAO,GAAG,IAAV;AACH;;AACD,MAAI,OAAOD,KAAP,KAAiB,QAAjB,IAA6BC,OAAjC,EAA0C;AACtC,SAAK,MAAMI,CAAX,IAAgBL,KAAhB,EAAuB;AACnBA,MAAAA,KAAK,CAACK,CAAD,CAAL,GAAWN,cAAc,CAACC,KAAK,CAACK,CAAD,CAAN,CAAzB;AACH;AACJ;;AACD,SAAOL,KAAP;AACH,CAbD;;eAee,MAAiE;AAC5E,SAAO;AACHM,IAAAA,IAAI,EAAE,4BADH;AAEHC,IAAAA,IAAI,EAAE,sCAFH;AAGHC,IAAAA,SAAS,EAAE,WAHR;;AAIH,UAAMC,WAAN,CAAkB;AAAEC,MAAAA,KAAF;AAASV,MAAAA,KAAK,EAAEW;AAAhB,KAAlB,EAAkD;AAC9C,UAAI,CAACA,YAAL,EAAmB;AACf,eAAOA,YAAP;AACH,OAFD,MAEO,IAAI,OAAOA,YAAP,KAAwB,QAA5B,EAAsC;AACzC,cAAM,IAAIC,cAAJ,CACD,uEAAsEF,KAAK,CAACG,OAAQ,IADnF,CAAN;AAGH;AACD;AACZ;AACA;AACA;;;AACY,UAAIF,YAAY,CAACG,cAAb,CAA4B,aAA5B,MAA+C,KAAnD,EAA0D;AACtD,eAAOH,YAAP;AACH;;AACD,YAAM;AAAEI,QAAAA,WAAF;AAAef,QAAAA;AAAf,UAAyBW,YAA/B;;AACA,UAAI,CAACI,WAAL,EAAkB;AACd,cAAM,IAAIH,cAAJ,CACD,2DACGF,KAAK,CAACG,OACT,MAAKG,IAAI,CAACC,SAAL,CAAeN,YAAf,CAA6B,GAHjC,EAIF,qBAJE,EAKF;AACIX,UAAAA,KAAK,EAAEW;AADX,SALE,CAAN;AASH;;AACD,UAAII,WAAW,KAAK,UAApB,EAAgC;AAC5B,cAAM,IAAIH,cAAJ,CACD,oEADC,EAEF,mBAFE,EAGF;AACIG,UAAAA;AADJ,SAHE,CAAN;AAOH;;AACD,UAAI;AACA,eAAOG,kBAASC,MAAT,CAAgBnB,KAAhB,CAAP;AACH,OAFD,CAEE,MAAM;AACJ,eAAO,IAAP;AACH;AACJ,KA7CE;;AA8CH,UAAMoB,SAAN,CAAgB;AAAEpB,MAAAA;AAAF,KAAhB,EAA2B;AACvB;AACZ;AACA;AACA;AACY,UAAIA,KAAK,IAAIA,KAAK,CAACc,cAAN,CAAqB,aAArB,MAAwC,IAArD,EAA2D;AACvD,eAAOd,KAAP;AACH;;AACDA,MAAAA,KAAK,GAAGD,cAAc,CAACC,KAAD,CAAtB;AACA,aAAO;AACHe,QAAAA,WAAW,EAAE,UADV;AAEHf,QAAAA,KAAK,EAAEA,KAAK,GAAGkB,kBAASG,IAAT,CAAcrB,KAAd,CAAH,GAA0BA;AAFnC,OAAP;AAIH;;AA3DE,GAAP;AA6DH,C","sourcesContent":["import jsonpack from \"jsonpack\";\nimport WebinyError from \"@webiny/error\";\nimport { CmsModelFieldToStoragePlugin } from \"@webiny/api-headless-cms/types\";\n\nexport type OriginalValue = Record<string, any> | any[];\n\nexport interface StorageValue {\n    compression: string;\n    value: any;\n}\n\n/**\n * Remove when jsonpack gets PR with a fix merged\n * https://github.com/rgcl/jsonpack/pull/25/files\n * NOTE 2021-07-28: it seems PR is not going to be merged so keep this.\n */\nconst transformArray = (value: Record<string, any> | any[]) => {\n    let isArray = Array.isArray(value);\n    const shouldBeArray = value instanceof Array === false && isArray;\n    if (shouldBeArray) {\n        value = Array.from(value as any);\n        isArray = true;\n    }\n    if (typeof value === \"object\" || isArray) {\n        for (const k in value) {\n            value[k] = transformArray(value[k]);\n        }\n    }\n    return value;\n};\n\nexport default (): CmsModelFieldToStoragePlugin<OriginalValue, StorageValue> => {\n    return {\n        type: \"cms-model-field-to-storage\",\n        name: \"cms-model-field-to-storage-rich-text\",\n        fieldType: \"rich-text\",\n        async fromStorage({ field, value: storageValue }) {\n            if (!storageValue) {\n                return storageValue;\n            } else if (typeof storageValue !== \"object\") {\n                throw new WebinyError(\n                    `Value received in \"fromStorage\" function is not an object in field \"${field.fieldId}\".`\n                );\n            }\n            /**\n             * This is to circumvent a bug introduced with 5.8.0 storage operations.\n             * Do not remove.\n             */\n            if (storageValue.hasOwnProperty(\"compression\") === false) {\n                return storageValue;\n            }\n            const { compression, value } = storageValue;\n            if (!compression) {\n                throw new WebinyError(\n                    `Missing compression in \"fromStorage\" function in field \"${\n                        field.fieldId\n                    }\": ${JSON.stringify(storageValue)}.`,\n                    \"MISSING_COMPRESSION\",\n                    {\n                        value: storageValue\n                    }\n                );\n            }\n            if (compression !== \"jsonpack\") {\n                throw new WebinyError(\n                    `This plugin cannot transform something not packed with \"jsonpack\".`,\n                    \"WRONG_COMPRESSION\",\n                    {\n                        compression\n                    }\n                );\n            }\n            try {\n                return jsonpack.unpack(value);\n            } catch {\n                return null;\n            }\n        },\n        async toStorage({ value }) {\n            /**\n             * There is a possibility that we are trying to compress already compressed value.\n             * Introduced a bug with 5.8.0 storage operations, so just return the value to correct it.\n             */\n            if (value && value.hasOwnProperty(\"compression\") === true) {\n                return value as any;\n            }\n            value = transformArray(value);\n            return {\n                compression: \"jsonpack\",\n                value: value ? jsonpack.pack(value) : value\n            };\n        }\n    };\n};\n"],"file":"richText.js"}

package/dynamoDb/transformValue/datetime.d.ts

@@ -0,0 +1,3 @@
+import { CmsFieldFilterValueTransformPlugin } from "../../types";
+declare const _default: () => CmsFieldFilterValueTransformPlugin<Date | string | number, number>;
+export default _default;

package/dynamoDb/transformValue/datetime.js

@@ -0,0 +1,48 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _TimeTransformPlugin = require("@webiny/db-dynamodb/plugins/definitions/TimeTransformPlugin");
+
+var _DateTimeTransformPlugin = require("@webiny/db-dynamodb/plugins/definitions/DateTimeTransformPlugin");
+
+const timeTransformer = new _TimeTransformPlugin.TimeTransformPlugin({
+  fields: ["*"]
+});
+const dateTimeTransformer = new _DateTimeTransformPlugin.DateTimeTransformPlugin({
+  fields: ["*"]
+});
+
+var _default = () => ({
+  type: "cms-field-filter-value-transform",
+  name: "cms-field-value-filter-transform-datetime",
+  fieldType: "datetime",
+
+  /**
+   * Always transform into the milliseconds.
+   */
+  transform: ({
+    field,
+    value
+  }) => {
+    const {
+      type
+    } = field.settings || {};
+
+    if (type === "time") {
+      return timeTransformer.transform({
+        value
+      });
+    }
+
+    return dateTimeTransformer.transform({
+      value
+    });
+  }
+});
+
+exports.default = _default;
+//# sourceMappingURL=datetime.js.map

package/dynamoDb/transformValue/datetime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/dynamoDb/transformValue/datetime.ts"],"names":["timeTransformer","TimeTransformPlugin","fields","dateTimeTransformer","DateTimeTransformPlugin","type","name","fieldType","transform","field","value","settings"],"mappings":";;;;;;;AACA;;AACA;;AAEA,MAAMA,eAAe,GAAG,IAAIC,wCAAJ,CAAwB;AAC5CC,EAAAA,MAAM,EAAE,CAAC,GAAD;AADoC,CAAxB,CAAxB;AAGA,MAAMC,mBAAmB,GAAG,IAAIC,gDAAJ,CAA4B;AACpDF,EAAAA,MAAM,EAAE,CAAC,GAAD;AAD4C,CAA5B,CAA5B;;eAIe,OAA2E;AACtFG,EAAAA,IAAI,EAAE,kCADgF;AAEtFC,EAAAA,IAAI,EAAE,2CAFgF;AAGtFC,EAAAA,SAAS,EAAE,UAH2E;;AAItF;AACJ;AACA;AACIC,EAAAA,SAAS,EAAE,CAAC;AAAEC,IAAAA,KAAF;AAASC,IAAAA;AAAT,GAAD,KAAsB;AAC7B,UAAM;AAAEL,MAAAA;AAAF,QAAWI,KAAK,CAACE,QAAN,IAAkB,EAAnC;;AACA,QAAIN,IAAI,KAAK,MAAb,EAAqB;AACjB,aAAOL,eAAe,CAACQ,SAAhB,CAA0B;AAC7BE,QAAAA;AAD6B,OAA1B,CAAP;AAGH;;AACD,WAAOP,mBAAmB,CAACK,SAApB,CAA8B;AACjCE,MAAAA;AADiC,KAA9B,CAAP;AAGH;AAjBqF,CAA3E,C","sourcesContent":["import { CmsFieldFilterValueTransformPlugin } from \"~/types\";\nimport { TimeTransformPlugin } from \"@webiny/db-dynamodb/plugins/definitions/TimeTransformPlugin\";\nimport { DateTimeTransformPlugin } from \"@webiny/db-dynamodb/plugins/definitions/DateTimeTransformPlugin\";\n\nconst timeTransformer = new TimeTransformPlugin({\n    fields: [\"*\"]\n});\nconst dateTimeTransformer = new DateTimeTransformPlugin({\n    fields: [\"*\"]\n});\n\nexport default (): CmsFieldFilterValueTransformPlugin<Date | string | number, number> => ({\n    type: \"cms-field-filter-value-transform\",\n    name: \"cms-field-value-filter-transform-datetime\",\n    fieldType: \"datetime\",\n    /**\n     * Always transform into the milliseconds.\n     */\n    transform: ({ field, value }) => {\n        const { type } = field.settings || {};\n        if (type === \"time\") {\n            return timeTransformer.transform({\n                value\n            });\n        }\n        return dateTimeTransformer.transform({\n            value\n        });\n    }\n});\n"],"file":"datetime.js"}

package/index.d.ts

@@ -0,0 +1,6 @@
+import { CmsContentEntryConfiguration } from "./operations/entry/CmsContentEntryDynamo";
+interface Configuration {
+    entry?: CmsContentEntryConfiguration;
+}
+declare const _default: (configuration?: Configuration) => (import("@webiny/api-headless-cms/types").CmsContentModelGroupStorageOperationsProvider | import("@webiny/api-headless-cms/types").CmsContentModelStorageOperationsProvider | import("@webiny/api-headless-cms/types").CmsContentEntryStorageOperationsProvider | import("@webiny/api-headless-cms/types").CmsSettingsStorageOperationsProviderPlugin | import("@webiny/api-headless-cms/types").CmsSystemStorageOperationsProviderPlugin | (import("./types").CmsFieldFilterPathPlugin | import("@webiny/api-headless-cms/types").CmsModelFieldToStoragePlugin<import("./dynamoDb/storage/richText").OriginalValue, import("./dynamoDb/storage/richText").StorageValue> | import("@webiny/api-headless-cms/types").CmsModelFieldToStoragePlugin<string | Date, string> | import("./types").CmsFieldFilterValueTransformPlugin<string | number | Date, number>)[])[];
+export default _default;

package/index.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _settings = _interopRequireDefault(require("./operations/settings"));
+
+var _system = _interopRequireDefault(require("./operations/system"));
+
+var _modelGroup = _interopRequireDefault(require("./operations/modelGroup"));
+
+var _model = _interopRequireDefault(require("./operations/model"));
+
+var _entry = _interopRequireDefault(require("./operations/entry"));
+
+var _dynamoDb = _interopRequireDefault(require("./dynamoDb"));
+
+var _default = configuration => {
+  const {
+    entry
+  } = configuration || {};
+  return [(0, _settings.default)(), (0, _system.default)(), (0, _modelGroup.default)(), (0, _model.default)(), (0, _entry.default)(entry), (0, _dynamoDb.default)()];
+};
+
+exports.default = _default;
+//# sourceMappingURL=index.js.map

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["configuration","entry"],"mappings":";;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;eAMgBA,aAAD,IAAmC;AAC9C,QAAM;AAAEC,IAAAA;AAAF,MAAYD,aAAa,IAAI,EAAnC;AACA,SAAO,CACH,wBADG,EAEH,sBAFG,EAGH,0BAHG,EAIH,qBAJG,EAKH,oBAAsCC,KAAtC,CALG,EAMH,wBANG,CAAP;AAQH,C","sourcesContent":["import settingsOperationsProvider from \"./operations/settings\";\nimport systemOperationsProvider from \"./operations/system\";\nimport contentModelGroupStorageOperationsProvider from \"./operations/modelGroup\";\nimport contentModelStorageOperationsProvider from \"./operations/model\";\nimport contentEntryStorageOperationsProvider from \"./operations/entry\";\nimport dynamoDbPlugins from \"./dynamoDb\";\nimport { CmsContentEntryConfiguration } from \"./operations/entry/CmsContentEntryDynamo\";\n\ninterface Configuration {\n    entry?: CmsContentEntryConfiguration;\n}\nexport default (configuration?: Configuration) => {\n    const { entry } = configuration || {};\n    return [\n        settingsOperationsProvider(),\n        systemOperationsProvider(),\n        contentModelGroupStorageOperationsProvider(),\n        contentModelStorageOperationsProvider(),\n        contentEntryStorageOperationsProvider(entry),\n        dynamoDbPlugins()\n    ];\n};\n"],"file":"index.js"}

package/operations/entry/CmsContentEntryDynamo.d.ts

@@ -0,0 +1,86 @@
+import { CmsContentEntry, CmsContentEntryStorageOperations, CmsContentEntryStorageOperationsCreateArgs, CmsContentEntryStorageOperationsCreateRevisionFromArgs, CmsContentEntryStorageOperationsDeleteArgs, CmsContentEntryStorageOperationsDeleteRevisionArgs, CmsContentEntryStorageOperationsGetArgs, CmsContentEntryStorageOperationsListArgs, CmsContentEntryStorageOperationsListResponse, CmsContentEntryStorageOperationsPublishArgs, CmsContentEntryStorageOperationsRequestChangesArgs, CmsContentEntryStorageOperationsRequestReviewArgs, CmsContentEntryStorageOperationsUnpublishArgs, CmsContentEntryStorageOperationsUpdateArgs, CmsContentModel, CmsContext } from "@webiny/api-headless-cms/types";
+import { Entity, Table } from "dynamodb-toolbox";
+import { queryOptions as DynamoDBToolboxQueryOptions } from "dynamodb-toolbox/dist/classes/Table";
+export declare const TYPE_ENTRY = "cms.entry";
+export declare const TYPE_ENTRY_LATEST: string;
+export declare const TYPE_ENTRY_PUBLISHED: string;
+export interface CmsContentEntryConfiguration {
+    defaultLimit?: number;
+    maxLimit?: number;
+}
+interface ConstructorArgs {
+    context: CmsContext;
+    configuration: CmsContentEntryConfiguration;
+}
+interface RunQueryArgs {
+    options?: DynamoDBToolboxQueryOptions;
+    partitionKey: string;
+}
+/**
+ * We do not use transactions in this storage operations implementation due to their cost.
+ */
+export declare class CmsContentEntryDynamo implements CmsContentEntryStorageOperations {
+    private readonly _context;
+    private readonly _configuration;
+    private readonly _modelPartitionKey;
+    private readonly _dataLoaders;
+    private readonly _table;
+    private readonly _entity;
+    private get context();
+    private get configuration();
+    get table(): Table;
+    get entity(): Entity<any>;
+    constructor({ context, configuration }: ConstructorArgs);
+    create(model: CmsContentModel, args: CmsContentEntryStorageOperationsCreateArgs): Promise<CmsContentEntry>;
+    createRevisionFrom(model: CmsContentModel, args: CmsContentEntryStorageOperationsCreateRevisionFromArgs): Promise<import("@webiny/api-headless-cms/types").CmsStorageContentEntry>;
+    delete(model: CmsContentModel, args: CmsContentEntryStorageOperationsDeleteArgs): Promise<void>;
+    deleteRevision(model: CmsContentModel, args: CmsContentEntryStorageOperationsDeleteRevisionArgs): Promise<void>;
+    get(model: CmsContentModel, args: CmsContentEntryStorageOperationsGetArgs): Promise<CmsContentEntry | null>;
+    list(model: CmsContentModel, args: CmsContentEntryStorageOperationsListArgs): Promise<CmsContentEntryStorageOperationsListResponse>;
+    update(model: CmsContentModel, args: CmsContentEntryStorageOperationsUpdateArgs): Promise<CmsContentEntry>;
+    publish(model: CmsContentModel, args: CmsContentEntryStorageOperationsPublishArgs): Promise<CmsContentEntry>;
+    unpublish(model: CmsContentModel, args: CmsContentEntryStorageOperationsUnpublishArgs): Promise<CmsContentEntry>;
+    requestChanges(model: CmsContentModel, args: CmsContentEntryStorageOperationsRequestChangesArgs): Promise<CmsContentEntry>;
+    requestReview(model: CmsContentModel, args: CmsContentEntryStorageOperationsRequestReviewArgs): Promise<CmsContentEntry>;
+    getAllRevisionsByIds(model: CmsContentModel, ids: readonly string[]): Promise<CmsContentEntry[]>;
+    getByIds(model: CmsContentModel, ids: readonly string[]): Promise<CmsContentEntry[]>;
+    getPublishedByIds(model: CmsContentModel, ids: readonly string[]): Promise<CmsContentEntry[]>;
+    getLatestByIds(model: CmsContentModel, ids: readonly string[]): Promise<CmsContentEntry[]>;
+    getRevisions(model: CmsContentModel, id: string): Promise<CmsContentEntry[]>;
+    getRevisionById(model: CmsContentModel, id: string): Promise<CmsContentEntry | null>;
+    getPublishedRevisionByEntryId(model: CmsContentModel, entryId: string): Promise<CmsContentEntry | null>;
+    getLatestRevisionByEntryId(model: CmsContentModel, entryId: string): Promise<CmsContentEntry | null>;
+    getPreviousRevision(model: CmsContentModel, entryId: string, version: number): Promise<CmsContentEntry | null>;
+    private getSingleDynamoDbItem;
+    getPartitionKey(id: string): string;
+    private get partitionKey();
+    private getGSIPartitionKey;
+    private getGSIEntryPartitionKey;
+    private getGSILatestPartitionKey;
+    private getGSIPublishedPartitionKey;
+    private getGSISortKey;
+    /**
+     * Gets a secondary key in form of REV#version from:
+     *   id#0003
+     *   0003
+     *   3
+     */
+    getSortKeyRevision(version: string | number): string;
+    getSortKeyLatest(): string;
+    getSortKeyPublished(): string;
+    /**
+     * Method to build the query partition keys, always an array, and create the target index:
+     * - if undefined then it is primary
+     * - if populated then it is that given one (and partition keys are reflecting that)
+     */
+    private createQueryOptions;
+    /**
+     * A method to query the database at the given partition key with the built query options.
+     * Method runs in the loop until it reads everything it needs to.
+     * We could impose the limit on the records read but there is no point since we MUST read everything to be able
+     * to filter and sort the data.
+     */
+    runQuery(args: RunQueryArgs): Promise<CmsContentEntry[]>;
+    private query;
+}
+export {};

package/operations/entry/CmsContentEntryDynamo.js

@@ -0,0 +1,972 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.CmsContentEntryDynamo = exports.TYPE_ENTRY_PUBLISHED = exports.TYPE_ENTRY_LATEST = exports.TYPE_ENTRY = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _dataLoaders = require("./dataLoaders");
+
+var _types = require("@webiny/api-headless-cms/types");
+
+var _utils = require("@webiny/api-headless-cms/utils");
+
+var _utils2 = require("../../utils");
+
+var _utils3 = require("./utils");
+
+var _lodash = _interopRequireDefault(require("lodash.clonedeep"));
+
+var _entry = require("../../definitions/entry");
+
+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 TYPE_ENTRY = "cms.entry";
+exports.TYPE_ENTRY = TYPE_ENTRY;
+const TYPE_ENTRY_LATEST = TYPE_ENTRY + ".l";
+exports.TYPE_ENTRY_LATEST = TYPE_ENTRY_LATEST;
+const TYPE_ENTRY_PUBLISHED = TYPE_ENTRY + ".p";
+exports.TYPE_ENTRY_PUBLISHED = TYPE_ENTRY_PUBLISHED;
+const GSI1_INDEX = "GSI1";
+const configurationDefaults = {
+  defaultLimit: 100,
+  maxLimit: undefined
+};
+/**
+ * We do not use transactions in this storage operations implementation due to their cost.
+ */
+
+class CmsContentEntryDynamo {
+  get context() {
+    return this._context;
+  }
+
+  get configuration() {
+    return this._configuration;
+  }
+
+  get table() {
+    return this._table;
+  }
+
+  get entity() {
+    return this._entity;
+  }
+
+  constructor({
+    context,
+    configuration
+  }) {
+    (0, _defineProperty2.default)(this, "_context", void 0);
+    (0, _defineProperty2.default)(this, "_configuration", void 0);
+    (0, _defineProperty2.default)(this, "_modelPartitionKey", void 0);
+    (0, _defineProperty2.default)(this, "_dataLoaders", void 0);
+    (0, _defineProperty2.default)(this, "_table", void 0);
+    (0, _defineProperty2.default)(this, "_entity", void 0);
+    this._context = context;
+    this._configuration = _objectSpread(_objectSpread({}, configurationDefaults), configuration || {});
+    this._modelPartitionKey = `${this.partitionKey}#M`;
+    this._dataLoaders = new _dataLoaders.DataLoadersHandler(context, this);
+    this._table = (0, _table.createTable)({
+      context,
+      indexes: {
+        [GSI1_INDEX]: {
+          partitionKey: "GSI1_PK",
+          sortKey: "GSI1_SK"
+        }
+      }
+    });
+    this._entity = (0, _entry.createEntryEntity)({
+      table: this._table
+    });
+  }
+
+  async create(model, args) {
+    const {
+      entry,
+      storageEntry
+    } = args;
+    const partitionKey = this.getPartitionKey(entry.id);
+    /**
+     * We need to:
+     *  - create new main entry item
+     *  - create new or update latest entry item
+     */
+
+    const items = [this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: this.getSortKeyRevision(entry.version),
+      TYPE: TYPE_ENTRY,
+      GSI1_PK: this.getGSIEntryPartitionKey(model),
+      GSI1_SK: this.getGSISortKey(storageEntry)
+    })), this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: this.getSortKeyLatest(),
+      TYPE: TYPE_ENTRY_LATEST,
+      GSI1_PK: this.getGSILatestPartitionKey(model),
+      GSI1_SK: this.getGSISortKey(storageEntry)
+    }))];
+
+    try {
+      await this._table.batchWrite(items);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not insert data into the DynamoDB.", ex.code || "CREATE_ENTRY_ERROR", {
+        error: ex,
+        entry
+      });
+    }
+
+    return storageEntry;
+  }
+
+  async createRevisionFrom(model, args) {
+    const {
+      originalEntry,
+      entry,
+      storageEntry,
+      latestEntry
+    } = args;
+    const partitionKey = this.getPartitionKey(storageEntry.id);
+    /**
+     * We need to:
+     *  - create the main entry item
+     *  - update the last entry item to a current one
+     */
+
+    const items = [this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: this.getSortKeyRevision(storageEntry.version),
+      TYPE: TYPE_ENTRY,
+      GSI1_PK: this.getGSIEntryPartitionKey(model),
+      GSI1_SK: this.getGSISortKey(storageEntry)
+    })), this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: this.getSortKeyLatest(),
+      TYPE: TYPE_ENTRY_LATEST,
+      GSI1_PK: this.getGSILatestPartitionKey(model),
+      GSI1_SK: this.getGSISortKey(storageEntry)
+    }))];
+
+    try {
+      await this._table.batchWrite(items);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not create revision from given entry.", ex.code || "CREATE_REVISION_ERROR", {
+        error: ex,
+        originalEntry,
+        latestEntry,
+        entry,
+        storageEntry
+      });
+    }
+    /**
+     * There are no modifications on the entry created so just return the data.
+     */
+
+
+    return storageEntry;
+  }
+
+  async delete(model, args) {
+    const {
+      entry
+    } = args;
+    const partitionKey = this.getPartitionKey(entry.id);
+    const results = await this._entity.query(partitionKey, {
+      gte: " "
+    });
+    const keys = results.Items.map(item => ({
+      PK: partitionKey,
+      SK: item.SK
+    }));
+
+    try {
+      await this._table.batchWrite(keys.map(key => this._entity.deleteBatch(key)));
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not delete the entry.", ex.code || "DELETE_ENTRY_ERROR", {
+        error: ex,
+        partitionKey,
+        keys
+      });
+    }
+  }
+
+  async deleteRevision(model, args) {
+    const {
+      entryToDelete,
+      entryToSetAsLatest,
+      storageEntryToSetAsLatest
+    } = args;
+    const partitionKey = this.getPartitionKey(entryToDelete.id);
+    const items = [this._entity.deleteBatch({
+      PK: partitionKey,
+      SK: this.getSortKeyRevision(entryToDelete.id)
+    })];
+    const publishedStorageEntry = await this.getPublishedRevisionByEntryId(model, entryToDelete.id);
+    /**
+     * If revision we are deleting is the published one as well, we need to delete those records as well.
+     */
+
+    if (publishedStorageEntry && entryToDelete.id === publishedStorageEntry.id) {
+      items.push(this._entity.deleteBatch({
+        PK: partitionKey,
+        SK: this.getSortKeyPublished()
+      }));
+    }
+
+    if (storageEntryToSetAsLatest) {
+      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntryToSetAsLatest), {}, {
+        PK: partitionKey,
+        SK: this.getSortKeyLatest(),
+        TYPE: TYPE_ENTRY_LATEST,
+        GSI1_PK: this.getGSILatestPartitionKey(model),
+        GSI1_SK: this.getGSISortKey(storageEntryToSetAsLatest)
+      })));
+    }
+
+    try {
+      await this._table.batchWrite(items);
+    } catch (ex) {
+      throw new _error.default(ex.message, ex.code, {
+        error: ex,
+        entryToDelete,
+        entryToSetAsLatest
+      });
+    }
+  }
+
+  async get(model, args) {
+    const {
+      items
+    } = await this.list(model, _objectSpread(_objectSpread({}, args || {}), {}, {
+      limit: 1
+    }));
+
+    if (items.length === 0) {
+      return null;
+    }
+
+    return items.shift();
+  }
+
+  async list(model, args) {
+    const {
+      limit: initialLimit,
+      where: originalWhere,
+      after,
+      sort
+    } = args;
+    /**
+     * There is no max limit imposed because that is up to the devs using this.
+     * Default is some reasonable number for us but users can set their own when initializing the plugin.
+     */
+
+    const defaultLimit = this.configuration.defaultLimit || configurationDefaults.defaultLimit;
+    const maxLimit = this.configuration.maxLimit || defaultLimit;
+    const limit = !initialLimit || initialLimit <= 0 ? initialLimit > maxLimit ? maxLimit : defaultLimit : initialLimit;
+    const items = [];
+    const queryOptions = this.createQueryOptions({
+      where: originalWhere,
+      model
+    });
+
+    try {
+      /**
+       * We run the query method on all the partition keys that were built in the createQueryOptions() method.
+       * Partition keys are always built as array because of the possibility that we might need to read from different partitions
+       * which is the case if where condition is something like id_in or entryId_in.
+       * If we are reading from the GSI1_PK it is a single partition but we keep it as an array
+       * just to make it easier to read in all of the cases.
+       */
+      for (const partitionKey of queryOptions.queryPartitionKeys) {
+        const results = await this.runQuery({
+          partitionKey,
+          options: queryOptions.options
+        });
+        items.push(...results);
+      }
+    } catch (ex) {
+      throw new _error.default(ex.message, "SCAN_ERROR", {
+        error: ex
+      });
+    }
+    /**
+     * We need a object containing field, transformers and paths.
+     * Just build it here and pass on into other methods that require it to avoid mapping multiple times.
+     */
+
+
+    const modelFields = (0, _utils3.buildModelFields)({
+      context: this.context,
+      model
+    });
+    /**
+     * Filter the read items via the code.
+     * It will build the filters out of the where input and transform the values it is using.
+     */
+
+    const filteredItems = (0, _utils3.filterItems)({
+      items,
+      where: queryOptions.where,
+      context: this.context,
+      fields: modelFields
+    });
+    const totalCount = filteredItems.length;
+    /**
+     * Sorting is also done via the code.
+     * It takes the sort input and sorts by it via the lodash sortBy method.
+     */
+
+    const sortedItems = (0, _utils3.sortEntryItems)({
+      items: filteredItems,
+      sort,
+      fields: modelFields
+    });
+    const start = (0, _utils2.decodePaginationCursor)(after) || 0;
+    const hasMoreItems = totalCount > start + limit;
+    const end = limit > totalCount + start + limit ? undefined : start + limit;
+    const slicedItems = sortedItems.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 = totalCount > start + limit ? (0, _utils2.encodePaginationCursor)(start + limit) : null;
+    return {
+      hasMoreItems,
+      totalCount,
+      cursor,
+      items: slicedItems
+    };
+  }
+
+  async update(model, args) {
+    const {
+      originalEntry,
+      entry,
+      storageEntry
+    } = args;
+    const partitionKey = this.getPartitionKey(originalEntry.id);
+    const items = [];
+    /**
+     * We need to:
+     *  - update the current entry
+     *  - update the latest entry if the current entry is the latest one
+     */
+
+    items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: this.getSortKeyRevision(storageEntry.version),
+      TYPE: TYPE_ENTRY,
+      GSI1_PK: this.getGSIEntryPartitionKey(model),
+      GSI1_SK: this.getGSISortKey(storageEntry)
+    })));
+    /**
+     * We need the latest entry to update it as well if neccessary.
+     */
+
+    const latestStorageEntry = await this.getLatestRevisionByEntryId(model, entry.id);
+
+    if (latestStorageEntry && latestStorageEntry.id === entry.id) {
+      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+        PK: partitionKey,
+        SK: this.getSortKeyLatest(),
+        TYPE: TYPE_ENTRY_LATEST,
+        GSI1_PK: this.getGSILatestPartitionKey(model),
+        GSI1_SK: this.getGSISortKey(entry)
+      })));
+    }
+
+    try {
+      await this._table.batchWrite(items);
+      return storageEntry;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not update entry.", ex.code || "UPDATE_ERROR", {
+        error: ex,
+        originalEntry,
+        entry,
+        latestStorageEntry
+      });
+    }
+  }
+
+  async publish(model, args) {
+    const {
+      entry,
+      storageEntry
+    } = args;
+    const partitionKey = this.getPartitionKey(entry.id);
+    /**
+     * We need the latest and published entries to see if something needs to be updated along side the publishing one.
+     */
+
+    const latestStorageEntry = await this.getLatestRevisionByEntryId(model, entry.id);
+    const publishedStorageEntry = await this.getPublishedRevisionByEntryId(model, entry.id);
+    /**
+     * We need to update:
+     *  - current entry revision sort key
+     *  - published sort key
+     *  - latest sort key - if entry updated is actually latest
+     *  - previous published entry to unpublished status - if any previously published entry
+     */
+
+    const items = [this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: this.getSortKeyRevision(entry.version),
+      TYPE: TYPE_ENTRY,
+      GSI1_PK: this.getGSIEntryPartitionKey(model),
+      GSI1_SK: this.getGSISortKey(entry)
+    })), this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: this.getSortKeyPublished(),
+      TYPE: TYPE_ENTRY_PUBLISHED,
+      GSI1_PK: this.getGSIPublishedPartitionKey(model),
+      GSI1_SK: this.getGSISortKey(entry)
+    }))];
+
+    if (entry.id === latestStorageEntry.id) {
+      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+        PK: partitionKey,
+        SK: this.getSortKeyLatest(),
+        TYPE: TYPE_ENTRY_LATEST,
+        GSI1_PK: this.getGSILatestPartitionKey(model),
+        GSI1_SK: this.getGSISortKey(entry)
+      })));
+    }
+
+    if (publishedStorageEntry) {
+      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, publishedStorageEntry), {}, {
+        PK: partitionKey,
+        SK: this.getSortKeyRevision(publishedStorageEntry.version),
+        TYPE: TYPE_ENTRY,
+        status: _types.CONTENT_ENTRY_STATUS.UNPUBLISHED,
+        GSI1_PK: this.getGSIEntryPartitionKey(model),
+        GSI1_SK: this.getGSISortKey(publishedStorageEntry)
+      })));
+    }
+
+    try {
+      await this._table.batchWrite(items);
+
+      this._dataLoaders.clearAllEntryRevisions(model, entry);
+
+      return entry;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not execute the publishing batch.", ex.code || "PUBLISH_ERROR", {
+        entry,
+        latestStorageEntry,
+        publishedStorageEntry
+      });
+    }
+  }
+
+  async unpublish(model, args) {
+    const {
+      entry,
+      storageEntry
+    } = args;
+    const partitionKey = this.getPartitionKey(entry.id);
+    /**
+     * We need to:
+     *  - delete currently published entry
+     *  - update current entry revision with new data
+     *  - update latest entry status - if entry being unpublished is latest
+     */
+
+    const items = [this._entity.deleteBatch({
+      PK: partitionKey,
+      SK: this.getSortKeyPublished()
+    }), this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: this.getSortKeyRevision(entry.version),
+      TYPE: TYPE_ENTRY,
+      GSI1_PK: this.getGSIEntryPartitionKey(model),
+      GSI1_SK: this.getGSISortKey(entry)
+    }))];
+    /**
+     * We need the latest entry to see if something needs to be updated along side the unpublishing one.
+     */
+
+    const latestStorageEntry = await this.getLatestRevisionByEntryId(model, entry.id);
+
+    if (entry.id === latestStorageEntry.id) {
+      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+        PK: partitionKey,
+        SK: this.getSortKeyLatest(),
+        TYPE: TYPE_ENTRY_LATEST,
+        GSI1_PK: this.getGSILatestPartitionKey(model),
+        GSI1_SK: this.getGSISortKey(entry)
+      })));
+    }
+
+    try {
+      await this._table.batchWrite(items);
+      return storageEntry;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not execute unpublish batch.", ex.code || "UNPUBLISH_ERROR", {
+        entry,
+        storageEntry
+      });
+    }
+  }
+
+  async requestChanges(model, args) {
+    const {
+      entry,
+      storageEntry,
+      originalEntry
+    } = args;
+    const partitionKey = this.getPartitionKey(entry.id);
+    /**
+     * We need to:
+     *  - update the existing entry
+     *  - update latest version - if existing entry is the latest version
+     */
+
+    const items = [this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: this.getSortKeyRevision(entry.version),
+      GSI1_PK: this.getGSIEntryPartitionKey(model),
+      GSI1_SK: this.getGSISortKey(entry)
+    }))];
+    /**
+     * We need the latest entry to see if something needs to be updated along side the request changes one.
+     */
+
+    const latestStorageEntry = await this.getLatestRevisionByEntryId(model, entry.id);
+
+    if (latestStorageEntry.id === entry.id) {
+      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+        PK: partitionKey,
+        SK: this.getSortKeyLatest(),
+        TYPE: TYPE_ENTRY_LATEST,
+        GSI1_PK: this.getGSILatestPartitionKey(model),
+        GSI1_SK: this.getGSISortKey(entry)
+      })));
+    }
+
+    try {
+      await this._table.batchWrite(items);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not execute the request changes batch.", ex.code || "REQUEST_CHANGES_ERROR", {
+        entry,
+        originalEntry
+      });
+    }
+
+    return entry;
+  }
+
+  async requestReview(model, args) {
+    const {
+      entry,
+      storageEntry,
+      originalEntry
+    } = args;
+    const partitionKey = this.getPartitionKey(entry.id);
+    /**
+     * We need to:
+     *  - update existing entry
+     *  - update latest entry - if existing entry is the latest entry
+     */
+
+    const items = [this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+      PK: partitionKey,
+      SK: this.getSortKeyRevision(entry.version),
+      GSI1_PK: this.getGSIEntryPartitionKey(model),
+      GSI1_SK: this.getGSISortKey(entry)
+    }))];
+    /**
+     * We need the latest entry to see if something needs to be updated along side the request review one.
+     */
+
+    const latestStorageEntry = await this.getLatestRevisionByEntryId(model, entry.id);
+
+    if (latestStorageEntry.id === entry.id) {
+      items.push(this._entity.putBatch(_objectSpread(_objectSpread({}, storageEntry), {}, {
+        PK: partitionKey,
+        SK: this.getSortKeyLatest(),
+        TYPE: TYPE_ENTRY_LATEST,
+        GSI1_PK: this.getGSILatestPartitionKey(model),
+        GSI1_SK: this.getGSISortKey(entry)
+      })));
+    }
+
+    try {
+      await this._table.batchWrite(items);
+      return entry;
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not execute request review batch.", ex.code || "REQUEST_REVIEW_ERROR", {
+        entry,
+        storageEntry,
+        originalEntry
+      });
+    }
+  }
+
+  async getAllRevisionsByIds(model, ids) {
+    if (ids.length === 0) {
+      return [];
+    }
+
+    try {
+      return await this._dataLoaders.getAllEntryRevisions(model, ids);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not read multiple entries.", ex.code || "GET_ALL_REVISIONS_BY_IDS_ERROR", {
+        ids
+      });
+    }
+  }
+
+  async getByIds(model, ids) {
+    if (ids.length === 0) {
+      return [];
+    }
+
+    try {
+      return await this._dataLoaders.getRevisionById(model, ids);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not read multiple entries.", ex.code || "GET_BY_IDS_ERROR", {
+        ids
+      });
+    }
+  }
+
+  async getPublishedByIds(model, ids) {
+    if (ids.length === 0) {
+      return [];
+    }
+
+    try {
+      return await this._dataLoaders.getPublishedRevisionByEntryId(model, ids);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not read multiple entries.", ex.code || "GET_BY_IDS_ERROR", {
+        ids
+      });
+    }
+  }
+
+  async getLatestByIds(model, ids) {
+    if (ids.length === 0) {
+      return [];
+    }
+
+    try {
+      return await this._dataLoaders.getLatestRevisionByEntryId(model, ids);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not read multiple entries.", ex.code || "GET_BY_IDS_ERROR", {
+        ids
+      });
+    }
+  }
+
+  async getRevisions(model, id) {
+    try {
+      return await this._dataLoaders.getAllEntryRevisions(model, [id]);
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not read multiple entries.", ex.code || "GET_ALL_REVISIONS_BY_IDS_ERROR", {
+        id
+      });
+    }
+  }
+
+  async getRevisionById(model, id) {
+    return this.getSingleDynamoDbItem({
+      partitionKey: this.getPartitionKey(id),
+      value: this.getSortKeyRevision(id)
+    });
+  }
+
+  async getPublishedRevisionByEntryId(model, entryId) {
+    return this.getSingleDynamoDbItem({
+      partitionKey: this.getPartitionKey(entryId),
+      value: this.getSortKeyPublished()
+    });
+  }
+
+  async getLatestRevisionByEntryId(model, entryId) {
+    return this.getSingleDynamoDbItem({
+      partitionKey: this.getPartitionKey(entryId),
+      value: this.getSortKeyLatest()
+    });
+  }
+
+  async getPreviousRevision(model, entryId, version) {
+    const entry = await this.getSingleDynamoDbItem({
+      partitionKey: this.getPartitionKey(entryId),
+      op: "lt",
+      value: this.getSortKeyRevision(version),
+      order: "DESC"
+    });
+
+    if (entry.TYPE !== TYPE_ENTRY) {
+      return null;
+    }
+
+    return entry;
+  }
+
+  async getSingleDynamoDbItem(args) {
+    const {
+      partitionKey,
+      op = "eq",
+      value,
+      order = "ASC"
+    } = args;
+    const queryOptions = {
+      [op]: value,
+      reverse: order === "DESC",
+      limit: 1
+    };
+
+    try {
+      const result = await this._entity.query(partitionKey, queryOptions);
+
+      if (!result || Array.isArray(result.Items) === false) {
+        throw new _error.default("Error when querying for content entries - no result.", "QUERY_ERROR", {
+          partitionKey,
+          queryOptions
+        });
+      }
+
+      if (result.Items.length === 0) {
+        return null;
+      }
+
+      return result.Items.shift();
+    } catch (ex) {
+      throw new _error.default(ex.message || "Could not read from the DynamoDB.", ex.code || "DDB_READ_ERROR", {
+        partitionKey,
+        queryOptions
+      });
+    }
+  }
+
+  getPartitionKey(id) {
+    /**
+     * If ID includes # it means it is composed of ID and VERSION.
+     * We need ID only so extract it.
+     */
+    if (id.match("#") !== null) {
+      id = id.split("#").shift();
+    }
+
+    return `${this.partitionKey}#${id}`;
+  }
+
+  get partitionKey() {
+    return `${(0, _utils2.createBasePartitionKey)(this.context)}#CME`;
+  }
+
+  getGSIPartitionKey(type, model) {
+    return `${this.partitionKey}#M#${model.modelId}#${type}`;
+  }
+
+  getGSIEntryPartitionKey(model) {
+    return this.getGSIPartitionKey("A", model);
+  }
+
+  getGSILatestPartitionKey(model) {
+    return this.getGSIPartitionKey("L", model);
+  }
+
+  getGSIPublishedPartitionKey(model) {
+    return this.getGSIPartitionKey("P", model);
+  }
+
+  getGSISortKey(entry) {
+    return entry.id;
+  }
+  /**
+   * Gets a secondary key in form of REV#version from:
+   *   id#0003
+   *   0003
+   *   3
+   */
+
+
+  getSortKeyRevision(version) {
+    if (typeof version === "string" && version.includes("#") === true) {
+      version = version.split("#").pop();
+    }
+
+    return `REV#${(0, _utils.zeroPad)(version)}`;
+  }
+
+  getSortKeyLatest() {
+    return "L";
+  }
+
+  getSortKeyPublished() {
+    return "P";
+  }
+  /**
+   * Method to build the query partition keys, always an array, and create the target index:
+   * - if undefined then it is primary
+   * - if populated then it is that given one (and partition keys are reflecting that)
+   */
+
+
+  createQueryOptions({
+    where: originalWhere,
+    model
+  }) {
+    const options = {
+      filters: [],
+      index: undefined
+    };
+    const where = (0, _lodash.default)(originalWhere);
+    /**
+     * if we have id or entry ID, we will query via the primary key
+     * just add all the possible IDs to find
+     */
+
+    const queryPartitionKeys = [];
+
+    if (where.id) {
+      queryPartitionKeys.push(this.getPartitionKey(where.id));
+    }
+
+    if (where.entryId) {
+      queryPartitionKeys.push(this.getPartitionKey(where.entryId));
+    }
+
+    if (where.id_in) {
+      queryPartitionKeys.push(...where.id_in.map(id => this.getPartitionKey(id)));
+    }
+
+    if (where.entryId_in) {
+      queryPartitionKeys.push(...where.entryId_in.map(id => this.getPartitionKey(id)));
+    }
+    /**
+     * If we do not have any of the IDs, we will query via the GSI1_PK just depending on the entry type
+     * At this point there will probably be a lot of results
+     * but we will apply some basic dynamodb filters so we dont get much data from the db
+     * NOTE: It is still going to get charged tho
+     */
+
+
+    if (queryPartitionKeys.length === 0) {
+      options.index = GSI1_INDEX;
+
+      if (where.published) {
+        queryPartitionKeys.push(this.getGSIPartitionKey("P", model));
+      } else if (where.latest) {
+        queryPartitionKeys.push(this.getGSIPartitionKey("L", model));
+      } else {
+        queryPartitionKeys.push(this.getGSIPartitionKey("A", model));
+      }
+    }
+    /**
+     * If index is the primary one, we can filter records by type (latest, published or regular)
+     * so we do not need to filter in the code
+     */
+
+
+    if (!options.index) {
+      if (where.published) {
+        options.eq = this.getSortKeyPublished();
+      } else if (where.latest) {
+        options.eq = this.getSortKeyLatest();
+      } else {
+        options.beginsWith = "REV#";
+      }
+    }
+    /**
+     * we remove all the used where conditions
+     */
+
+
+    delete where["id"];
+    delete where["id_in"];
+    delete where["entryId"];
+    delete where["entryId_in"];
+    delete where["published"];
+    delete where["latest"];
+    return {
+      options,
+      queryPartitionKeys,
+      where
+    };
+  }
+  /**
+   * A method to query the database at the given partition key with the built query options.
+   * Method runs in the loop until it reads everything it needs to.
+   * We could impose the limit on the records read but there is no point since we MUST read everything to be able
+   * to filter and sort the data.
+   */
+
+
+  async runQuery(args) {
+    let previousResult = undefined;
+    let results;
+    const items = [];
+
+    while (results = await this.query(previousResult, args)) {
+      items.push(...results.Items);
+      previousResult = results;
+    }
+
+    return items;
+  }
+
+  async query(previousResult, args) {
+    const {
+      partitionKey,
+      options
+    } = args;
+    let result;
+    /**
+     * In case there is no previous result we must make a new query.
+     * This is the first query on the given partition key.
+     */
+
+    if (!previousResult) {
+      result = await this._entity.query(partitionKey, options);
+    } else if (typeof previousResult.next === "function") {
+      /**
+       * In case we have a previous result and it has a next method, we run it.
+       * In case result of the next method is false, it means it has nothing else to read
+       * and we return a null to keep the query from repeating.
+       */
+      result = await previousResult.next();
+
+      if (result === false) {
+        return null;
+      }
+    } else {
+      /**
+       * This could probably never happen but keep it here just in case to break the query loop.
+       * Basically, either previousResult does not exist or it exists and has a next method
+       * and at that point a result returned will be null and loop should not start again.
+       */
+      return null;
+    }
+    /**
+     * We expect the result to contain an Items array and if not, something went wrong, very wrong.
+     */
+
+
+    if (!result || !result.Items || !Array.isArray(result.Items)) {
+      throw new _error.default("Error when querying for content entries - no result.", "QUERY_ERROR", {
+        partitionKey,
+        options
+      });
+    }
+
+    return result;
+  }
+
+}
+
+exports.CmsContentEntryDynamo = CmsContentEntryDynamo;
+//# sourceMappingURL=CmsContentEntryDynamo.js.map