@webiny/db-dynamodb 0.0.0-mt-2 → 0.0.0-unstable.5e7233243f

package/plugins/definitions/NumberTransformPlugin.js

@@ -15,9 +15,9 @@ var _error = _interopRequireDefault(require("@webiny/error"));
 
 var _isNumber = _interopRequireDefault(require("is-number"));
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 const transformNumber = params => {
   const {

package/plugins/definitions/NumberTransformPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["transformNumber","params","value","typeOf","isNumber","Number","WebinyError","NumberTransformPlugin","ValueTransformPlugin","constructor","transform"],"sources":["NumberTransformPlugin.ts"],"sourcesContent":["import {\n    ValueTransformPlugin,\n    ValueTransformPluginParams,\n    ValueTransformPluginParamsTransformParams\n} from \"./ValueTransformPlugin\";\nimport WebinyError from \"@webiny/error\";\nimport isNumber from \"is-number\";\n\nconst transformNumber = (params: ValueTransformPluginParamsTransformParams): number => {\n    const { value } = params;\n    const typeOf = typeof value;\n    /**\n     * Due to some internal JS stuff, we must check for a number like this.\n     */\n    if (typeOf === \"number\" || isNumber(value) === true) {\n        return Number(value);\n    }\n    throw new WebinyError(\"Field value must be a number because.\", \"NUMBER_ERROR\", {\n        value\n    });\n};\n\nexport class NumberTransformPlugin extends ValueTransformPlugin {\n    public constructor(params: Omit<ValueTransformPluginParams, \"transform\">) {\n        super({\n            transform: transformNumber,\n            ...params\n        });\n    }\n}\n"],"mappings":";;;;;;;;;;;AAAA;;AAKA;;AACA;;;;;;AAEA,MAAMA,eAAe,GAAIC,MAAD,IAA+D;EACnF,MAAM;IAAEC;EAAF,IAAYD,MAAlB;EACA,MAAME,MAAM,GAAG,OAAOD,KAAtB;EACA;AACJ;AACA;;EACI,IAAIC,MAAM,KAAK,QAAX,IAAuB,IAAAC,iBAAA,EAASF,KAAT,MAAoB,IAA/C,EAAqD;IACjD,OAAOG,MAAM,CAACH,KAAD,CAAb;EACH;;EACD,MAAM,IAAII,cAAJ,CAAgB,uCAAhB,EAAyD,cAAzD,EAAyE;IAC3EJ;EAD2E,CAAzE,CAAN;AAGH,CAZD;;AAcO,MAAMK,qBAAN,SAAoCC,0CAApC,CAAyD;EACrDC,WAAW,CAACR,MAAD,EAAwD;IACtE;MACIS,SAAS,EAAEV;IADf,GAEOC,MAFP;EAIH;;AAN2D"}

package/plugins/definitions/TimeTransformPlugin.d.ts

@@ -1,4 +1,4 @@
-import { ValueTransformPlugin, Params } from "./ValueTransformPlugin";
+import { ValueTransformPlugin, ValueTransformPluginParams } from "./ValueTransformPlugin";
 export declare class TimeTransformPlugin extends ValueTransformPlugin {
-    constructor(params: Omit<Params, "transform">);
+    constructor(params: Omit<ValueTransformPluginParams, "transform">);
 }

package/plugins/definitions/TimeTransformPlugin.js

@@ -15,9 +15,9 @@ var _error = _interopRequireDefault(require("@webiny/error"));
 
 var _isNumber = _interopRequireDefault(require("is-number"));
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 const transformTime = params => {
   const {

package/plugins/definitions/TimeTransformPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["transformTime","params","value","typeOf","isNumber","Number","WebinyError","time","milliseconds","split","values","map","length","hours","minutes","seconds","TimeTransformPlugin","ValueTransformPlugin","constructor","transform"],"sources":["TimeTransformPlugin.ts"],"sourcesContent":["import {\n    ValueTransformPlugin,\n    ValueTransformPluginParams,\n    ValueTransformPluginParamsTransformParams\n} from \"./ValueTransformPlugin\";\nimport WebinyError from \"@webiny/error\";\nimport isNumber from \"is-number\";\n\nconst transformTime = (params: ValueTransformPluginParamsTransformParams): number => {\n    const { value } = params;\n    const typeOf = typeof value;\n    /**\n     * Due to some internal JS stuff, we must check for a number like this.\n     */\n    if (typeOf === \"number\" || isNumber(value) === true) {\n        return Number(value);\n    } else if (typeOf !== \"string\") {\n        throw new WebinyError(\n            \"Field value must be a string because field is defined as time.\",\n            \"TIME_PARSE_ERROR\",\n            {\n                value\n            }\n        );\n    }\n    /**\n     * This is for the time format, eg. 12:36:25 or 12:36:25.881\n     */\n    const [time, milliseconds = 0] = (value as any).split(\".\");\n    const values = time.split(\":\").map(Number);\n    if (values.length < 2) {\n        throw new WebinyError(\"Time must contain at least hours and minutes.\", \"TIME_PARSE_ERROR\", {\n            value\n        });\n    }\n    const [hours, minutes, seconds = 0] = values;\n    return (hours * 60 * 60 + minutes * 60 + seconds) * 1000 + Number(milliseconds);\n};\n\nexport class TimeTransformPlugin extends ValueTransformPlugin {\n    public constructor(params: Omit<ValueTransformPluginParams, \"transform\">) {\n        super({\n            transform: transformTime,\n            ...params\n        });\n    }\n}\n"],"mappings":";;;;;;;;;;;AAAA;;AAKA;;AACA;;;;;;AAEA,MAAMA,aAAa,GAAIC,MAAD,IAA+D;EACjF,MAAM;IAAEC;EAAF,IAAYD,MAAlB;EACA,MAAME,MAAM,GAAG,OAAOD,KAAtB;EACA;AACJ;AACA;;EACI,IAAIC,MAAM,KAAK,QAAX,IAAuB,IAAAC,iBAAA,EAASF,KAAT,MAAoB,IAA/C,EAAqD;IACjD,OAAOG,MAAM,CAACH,KAAD,CAAb;EACH,CAFD,MAEO,IAAIC,MAAM,KAAK,QAAf,EAAyB;IAC5B,MAAM,IAAIG,cAAJ,CACF,gEADE,EAEF,kBAFE,EAGF;MACIJ;IADJ,CAHE,CAAN;EAOH;EACD;AACJ;AACA;;;EACI,MAAM,CAACK,IAAD,EAAOC,YAAY,GAAG,CAAtB,IAA4BN,KAAD,CAAeO,KAAf,CAAqB,GAArB,CAAjC;EACA,MAAMC,MAAM,GAAGH,IAAI,CAACE,KAAL,CAAW,GAAX,EAAgBE,GAAhB,CAAoBN,MAApB,CAAf;;EACA,IAAIK,MAAM,CAACE,MAAP,GAAgB,CAApB,EAAuB;IACnB,MAAM,IAAIN,cAAJ,CAAgB,+CAAhB,EAAiE,kBAAjE,EAAqF;MACvFJ;IADuF,CAArF,CAAN;EAGH;;EACD,MAAM,CAACW,KAAD,EAAQC,OAAR,EAAiBC,OAAO,GAAG,CAA3B,IAAgCL,MAAtC;EACA,OAAO,CAACG,KAAK,GAAG,EAAR,GAAa,EAAb,GAAkBC,OAAO,GAAG,EAA5B,GAAiCC,OAAlC,IAA6C,IAA7C,GAAoDV,MAAM,CAACG,YAAD,CAAjE;AACH,CA7BD;;AA+BO,MAAMQ,mBAAN,SAAkCC,0CAAlC,CAAuD;EACnDC,WAAW,CAACjB,MAAD,EAAwD;IACtE;MACIkB,SAAS,EAAEnB;IADf,GAEOC,MAFP;EAIH;;AANyD"}

package/plugins/definitions/ValueFilterPlugin.d.ts

@@ -1,20 +1,20 @@
 import { Plugin } from "@webiny/plugins";
-export interface MatchesParams {
-    value: any;
-    compareValue: any;
+export interface ValueFilterPluginParamsMatchesParams<V = any, C = any> {
+    value: V;
+    compareValue: C;
 }
-export interface Matches {
-    (params: MatchesParams): boolean;
+export interface ValueFilterPluginParamsMatches {
+    (params: ValueFilterPluginParamsMatchesParams): boolean;
 }
-export interface Params {
+export interface ValueFilterPluginParams {
     operation: string;
-    matches: Matches;
+    matches: ValueFilterPluginParamsMatches;
 }
 export declare class ValueFilterPlugin extends Plugin {
-    static readonly type = "dynamodb.value.filter";
+    static readonly type: string;
     private readonly _params;
     get operation(): string;
-    constructor(params: Params);
-    matches(params: MatchesParams): boolean;
+    constructor(params: ValueFilterPluginParams);
+    matches(params: ValueFilterPluginParamsMatchesParams): boolean;
     getOperation(): string;
 }

package/plugins/definitions/ValueFilterPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","Plugin","operation","getOperation","constructor","params","_params","matches","WebinyError","plugin"],"sources":["ValueFilterPlugin.ts"],"sourcesContent":["import { Plugin } from \"@webiny/plugins\";\nimport WebinyError from \"@webiny/error\";\n\nexport interface ValueFilterPluginParamsMatchesParams<V = any, C = any> {\n    value: V;\n    compareValue: C;\n}\n\nexport interface ValueFilterPluginParamsMatches {\n    (params: ValueFilterPluginParamsMatchesParams): boolean;\n}\n\nexport interface ValueFilterPluginParams {\n    operation: string;\n    matches: ValueFilterPluginParamsMatches;\n}\nexport class ValueFilterPlugin extends Plugin {\n    public static override readonly type: string = \"dynamodb.value.filter\";\n    private readonly _params: ValueFilterPluginParams;\n\n    public get operation(): string {\n        return this.getOperation();\n    }\n\n    public constructor(params: ValueFilterPluginParams) {\n        super();\n        this._params = params;\n    }\n\n    public matches(params: ValueFilterPluginParamsMatchesParams): boolean {\n        if (!this._params || !this._params.matches) {\n            throw new WebinyError(`Missing \"matches\" in the plugin.`, \"MATCHES_ERROR\", {\n                plugin: this,\n                params\n            });\n        }\n        return this._params.matches(params);\n    }\n\n    public getOperation(): string {\n        if (!this._params || !this._params.operation) {\n            throw new WebinyError(`Missing \"operation\" in the plugin.`, \"OPERATION_ERROR\");\n        }\n        return this._params.operation;\n    }\n}\n"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AAeO,MAAMA,iBAAN,SAAgCC,eAAhC,CAAuC;EAItB,IAATC,SAAS,GAAW;IAC3B,OAAO,KAAKC,YAAL,EAAP;EACH;;EAEMC,WAAW,CAACC,MAAD,EAAkC;IAChD;IADgD;IAEhD,KAAKC,OAAL,GAAeD,MAAf;EACH;;EAEME,OAAO,CAACF,MAAD,EAAwD;IAClE,IAAI,CAAC,KAAKC,OAAN,IAAiB,CAAC,KAAKA,OAAL,CAAaC,OAAnC,EAA4C;MACxC,MAAM,IAAIC,cAAJ,CAAiB,kCAAjB,EAAoD,eAApD,EAAqE;QACvEC,MAAM,EAAE,IAD+D;QAEvEJ;MAFuE,CAArE,CAAN;IAIH;;IACD,OAAO,KAAKC,OAAL,CAAaC,OAAb,CAAqBF,MAArB,CAAP;EACH;;EAEMF,YAAY,GAAW;IAC1B,IAAI,CAAC,KAAKG,OAAN,IAAiB,CAAC,KAAKA,OAAL,CAAaJ,SAAnC,EAA8C;MAC1C,MAAM,IAAIM,cAAJ,CAAiB,oCAAjB,EAAsD,iBAAtD,CAAN;IACH;;IACD,OAAO,KAAKF,OAAL,CAAaJ,SAApB;EACH;;AA5ByC;;;8BAAjCF,iB,UACsC,uB"}

package/plugins/definitions/ValueTransformPlugin.d.ts

@@ -1,22 +1,22 @@
 import { Plugin } from "@webiny/plugins";
-export interface TransformParams {
+export interface ValueTransformPluginParamsTransformParams {
     value: any;
 }
-export interface Transform {
-    (params: TransformParams): any;
+export interface ValueTransformPluginParamsTransform {
+    (params: ValueTransformPluginParamsTransformParams): any;
 }
 export interface CanTransform {
     (field: string): boolean;
 }
-export interface Params {
+export interface ValueTransformPluginParams {
     fields: string[];
-    transform: Transform;
+    transform: ValueTransformPluginParamsTransform;
     canTransform?: CanTransform;
 }
 export declare class ValueTransformPlugin extends Plugin {
-    static readonly type = "dynamodb.value.transform";
+    static readonly type: string;
     private readonly _params;
-    constructor(params: Params);
+    constructor(params: ValueTransformPluginParams);
     canTransform(field: string): boolean;
-    transform(params: TransformParams): any;
+    transform(params: ValueTransformPluginParamsTransformParams): any;
 }

package/plugins/definitions/ValueTransformPlugin.js

@@ -15,9 +15,9 @@ var _error = _interopRequireDefault(require("@webiny/error"));
 
 var _assignFields = require("./assignFields");
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 class ValueTransformPlugin extends _plugins.Plugin {
   constructor(params) {

package/plugins/definitions/ValueTransformPlugin.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueTransformPlugin","Plugin","constructor","params","_params","fields","assignFields","canTransform","field","includes","transform","WebinyError"],"sources":["ValueTransformPlugin.ts"],"sourcesContent":["import { Plugin } from \"@webiny/plugins\";\nimport WebinyError from \"@webiny/error\";\nimport { assignFields } from \"./assignFields\";\n\nexport interface ValueTransformPluginParamsTransformParams {\n    value: any;\n}\nexport interface ValueTransformPluginParamsTransform {\n    (params: ValueTransformPluginParamsTransformParams): any;\n}\nexport interface CanTransform {\n    (field: string): boolean;\n}\nexport interface ValueTransformPluginParams {\n    fields: string[];\n    transform: ValueTransformPluginParamsTransform;\n    canTransform?: CanTransform;\n}\n\nexport class ValueTransformPlugin extends Plugin {\n    public static override readonly type: string = \"dynamodb.value.transform\";\n\n    private readonly _params: ValueTransformPluginParams;\n\n    public constructor(params: ValueTransformPluginParams) {\n        super();\n        this._params = {\n            ...params,\n            fields: assignFields(params.fields)\n        };\n    }\n\n    public canTransform(field: string): boolean {\n        if (!this._params.canTransform) {\n            return this._params.fields.includes(field);\n        }\n        return this._params.canTransform(field);\n    }\n\n    public transform(params: ValueTransformPluginParamsTransformParams): any {\n        if (!this._params.transform) {\n            throw new WebinyError(`Missing \"transform\" in the plugin.`, \"TRANSFORM_ERROR\", {\n                fields: this._params.fields\n            });\n        }\n        return this._params.transform(params);\n    }\n}\n"],"mappings":";;;;;;;;;;;AAAA;;AACA;;AACA;;;;;;AAiBO,MAAMA,oBAAN,SAAmCC,eAAnC,CAA0C;EAKtCC,WAAW,CAACC,MAAD,EAAqC;IACnD;IADmD;IAEnD,KAAKC,OAAL,mCACOD,MADP;MAEIE,MAAM,EAAE,IAAAC,0BAAA,EAAaH,MAAM,CAACE,MAApB;IAFZ;EAIH;;EAEME,YAAY,CAACC,KAAD,EAAyB;IACxC,IAAI,CAAC,KAAKJ,OAAL,CAAaG,YAAlB,EAAgC;MAC5B,OAAO,KAAKH,OAAL,CAAaC,MAAb,CAAoBI,QAApB,CAA6BD,KAA7B,CAAP;IACH;;IACD,OAAO,KAAKJ,OAAL,CAAaG,YAAb,CAA0BC,KAA1B,CAAP;EACH;;EAEME,SAAS,CAACP,MAAD,EAAyD;IACrE,IAAI,CAAC,KAAKC,OAAL,CAAaM,SAAlB,EAA6B;MACzB,MAAM,IAAIC,cAAJ,CAAiB,oCAAjB,EAAsD,iBAAtD,EAAyE;QAC3EN,MAAM,EAAE,KAAKD,OAAL,CAAaC;MADsD,CAAzE,CAAN;IAGH;;IACD,OAAO,KAAKD,OAAL,CAAaM,SAAb,CAAuBP,MAAvB,CAAP;EACH;;AA3B4C;;;8BAApCH,oB,UACsC,0B"}

package/plugins/definitions/assignFields.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["assignFields","rawInput","input","Array","isArray","length","WebinyError","fields","field","push"],"sources":["assignFields.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\n\nexport const assignFields = (rawInput: string | string[]): string[] => {\n    const input = Array.isArray(rawInput) ? rawInput : [rawInput];\n    if (input.length === 0) {\n        throw new WebinyError(\n            \"Could not assign fields because there are none.\",\n            \"ASSIGN_FIELDS_ERROR\"\n        );\n    }\n    const fields: string[] = [];\n    for (const field of input) {\n        /**\n         * Need to make sure that no field is empty.\n         */\n        if (!field) {\n            throw new WebinyError(\n                \"Passed empty field value into the plugin.\",\n                \"EMPTY_FIELD_VALUE\",\n                {\n                    fields: input\n                }\n            );\n        }\n        fields.push(field);\n    }\n    return fields;\n};\n"],"mappings":";;;;;;;;;AAAA;;AAEO,MAAMA,YAAY,GAAIC,QAAD,IAA2C;EACnE,MAAMC,KAAK,GAAGC,KAAK,CAACC,OAAN,CAAcH,QAAd,IAA0BA,QAA1B,GAAqC,CAACA,QAAD,CAAnD;;EACA,IAAIC,KAAK,CAACG,MAAN,KAAiB,CAArB,EAAwB;IACpB,MAAM,IAAIC,cAAJ,CACF,iDADE,EAEF,qBAFE,CAAN;EAIH;;EACD,MAAMC,MAAgB,GAAG,EAAzB;;EACA,KAAK,MAAMC,KAAX,IAAoBN,KAApB,EAA2B;IACvB;AACR;AACA;IACQ,IAAI,CAACM,KAAL,EAAY;MACR,MAAM,IAAIF,cAAJ,CACF,2CADE,EAEF,mBAFE,EAGF;QACIC,MAAM,EAAEL;MADZ,CAHE,CAAN;IAOH;;IACDK,MAAM,CAACE,IAAP,CAAYD,KAAZ;EACH;;EACD,OAAOD,MAAP;AACH,CAzBM"}

package/plugins/filters/andIn.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue","Array","isArray","WebinyError","every","c","includes"],"sources":["andIn.ts"],"sourcesContent":["import { ValueFilterPlugin } from \"../definitions/ValueFilterPlugin\";\nimport WebinyError from \"@webiny/error\";\n\ninterface MatchesParams {\n    value: any[];\n    compareValue?: any[];\n}\n\nexport default new ValueFilterPlugin({\n    operation: \"and_in\",\n    matches: ({ value, compareValue }: MatchesParams) => {\n        if (!compareValue || Array.isArray(compareValue) === false) {\n            throw new WebinyError(\n                `The value given as \"compareValue\" must be an array!`,\n                \"COMPARE_VALUE_ERROR\",\n                {\n                    value,\n                    compareValue\n                }\n            );\n        }\n        if (Array.isArray(value) === true) {\n            return compareValue.every(c => value.includes(c));\n        }\n        return compareValue.includes(value);\n    }\n});\n"],"mappings":";;;;;;;;;AAAA;;AACA;;eAOe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,QADsB;EAEjCC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASC;EAAT,CAAD,KAA4C;IACjD,IAAI,CAACA,YAAD,IAAiBC,KAAK,CAACC,OAAN,CAAcF,YAAd,MAAgC,KAArD,EAA4D;MACxD,MAAM,IAAIG,cAAJ,CACD,qDADC,EAEF,qBAFE,EAGF;QACIJ,KADJ;QAEIC;MAFJ,CAHE,CAAN;IAQH;;IACD,IAAIC,KAAK,CAACC,OAAN,CAAcH,KAAd,MAAyB,IAA7B,EAAmC;MAC/B,OAAOC,YAAY,CAACI,KAAb,CAAmBC,CAAC,IAAIN,KAAK,CAACO,QAAN,CAAeD,CAAf,CAAxB,CAAP;IACH;;IACD,OAAOL,YAAY,CAACM,QAAb,CAAsBP,KAAtB,CAAP;EACH;AAjBgC,CAAtB,C"}

package/plugins/filters/between.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue","Array","isArray","length","WebinyError","from","to"],"sources":["between.ts"],"sourcesContent":["import WebinyError from \"@webiny/error\";\nimport { ValueFilterPlugin } from \"../definitions/ValueFilterPlugin\";\n\nexport default new ValueFilterPlugin({\n    operation: \"between\",\n    matches: ({ value, compareValue }) => {\n        if (Array.isArray(compareValue)) {\n            if (compareValue.length !== 2) {\n                throw new WebinyError(\n                    \"When comparing between and you give an array, there must be two items in it.\",\n                    \"FILTER_ERROR\",\n                    {\n                        value,\n                        compareValue\n                    }\n                );\n            }\n            const [from, to] = compareValue;\n            return value >= from && value <= to;\n        }\n        return value >= compareValue && value <= compareValue;\n    }\n});\n"],"mappings":";;;;;;;;;AAAA;;AACA;;eAEe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,SADsB;EAEjCC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASC;EAAT,CAAD,KAA6B;IAClC,IAAIC,KAAK,CAACC,OAAN,CAAcF,YAAd,CAAJ,EAAiC;MAC7B,IAAIA,YAAY,CAACG,MAAb,KAAwB,CAA5B,EAA+B;QAC3B,MAAM,IAAIC,cAAJ,CACF,8EADE,EAEF,cAFE,EAGF;UACIL,KADJ;UAEIC;QAFJ,CAHE,CAAN;MAQH;;MACD,MAAM,CAACK,IAAD,EAAOC,EAAP,IAAaN,YAAnB;MACA,OAAOD,KAAK,IAAIM,IAAT,IAAiBN,KAAK,IAAIO,EAAjC;IACH;;IACD,OAAOP,KAAK,IAAIC,YAAT,IAAyBD,KAAK,IAAIC,YAAzC;EACH;AAlBgC,CAAtB,C"}

package/plugins/filters/contains.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue","Array","isArray","re","RegExp","some","v","match"],"sources":["contains.ts"],"sourcesContent":["import { ValueFilterPlugin } from \"../definitions/ValueFilterPlugin\";\n\nexport default new ValueFilterPlugin({\n    operation: \"contains\",\n    matches: ({ value, compareValue }) => {\n        if (typeof value !== \"string\") {\n            if (Array.isArray(value) === true) {\n                const re = new RegExp(compareValue, \"i\");\n                return value.some((v: string) => {\n                    return v.match(re) !== null;\n                });\n            }\n            return false;\n        }\n        const re = new RegExp(compareValue, \"i\");\n        return value.match(re) !== null;\n    }\n});\n"],"mappings":";;;;;;;AAAA;;eAEe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,UADsB;EAEjCC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASC;EAAT,CAAD,KAA6B;IAClC,IAAI,OAAOD,KAAP,KAAiB,QAArB,EAA+B;MAC3B,IAAIE,KAAK,CAACC,OAAN,CAAcH,KAAd,MAAyB,IAA7B,EAAmC;QAC/B,MAAMI,EAAE,GAAG,IAAIC,MAAJ,CAAWJ,YAAX,EAAyB,GAAzB,CAAX;QACA,OAAOD,KAAK,CAACM,IAAN,CAAYC,CAAD,IAAe;UAC7B,OAAOA,CAAC,CAACC,KAAF,CAAQJ,EAAR,MAAgB,IAAvB;QACH,CAFM,CAAP;MAGH;;MACD,OAAO,KAAP;IACH;;IACD,MAAMA,EAAE,GAAG,IAAIC,MAAJ,CAAWJ,YAAX,EAAyB,GAAzB,CAAX;IACA,OAAOD,KAAK,CAACQ,KAAN,CAAYJ,EAAZ,MAAoB,IAA3B;EACH;AAdgC,CAAtB,C"}

package/plugins/filters/eq.js

@@ -13,6 +13,19 @@ var _default = new _ValueFilterPlugin.ValueFilterPlugin({
     value,
     compareValue
   }) => {
+    /**
+     * Possibility that either input value or one from the system is array.
+     */
+    if (Array.isArray(value) === true) {
+      return value.some(v => {
+        return Array.isArray(compareValue) ? compareValue.includes(v) : compareValue === v;
+      });
+    } else if (Array.isArray(compareValue) === true) {
+      return compareValue.every(v => {
+        return value === v;
+      });
+    }
+
     return value === compareValue;
   }
 });

package/plugins/filters/eq.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue","Array","isArray","some","v","includes","every"],"sources":["eq.ts"],"sourcesContent":["import { ValueFilterPlugin } from \"../definitions/ValueFilterPlugin\";\n\nexport default new ValueFilterPlugin({\n    operation: \"eq\",\n    matches: ({ value, compareValue }) => {\n        /**\n         * Possibility that either input value or one from the system is array.\n         */\n        if (Array.isArray(value) === true) {\n            return value.some((v: string) => {\n                return Array.isArray(compareValue) ? compareValue.includes(v) : compareValue === v;\n            });\n        } else if (Array.isArray(compareValue) === true) {\n            return compareValue.every((v: string) => {\n                return value === v;\n            });\n        }\n        return value === compareValue;\n    }\n});\n"],"mappings":";;;;;;;AAAA;;eAEe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,IADsB;EAEjCC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASC;EAAT,CAAD,KAA6B;IAClC;AACR;AACA;IACQ,IAAIC,KAAK,CAACC,OAAN,CAAcH,KAAd,MAAyB,IAA7B,EAAmC;MAC/B,OAAOA,KAAK,CAACI,IAAN,CAAYC,CAAD,IAAe;QAC7B,OAAOH,KAAK,CAACC,OAAN,CAAcF,YAAd,IAA8BA,YAAY,CAACK,QAAb,CAAsBD,CAAtB,CAA9B,GAAyDJ,YAAY,KAAKI,CAAjF;MACH,CAFM,CAAP;IAGH,CAJD,MAIO,IAAIH,KAAK,CAACC,OAAN,CAAcF,YAAd,MAAgC,IAApC,EAA0C;MAC7C,OAAOA,YAAY,CAACM,KAAb,CAAoBF,CAAD,IAAe;QACrC,OAAOL,KAAK,KAAKK,CAAjB;MACH,CAFM,CAAP;IAGH;;IACD,OAAOL,KAAK,KAAKC,YAAjB;EACH;AAhBgC,CAAtB,C"}

package/plugins/filters/fuzzy.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue","f","Fuse","result","search","length"],"sources":["fuzzy.ts"],"sourcesContent":["import Fuse from \"fuse.js\";\nimport {\n    ValueFilterPluginParamsMatchesParams,\n    ValueFilterPlugin\n} from \"../definitions/ValueFilterPlugin\";\n\nexport default new ValueFilterPlugin({\n    operation: \"fuzzy\",\n    matches: ({\n        value,\n        compareValue\n    }: ValueFilterPluginParamsMatchesParams<string | null, string>) => {\n        if (typeof value !== \"string\") {\n            return false;\n        }\n        const f = new Fuse([value], {});\n        const result = f.search(compareValue);\n\n        return result.length > 0;\n    }\n});\n"],"mappings":";;;;;;;;;AAAA;;AACA;;eAKe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,OADsB;EAEjCC,OAAO,EAAE,CAAC;IACNC,KADM;IAENC;EAFM,CAAD,KAG0D;IAC/D,IAAI,OAAOD,KAAP,KAAiB,QAArB,EAA+B;MAC3B,OAAO,KAAP;IACH;;IACD,MAAME,CAAC,GAAG,IAAIC,aAAJ,CAAS,CAACH,KAAD,CAAT,EAAkB,EAAlB,CAAV;IACA,MAAMI,MAAM,GAAGF,CAAC,CAACG,MAAF,CAASJ,YAAT,CAAf;IAEA,OAAOG,MAAM,CAACE,MAAP,GAAgB,CAAvB;EACH;AAbgC,CAAtB,C"}

package/plugins/filters/gt.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue"],"sources":["gt.ts"],"sourcesContent":["import { ValueFilterPlugin } from \"../definitions/ValueFilterPlugin\";\n\nexport default new ValueFilterPlugin({\n    operation: \"gt\",\n    matches: ({ value, compareValue }) => {\n        return value > compareValue;\n    }\n});\n"],"mappings":";;;;;;;AAAA;;eAEe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,IADsB;EAEjCC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASC;EAAT,CAAD,KAA6B;IAClC,OAAOD,KAAK,GAAGC,YAAf;EACH;AAJgC,CAAtB,C"}

package/plugins/filters/gte.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue"],"sources":["gte.ts"],"sourcesContent":["import { ValueFilterPlugin } from \"../definitions/ValueFilterPlugin\";\n\nexport default new ValueFilterPlugin({\n    operation: \"gte\",\n    matches: ({ value, compareValue }) => {\n        return value >= compareValue;\n    }\n});\n"],"mappings":";;;;;;;AAAA;;eAEe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,KADsB;EAEjCC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASC;EAAT,CAAD,KAA6B;IAClC,OAAOD,KAAK,IAAIC,YAAhB;EACH;AAJgC,CAAtB,C"}

package/plugins/filters/in.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue","Array","isArray","WebinyError","some","c","includes"],"sources":["in.ts"],"sourcesContent":["import { ValueFilterPlugin } from \"../definitions/ValueFilterPlugin\";\nimport WebinyError from \"@webiny/error\";\n\ninterface MatchesParams {\n    value: any[];\n    compareValue?: any[];\n}\n\nexport default new ValueFilterPlugin({\n    operation: \"in\",\n    matches: ({ value, compareValue }: MatchesParams) => {\n        if (!compareValue || Array.isArray(compareValue) === false) {\n            throw new WebinyError(\n                `The value given as \"compareValue\" must be an array!`,\n                \"COMPARE_VALUE_ERROR\",\n                {\n                    value,\n                    compareValue\n                }\n            );\n        }\n        if (Array.isArray(value) === true) {\n            return compareValue.some(c => value.includes(c));\n        }\n        return compareValue.includes(value);\n    }\n});\n"],"mappings":";;;;;;;;;AAAA;;AACA;;eAOe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,IADsB;EAEjCC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASC;EAAT,CAAD,KAA4C;IACjD,IAAI,CAACA,YAAD,IAAiBC,KAAK,CAACC,OAAN,CAAcF,YAAd,MAAgC,KAArD,EAA4D;MACxD,MAAM,IAAIG,cAAJ,CACD,qDADC,EAEF,qBAFE,EAGF;QACIJ,KADJ;QAEIC;MAFJ,CAHE,CAAN;IAQH;;IACD,IAAIC,KAAK,CAACC,OAAN,CAAcH,KAAd,MAAyB,IAA7B,EAAmC;MAC/B,OAAOC,YAAY,CAACI,IAAb,CAAkBC,CAAC,IAAIN,KAAK,CAACO,QAAN,CAAeD,CAAf,CAAvB,CAAP;IACH;;IACD,OAAOL,YAAY,CAACM,QAAb,CAAsBP,KAAtB,CAAP;EACH;AAjBgC,CAAtB,C"}

package/plugins/filters/index.js

@@ -27,6 +27,8 @@ var _contains = _interopRequireDefault(require("./contains"));
 
 var _fuzzy = _interopRequireDefault(require("./fuzzy"));
 
-var _default = () => [_eq.default, _andIn.default, _in.default, _gt.default, _lt.default, _gte.default, _lte.default, _between.default, _contains.default, _fuzzy.default];
+var _startsWith = _interopRequireDefault(require("./startsWith"));
+
+var _default = () => [_eq.default, _andIn.default, _in.default, _gt.default, _lt.default, _gte.default, _lte.default, _between.default, _contains.default, _fuzzy.default, _startsWith.default];
 
 exports.default = _default;

package/plugins/filters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["eqFilter","andInFilter","inFilter","gtFilter","ltFilter","gteFilter","lteFilter","betweenFilter","containsFilter","fuzzyFilter","startsWithFilter"],"sources":["index.ts"],"sourcesContent":["import eqFilter from \"./eq\";\nimport betweenFilter from \"./between\";\nimport andInFilter from \"./andIn\";\nimport inFilter from \"./in\";\nimport gtFilter from \"./gt\";\nimport gteFilter from \"./gte\";\nimport ltFilter from \"./lt\";\nimport lteFilter from \"./lte\";\nimport containsFilter from \"./contains\";\nimport fuzzyFilter from \"./fuzzy\";\nimport startsWithFilter from \"./startsWith\";\n\nexport default () => [\n    eqFilter,\n    andInFilter,\n    inFilter,\n    gtFilter,\n    ltFilter,\n    gteFilter,\n    lteFilter,\n    betweenFilter,\n    containsFilter,\n    fuzzyFilter,\n    startsWithFilter\n];\n"],"mappings":";;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;eAEe,MAAM,CACjBA,WADiB,EAEjBC,cAFiB,EAGjBC,WAHiB,EAIjBC,WAJiB,EAKjBC,WALiB,EAMjBC,YANiB,EAOjBC,YAPiB,EAQjBC,gBARiB,EASjBC,iBATiB,EAUjBC,cAViB,EAWjBC,mBAXiB,C"}

package/plugins/filters/lt.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue"],"sources":["lt.ts"],"sourcesContent":["import { ValueFilterPlugin } from \"../definitions/ValueFilterPlugin\";\n\nexport default new ValueFilterPlugin({\n    operation: \"lt\",\n    matches: ({ value, compareValue }) => {\n        return value < compareValue;\n    }\n});\n"],"mappings":";;;;;;;AAAA;;eAEe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,IADsB;EAEjCC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASC;EAAT,CAAD,KAA6B;IAClC,OAAOD,KAAK,GAAGC,YAAf;EACH;AAJgC,CAAtB,C"}

package/plugins/filters/lte.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue"],"sources":["lte.ts"],"sourcesContent":["import { ValueFilterPlugin } from \"../definitions/ValueFilterPlugin\";\n\nexport default new ValueFilterPlugin({\n    operation: \"lte\",\n    matches: ({ value, compareValue }) => {\n        return value <= compareValue;\n    }\n});\n"],"mappings":";;;;;;;AAAA;;eAEe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,KADsB;EAEjCC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASC;EAAT,CAAD,KAA6B;IAClC,OAAOD,KAAK,IAAIC,YAAhB;EACH;AAJgC,CAAtB,C"}

package/plugins/filters/startsWith.d.ts

@@ -0,0 +1,3 @@
+import { ValueFilterPlugin } from "../definitions/ValueFilterPlugin";
+declare const _default: ValueFilterPlugin;
+export default _default;

package/plugins/filters/startsWith.js

@@ -0,0 +1,33 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ValueFilterPlugin = require("../definitions/ValueFilterPlugin");
+
+var _default = new _ValueFilterPlugin.ValueFilterPlugin({
+  operation: "startsWith",
+  matches: ({
+    value,
+    compareValue
+  }) => {
+    /**
+     * We do "case-insensitive" comparison.
+     */
+    const compareValueInLowerCase = compareValue.toLowerCase();
+
+    if (typeof value !== "string") {
+      if (Array.isArray(value) === true) {
+        return value.some(v => v.toLowerCase().startsWith(compareValueInLowerCase));
+      }
+
+      return false;
+    }
+
+    return value.toLowerCase().startsWith(compareValueInLowerCase);
+  }
+});
+
+exports.default = _default;

package/plugins/filters/startsWith.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["ValueFilterPlugin","operation","matches","value","compareValue","compareValueInLowerCase","toLowerCase","Array","isArray","some","v","startsWith"],"sources":["startsWith.ts"],"sourcesContent":["import { ValueFilterPlugin } from \"../definitions/ValueFilterPlugin\";\n\nexport default new ValueFilterPlugin({\n    operation: \"startsWith\",\n    matches: ({ value, compareValue }) => {\n        /**\n         * We do \"case-insensitive\" comparison.\n         */\n        const compareValueInLowerCase = compareValue.toLowerCase();\n\n        if (typeof value !== \"string\") {\n            if (Array.isArray(value) === true) {\n                return value.some((v: string) =>\n                    v.toLowerCase().startsWith(compareValueInLowerCase)\n                );\n            }\n            return false;\n        }\n\n        return value.toLowerCase().startsWith(compareValueInLowerCase);\n    }\n});\n"],"mappings":";;;;;;;AAAA;;eAEe,IAAIA,oCAAJ,CAAsB;EACjCC,SAAS,EAAE,YADsB;EAEjCC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASC;EAAT,CAAD,KAA6B;IAClC;AACR;AACA;IACQ,MAAMC,uBAAuB,GAAGD,YAAY,CAACE,WAAb,EAAhC;;IAEA,IAAI,OAAOH,KAAP,KAAiB,QAArB,EAA+B;MAC3B,IAAII,KAAK,CAACC,OAAN,CAAcL,KAAd,MAAyB,IAA7B,EAAmC;QAC/B,OAAOA,KAAK,CAACM,IAAN,CAAYC,CAAD,IACdA,CAAC,CAACJ,WAAF,GAAgBK,UAAhB,CAA2BN,uBAA3B,CADG,CAAP;MAGH;;MACD,OAAO,KAAP;IACH;;IAED,OAAOF,KAAK,CAACG,WAAN,GAAoBK,UAApB,CAA+BN,uBAA/B,CAAP;EACH;AAlBgC,CAAtB,C"}

package/plugins/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["filterPlugins"],"sources":["index.ts"],"sourcesContent":["/**\n * List everything that needs to be loaded by default.\n */\nimport filterPlugins from \"./filters\";\n\nexport default () => {\n    return [filterPlugins()];\n};\n"],"mappings":";;;;;;;;;AAGA;;AAHA;AACA;AACA;eAGe,MAAM;EACjB,OAAO,CAAC,IAAAA,gBAAA,GAAD,CAAP;AACH,C"}

package/statements/createKeyConditionExpressionArgs.d.ts

@@ -1,12 +1,15 @@
-declare const _default: ({ query, sort, key }: {
-    query: any;
-    sort: any;
-    key: any;
-}) => {
+import { Query, QueryKey, QuerySort } from "../types";
+interface Output {
     KeyConditionExpression: string;
-    ExpressionAttributeNames: {};
-    ExpressionAttributeValues: {};
+    ExpressionAttributeNames: Record<string, any>;
+    ExpressionAttributeValues: Record<string, any>;
     ScanIndexForward: boolean;
-    IndexName: any;
-};
+    IndexName: string;
+}
+interface Params {
+    query: Query;
+    sort: QuerySort;
+    key: QueryKey;
+}
+declare const _default: ({ query, sort, key }: Params) => Output;
 export default _default;

package/statements/createKeyConditionExpressionArgs.js

@@ -9,6 +9,10 @@ exports.default = void 0;
 
 var _processStatement = _interopRequireDefault(require("./processStatement"));
 
+/**
+ * Remove this when no apps are using our internal db drivers anymore
+ */
+// @ts-nocheck
 var _default = ({
   query,
   sort,

package/statements/createKeyConditionExpressionArgs.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["query","sort","key","args","expression","attributeNames","attributeValues","processStatement","$and","output","KeyConditionExpression","ExpressionAttributeNames","ExpressionAttributeValues","ScanIndexForward","IndexName","sortKey","fields","name","primary"],"sources":["createKeyConditionExpressionArgs.ts"],"sourcesContent":["/**\n * Remove this when no apps are using our internal db drivers anymore\n */\n// @ts-nocheck\nimport processStatement from \"./processStatement\";\nimport { ProcessStatementArgsParam, Query, QueryKey, QuerySort } from \"~/types\";\n\ninterface Output {\n    KeyConditionExpression: string;\n    ExpressionAttributeNames: Record<string, any>;\n    ExpressionAttributeValues: Record<string, any>;\n    ScanIndexForward: boolean;\n    IndexName: string;\n}\ninterface Params {\n    query: Query;\n    sort: QuerySort;\n    key: QueryKey;\n}\nexport default ({ query, sort, key }: Params): Output => {\n    const args: ProcessStatementArgsParam = {\n        expression: \"\",\n        attributeNames: {},\n        attributeValues: {}\n    };\n\n    processStatement({ args, query: { $and: query } });\n\n    const output: Output = {\n        KeyConditionExpression: args.expression,\n        ExpressionAttributeNames: args.attributeNames,\n        ExpressionAttributeValues: args.attributeValues,\n        ScanIndexForward: true,\n        IndexName: null\n    };\n\n    const sortKey = key.fields && key.fields[1];\n    if (sort && sort[sortKey.name] === -1) {\n        output.ScanIndexForward = false;\n    }\n\n    if (!key.primary) {\n        output.IndexName = key.name;\n    }\n\n    return output;\n};\n"],"mappings":";;;;;;;;;AAIA;;AAJA;AACA;AACA;AACA;eAgBe,CAAC;EAAEA,KAAF;EAASC,IAAT;EAAeC;AAAf,CAAD,KAA0C;EACrD,MAAMC,IAA+B,GAAG;IACpCC,UAAU,EAAE,EADwB;IAEpCC,cAAc,EAAE,EAFoB;IAGpCC,eAAe,EAAE;EAHmB,CAAxC;EAMA,IAAAC,yBAAA,EAAiB;IAAEJ,IAAF;IAAQH,KAAK,EAAE;MAAEQ,IAAI,EAAER;IAAR;EAAf,CAAjB;EAEA,MAAMS,MAAc,GAAG;IACnBC,sBAAsB,EAAEP,IAAI,CAACC,UADV;IAEnBO,wBAAwB,EAAER,IAAI,CAACE,cAFZ;IAGnBO,yBAAyB,EAAET,IAAI,CAACG,eAHb;IAInBO,gBAAgB,EAAE,IAJC;IAKnBC,SAAS,EAAE;EALQ,CAAvB;EAQA,MAAMC,OAAO,GAAGb,GAAG,CAACc,MAAJ,IAAcd,GAAG,CAACc,MAAJ,CAAW,CAAX,CAA9B;;EACA,IAAIf,IAAI,IAAIA,IAAI,CAACc,OAAO,CAACE,IAAT,CAAJ,KAAuB,CAAC,CAApC,EAAuC;IACnCR,MAAM,CAACI,gBAAP,GAA0B,KAA1B;EACH;;EAED,IAAI,CAACX,GAAG,CAACgB,OAAT,EAAkB;IACdT,MAAM,CAACK,SAAP,GAAmBZ,GAAG,CAACe,IAAvB;EACH;;EAED,OAAOR,MAAP;AACH,C"}

package/statements/processStatement.d.ts

@@ -1,4 +1,3 @@
-export default function processStatement({ args, query }: {
-    args: any;
-    query: any;
-}): void;
+import { ProcessStatementCallable } from "../types";
+declare const processStatement: ProcessStatementCallable;
+export default processStatement;

package/statements/processStatement.js

@@ -5,14 +5,14 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.default = processStatement;
+exports.default = void 0;
 
 var _operators = _interopRequireDefault(require("./../operators"));
 
-function processStatement({
+const processStatement = ({
   args,
   query
-}) {
+}) => {
   outerLoop: for (const [key, value] of Object.entries(query)) {
     const operators = Object.values(_operators.default);
 
@@ -36,4 +36,7 @@ function processStatement({
 
     throw new Error(`Invalid operator {${key} : ${value}}.`);
   }
-}
+};
+
+var _default = processStatement;
+exports.default = _default;

package/statements/processStatement.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["processStatement","args","query","outerLoop","key","value","Object","entries","operators","values","allOperators","i","length","operator","canProcess","process","Error"],"sources":["processStatement.ts"],"sourcesContent":["import allOperators from \"./../operators\";\nimport { ProcessStatementCallable } from \"~/types\";\n\nconst processStatement: ProcessStatementCallable = ({ args, query }) => {\n    outerLoop: for (const [key, value] of Object.entries(query)) {\n        const operators = Object.values(allOperators);\n        for (let i = 0; i < operators.length; i++) {\n            const operator = operators[i];\n            if (operator.canProcess({ key, value, args })) {\n                operator.process({ key, value, args, processStatement });\n                continue outerLoop;\n            }\n        }\n        throw new Error(`Invalid operator {${key} : ${value}}.`);\n    }\n};\nexport default processStatement;\n"],"mappings":";;;;;;;;;AAAA;;AAGA,MAAMA,gBAA0C,GAAG,CAAC;EAAEC,IAAF;EAAQC;AAAR,CAAD,KAAqB;EACpEC,SAAS,EAAE,KAAK,MAAM,CAACC,GAAD,EAAMC,KAAN,CAAX,IAA2BC,MAAM,CAACC,OAAP,CAAeL,KAAf,CAA3B,EAAkD;IACzD,MAAMM,SAAS,GAAGF,MAAM,CAACG,MAAP,CAAcC,kBAAd,CAAlB;;IACA,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,SAAS,CAACI,MAA9B,EAAsCD,CAAC,EAAvC,EAA2C;MACvC,MAAME,QAAQ,GAAGL,SAAS,CAACG,CAAD,CAA1B;;MACA,IAAIE,QAAQ,CAACC,UAAT,CAAoB;QAAEV,GAAF;QAAOC,KAAP;QAAcJ;MAAd,CAApB,CAAJ,EAA+C;QAC3CY,QAAQ,CAACE,OAAT,CAAiB;UAAEX,GAAF;UAAOC,KAAP;UAAcJ,IAAd;UAAoBD;QAApB,CAAjB;QACA,SAASG,SAAT;MACH;IACJ;;IACD,MAAM,IAAIa,KAAJ,CAAW,qBAAoBZ,GAAI,MAAKC,KAAM,IAA9C,CAAN;EACH;AACJ,CAZD;;eAaeL,gB"}

package/types.d.ts

@@ -1,23 +1,23 @@
-export declare type OperatorArgs = {
+export interface OperatorArgs {
     expression: string;
     attributeNames: Record<string, any>;
     attributeValues: Record<string, any>;
-};
-declare type CanProcessArgs = {
+}
+interface CanProcessArgs {
     key: string;
     value: any;
     args: OperatorArgs;
-};
-declare type ProcessArgs = {
+}
+interface ProcessArgs {
     key: string;
     value: any;
     args: OperatorArgs;
     processStatement: any;
-};
-export declare type Operator = {
+}
+export interface Operator {
     canProcess: ({ key }: CanProcessArgs) => boolean;
     process: ({ key, value, args }: ProcessArgs) => void;
-};
+}
 /**
  * We use this definition to search for a value in any given field that was passed.
  * It works as an "OR" condition.
@@ -26,4 +26,33 @@ export interface DynamoDbContainsFilter {
     fields: string[];
     value: string;
 }
+export interface ProcessStatementArgsParam {
+    expression: string;
+    attributeNames: Record<string, any>;
+    attributeValues: Record<string, any>;
+}
+export interface ProcessStatementQueryParam {
+    [key: string]: any;
+}
+export interface ProcessStatementParams {
+    args: ProcessStatementArgsParam;
+    query: ProcessStatementQueryParam;
+}
+export interface ProcessStatementCallable {
+    (params: ProcessStatementParams): void;
+}
+export interface Query {
+    [key: string]: string;
+}
+export interface QueryKeyField {
+    name: string;
+}
+export interface QueryKey {
+    fields: QueryKeyField[];
+    primary?: boolean;
+    unique?: boolean;
+    name: string;
+}
+export declare type QueryKeys = QueryKey[];
+export declare type QuerySort = Record<string, -1 | 1>;
 export {};

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["export interface OperatorArgs {\n    expression: string;\n    attributeNames: Record<string, any>;\n    attributeValues: Record<string, any>;\n}\n\ninterface CanProcessArgs {\n    key: string;\n    value: any;\n    args: OperatorArgs;\n}\n\ninterface ProcessArgs {\n    key: string;\n    value: any;\n    args: OperatorArgs;\n    processStatement: any;\n}\n\nexport interface Operator {\n    canProcess: ({ key }: CanProcessArgs) => boolean;\n    process: ({ key, value, args }: ProcessArgs) => void;\n}\n\n/**\n * We use this definition to search for a value in any given field that was passed.\n * It works as an \"OR\" condition.\n */\nexport interface DynamoDbContainsFilter {\n    fields: string[];\n    value: string;\n}\n\nexport interface ProcessStatementArgsParam {\n    expression: string;\n    attributeNames: Record<string, any>;\n    attributeValues: Record<string, any>;\n}\nexport interface ProcessStatementQueryParam {\n    [key: string]: any;\n}\nexport interface ProcessStatementParams {\n    args: ProcessStatementArgsParam;\n    query: ProcessStatementQueryParam;\n}\n\nexport interface ProcessStatementCallable {\n    (params: ProcessStatementParams): void;\n}\n\nexport interface Query {\n    [key: string]: string;\n}\nexport interface QueryKeyField {\n    name: string;\n}\nexport interface QueryKey {\n    fields: QueryKeyField[];\n    primary?: boolean;\n    unique?: boolean;\n    name: string;\n}\nexport type QueryKeys = QueryKey[];\n\nexport type QuerySort = Record<string, -1 | 1>;\n"],"mappings":""}

package/utils/attributes.d.ts

@@ -1,4 +1,4 @@
-import { ContextInterface } from "@webiny/handler/types";
+import { Context } from "@webiny/api/types";
 import { DefinitionParams } from "../plugins/definitions/AttributePlugin";
 import { PluginsContainer } from "@webiny/plugins";
 /**
@@ -6,5 +6,5 @@ import { PluginsContainer } from "@webiny/plugins";
  *
  * @deprecated
  */
-export declare const getExtraAttributes: (context: ContextInterface, entity: string) => Record<string, DefinitionParams>;
+export declare const getExtraAttributes: (context: Context, entity: string) => Record<string, DefinitionParams>;
 export declare const getExtraAttributesFromPlugins: (plugins: PluginsContainer, entity: string) => Record<string, DefinitionParams>;

package/utils/attributes.js

@@ -11,9 +11,9 @@ var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/de
 
 var _AttributePlugin = require("../plugins/definitions/AttributePlugin");
 
-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 ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); 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; }
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
 /**
  * Will be removed in favor of directly assigning attributes to a certain entity when creating the storage operations.

package/utils/attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getExtraAttributes","context","entity","getExtraAttributesFromPlugins","plugins","byType","AttributePlugin","type","filter","plugin","reduce","attributes","getDefinition"],"sources":["attributes.ts"],"sourcesContent":["import { Context } from \"@webiny/api/types\";\nimport { AttributePlugin, DefinitionParams } from \"~/plugins/definitions/AttributePlugin\";\nimport { PluginsContainer } from \"@webiny/plugins\";\n\n/**\n * Will be removed in favor of directly assigning attributes to a certain entity when creating the storage operations.\n *\n * @deprecated\n */\nexport const getExtraAttributes = (\n    context: Context,\n    entity: string\n): Record<string, DefinitionParams> => {\n    return getExtraAttributesFromPlugins(context.plugins, entity);\n};\n\nexport const getExtraAttributesFromPlugins = (\n    plugins: PluginsContainer,\n    entity: string\n): Record<string, DefinitionParams> => {\n    return plugins\n        .byType<AttributePlugin>(AttributePlugin.type)\n        .filter(plugin => plugin.entity === entity)\n        .reduce((attributes, plugin) => {\n            return {\n                ...attributes,\n                ...plugin.getDefinition()\n            };\n        }, {});\n};\n"],"mappings":";;;;;;;;;;;AACA;;;;;;AAGA;AACA;AACA;AACA;AACA;AACO,MAAMA,kBAAkB,GAAG,CAC9BC,OAD8B,EAE9BC,MAF8B,KAGK;EACnC,OAAOC,6BAA6B,CAACF,OAAO,CAACG,OAAT,EAAkBF,MAAlB,CAApC;AACH,CALM;;;;AAOA,MAAMC,6BAA6B,GAAG,CACzCC,OADyC,EAEzCF,MAFyC,KAGN;EACnC,OAAOE,OAAO,CACTC,MADE,CACsBC,gCAAA,CAAgBC,IADtC,EAEFC,MAFE,CAEKC,MAAM,IAAIA,MAAM,CAACP,MAAP,KAAkBA,MAFjC,EAGFQ,MAHE,CAGK,CAACC,UAAD,EAAaF,MAAb,KAAwB;IAC5B,uCACOE,UADP,GAEOF,MAAM,CAACG,aAAP,EAFP;EAIH,CARE,EAQA,EARA,CAAP;AASH,CAbM"}

package/utils/batchRead.d.ts

@@ -11,5 +11,5 @@ interface Params {
  * This helper function is meant to be used to batch read from one table.
  * It will fetch all results, as there is a next() method call built in.
  */
-export declare const batchReadAll: <T = any>(params: Params) => Promise<T[]>;
+export declare const batchReadAll: <T = any>(params: Params, maxChunk?: number) => Promise<T[]>;
 export {};

package/utils/batchRead.js

@@ -1,10 +1,18 @@
 "use strict";
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.batchReadAll = void 0;
 
+var _chunk = _interopRequireDefault(require("lodash/chunk"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const MAX_BATCH_ITEMS = 100;
+
 const flatten = responses => {
   const entries = [];
   const values = Object.values(responses);
@@ -15,44 +23,67 @@ const flatten = responses => {
 
   return entries;
 };
-/**
- * This helper function is meant to be used to batch read from one table.
- * It will fetch all results, as there is a next() method call built in.
- */
 
+const batchReadAllChunk = async params => {
+  const {
+    table,
+    items
+  } = params;
+  const records = [];
+  const result = await table.batchGet(items);
 
-const batchReadAll = async params => {
-  if (params.items.length === 0) {
-    return [];
+  if (!result || !result.Responses) {
+    return records;
   }
 
-  const items = [];
-  const result = await params.table.batchGet(params.items);
+  records.push(...flatten(result.Responses));
 
-  if (result.Responses) {
-    items.push(...flatten(result.Responses));
+  if (!result.next || typeof result.next !== "function") {
+    return records;
   }
 
-  if (typeof result.next === "function") {
-    let previous = result;
-    let nextResult;
+  let previous = result;
 
-    while (nextResult = await previous.next()) {
-      if (!nextResult) {
-        return items;
-      }
+  while (typeof previous.next === "function") {
+    const nextResult = await previous.next();
 
-      items.push(...flatten(nextResult.Responses));
+    if (!nextResult) {
+      return records;
+    }
 
-      if (!nextResult || typeof nextResult.next !== "function") {
-        return items;
-      }
+    records.push(...flatten(nextResult.Responses));
+    previous = nextResult;
+  }
 
-      previous = nextResult;
-    }
+  return records;
+};
+/**
+ * This helper function is meant to be used to batch read from one table.
+ * It will fetch all results, as there is a next() method call built in.
+ */
+
+
+const batchReadAll = async (params, maxChunk = MAX_BATCH_ITEMS) => {
+  if (params.items.length === 0) {
+    return [];
+  } else if (maxChunk > MAX_BATCH_ITEMS) {
+    throw new _error.default(`Cannot set to load more than ${MAX_BATCH_ITEMS} items from the DynamoDB at once.`, "DYNAMODB_MAX_BATCH_GET_LIMIT_ERROR", {
+      maxChunk
+    });
+  }
+
+  const records = [];
+  const chunkItemsList = (0, _chunk.default)(params.items, maxChunk);
+
+  for (const chunkItems of chunkItemsList) {
+    const results = await batchReadAllChunk({
+      table: params.table,
+      items: chunkItems
+    });
+    records.push(...results);
   }
 
-  return items;
+  return records;
 };
 
 exports.batchReadAll = batchReadAll;