@webiny/db-dynamodb 0.0.0-ee-vpcs.549378cf03

package/QueryGenerator.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _createKeyConditionExpressionArgs = _interopRequireDefault(require("./statements/createKeyConditionExpressionArgs"));
+
+class QueryGenerator {
+  generate(params) {
+    const {
+      query,
+      keys,
+      sort,
+      limit,
+      tableName
+    } = params; // 1. Which key can we use in this query operation?
+
+    const key = this.findQueryKey(query, keys);
+
+    if (!key) {
+      throw new Error("Cannot perform query - key not found.");
+    } // 2. Now that we know the key, let's separate the key attributes from the rest.
+
+
+    const keyAttributesValues = {};
+    const nonKeyAttributesValues = {};
+
+    for (const queryKey in query) {
+      if (key.fields.find(item => item.name === queryKey)) {
+        keyAttributesValues[queryKey] = query[queryKey];
+      } else {
+        nonKeyAttributesValues[queryKey] = query[queryKey];
+      }
+    }
+
+    const keyConditionExpression = (0, _createKeyConditionExpressionArgs.default)({
+      query: keyAttributesValues,
+      sort,
+      key
+    });
+    return (0, _objectSpread2.default)((0, _objectSpread2.default)({}, keyConditionExpression), {}, {
+      TableName: tableName,
+      Limit: limit
+    });
+  }
+
+  findQueryKey(query = {}, keys = []) {
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      let hasAllFields = true;
+
+      for (let j = 0; j < key.fields.length; j++) {
+        const field = key.fields[j];
+
+        if (!query[field.name]) {
+          hasAllFields = false;
+          break;
+        }
+      }
+
+      if (hasAllFields) {
+        return key;
+      }
+    }
+
+    return null;
+  }
+
+}
+
+var _default = QueryGenerator;
+exports.default = _default;

package/QueryGenerator.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["QueryGenerator","generate","params","query","keys","sort","limit","tableName","key","findQueryKey","Error","keyAttributesValues","nonKeyAttributesValues","queryKey","fields","find","item","name","keyConditionExpression","createKeyConditionExpressionArgs","TableName","Limit","i","length","hasAllFields","j","field"],"sources":["QueryGenerator.ts"],"sourcesContent":["import createKeyConditionExpressionArgs from \"./statements/createKeyConditionExpressionArgs\";\nimport { Query, QueryKey, QueryKeyField, QueryKeys, QuerySort } from \"~/types\";\n\ninterface GenerateParams {\n    query: Query;\n    keys: QueryKeys;\n    sort: QuerySort;\n    limit: number;\n    tableName: string;\n}\nclass QueryGenerator {\n    generate(params: GenerateParams) {\n        const { query, keys, sort, limit, tableName } = params;\n        // 1. Which key can we use in this query operation?\n        const key = this.findQueryKey(query, keys);\n\n        if (!key) {\n            throw new Error(\"Cannot perform query - key not found.\");\n        }\n\n        // 2. Now that we know the key, let's separate the key attributes from the rest.\n        const keyAttributesValues: Record<string, string> = {};\n        const nonKeyAttributesValues: Record<string, string> = {};\n        for (const queryKey in query) {\n            if (key.fields.find((item: QueryKeyField) => item.name === queryKey)) {\n                keyAttributesValues[queryKey] = query[queryKey];\n            } else {\n                nonKeyAttributesValues[queryKey] = query[queryKey];\n            }\n        }\n\n        const keyConditionExpression = createKeyConditionExpressionArgs({\n            query: keyAttributesValues,\n            sort,\n            key\n        });\n\n        return { ...keyConditionExpression, TableName: tableName, Limit: limit };\n    }\n\n    findQueryKey(query: Query = {}, keys: QueryKeys = []): QueryKey | null {\n        for (let i = 0; i < keys.length; i++) {\n            const key = keys[i];\n            let hasAllFields = true;\n            for (let j = 0; j < key.fields.length; j++) {\n                const field = key.fields[j];\n                if (!query[field.name]) {\n                    hasAllFields = false;\n                    break;\n                }\n            }\n\n            if (hasAllFields) {\n                return key;\n            }\n        }\n        return null;\n    }\n}\n\nexport default QueryGenerator;\n"],"mappings":";;;;;;;;;;;AAAA;;AAUA,MAAMA,cAAN,CAAqB;EACjBC,QAAQ,CAACC,MAAD,EAAyB;IAC7B,MAAM;MAAEC,KAAF;MAASC,IAAT;MAAeC,IAAf;MAAqBC,KAArB;MAA4BC;IAA5B,IAA0CL,MAAhD,CAD6B,CAE7B;;IACA,MAAMM,GAAG,GAAG,KAAKC,YAAL,CAAkBN,KAAlB,EAAyBC,IAAzB,CAAZ;;IAEA,IAAI,CAACI,GAAL,EAAU;MACN,MAAM,IAAIE,KAAJ,CAAU,uCAAV,CAAN;IACH,CAP4B,CAS7B;;;IACA,MAAMC,mBAA2C,GAAG,EAApD;IACA,MAAMC,sBAA8C,GAAG,EAAvD;;IACA,KAAK,MAAMC,QAAX,IAAuBV,KAAvB,EAA8B;MAC1B,IAAIK,GAAG,CAACM,MAAJ,CAAWC,IAAX,CAAiBC,IAAD,IAAyBA,IAAI,CAACC,IAAL,KAAcJ,QAAvD,CAAJ,EAAsE;QAClEF,mBAAmB,CAACE,QAAD,CAAnB,GAAgCV,KAAK,CAACU,QAAD,CAArC;MACH,CAFD,MAEO;QACHD,sBAAsB,CAACC,QAAD,CAAtB,GAAmCV,KAAK,CAACU,QAAD,CAAxC;MACH;IACJ;;IAED,MAAMK,sBAAsB,GAAG,IAAAC,yCAAA,EAAiC;MAC5DhB,KAAK,EAAEQ,mBADqD;MAE5DN,IAF4D;MAG5DG;IAH4D,CAAjC,CAA/B;IAMA,mEAAYU,sBAAZ;MAAoCE,SAAS,EAAEb,SAA/C;MAA0Dc,KAAK,EAAEf;IAAjE;EACH;;EAEDG,YAAY,CAACN,KAAY,GAAG,EAAhB,EAAoBC,IAAe,GAAG,EAAtC,EAA2D;IACnE,KAAK,IAAIkB,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGlB,IAAI,CAACmB,MAAzB,EAAiCD,CAAC,EAAlC,EAAsC;MAClC,MAAMd,GAAG,GAAGJ,IAAI,CAACkB,CAAD,CAAhB;MACA,IAAIE,YAAY,GAAG,IAAnB;;MACA,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGjB,GAAG,CAACM,MAAJ,CAAWS,MAA/B,EAAuCE,CAAC,EAAxC,EAA4C;QACxC,MAAMC,KAAK,GAAGlB,GAAG,CAACM,MAAJ,CAAWW,CAAX,CAAd;;QACA,IAAI,CAACtB,KAAK,CAACuB,KAAK,CAACT,IAAP,CAAV,EAAwB;UACpBO,YAAY,GAAG,KAAf;UACA;QACH;MACJ;;MAED,IAAIA,YAAJ,EAAkB;QACd,OAAOhB,GAAP;MACH;IACJ;;IACD,OAAO,IAAP;EACH;;AA/CgB;;eAkDNR,c"}

package/README.md

@@ -0,0 +1,67 @@
+# @webiny/db-dynamodb
+[![](https://img.shields.io/npm/dw/webiny-data-dynamodb.svg)](https://www.npmjs.com/package/webiny-data-dynamodb) 
+[![](https://img.shields.io/npm/v/webiny-data-dynamodb.svg)](https://www.npmjs.com/package/webiny-data-dynamodb)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+A set of frequently used data-dynamodb higher order functions.
+
+For more information, please visit 
+[the official docs](https://github.com/doitadrian/data-dynamodb). 
+  
+## Install
+```
+yarn add @webiny/db-dynamodb
+```
+
+
+### Helper functions
+We have a number [helper](./src/utils) functions that ease the use of either dynamodb-toolbox, filtering, sorting or just creating proper response.
+
+#### [batchRead](./src/utils/batchRead.ts)
+Read a batch of records from the DynamoDB table.
+
+This function accepts [table](https://github.com/jeremydaly/dynamodb-toolbox/blob/main/src/classes/Table.ts) and items, an array of objects created by [Entity.getBatch()](https://github.com/jeremydaly/dynamodb-toolbox/blob/main/src/classes/Entity.ts#L313).
+
+Internally it reads records until there are no more to read and returns a list of read records.
+
+#### [batchWrite](./src/utils/batchWrite.ts)
+Write a batch of records to the DynamoDB table.
+
+This function accepts [table](https://github.com/jeremydaly/dynamodb-toolbox/blob/main/src/classes/Table.ts) and items, an array of objects created by [Entity.putBatch()](https://github.com/jeremydaly/dynamodb-toolbox/blob/main/src/classes/Entity.ts#L989).
+It also accepts a number which defines a number of items to be written in one request. DO NOT put that number over the official DynamoDB maximum.
+
+Internally it loops through the items received (in chunks of `maxChunks` parameter) and does not return anything.
+
+
+#### [cleanupItem and cleanupItems](./src/utils/cleanup.ts)
+Clean up records received from the DynamoDB table. 
+
+This function accepts [entity](https://github.com/jeremydaly/dynamodb-toolbox/blob/main/src/classes/Entity.ts) and item to be cleaned up, in case of the cleanupItem.
+In case of `cleanupItems` it accepts an array of items to clean up.
+
+We use this to remove the properties that dynamodb-toolbox puts on the record automatically.
+
+#### [get](./src/utils/get.ts)
+Get a single record from the DynamoDB table with given keys.
+
+This function accepts [entity](https://github.com/jeremydaly/dynamodb-toolbox/blob/main/src/classes/Entity.ts) and keys to fetch the record by.
+
+It returns either record or null. By default, [entity.get()](https://github.com/jeremydaly/dynamodb-toolbox/blob/main/src/classes/Entity.ts#L281) returns a object with some meta data and `Item` property, which contains the record (or null if no record).
+
+#### [queryOne and queryAll](./src/utils/query.ts)
+Query the DynamoDB table for record(s) by given partition key and query options.
+
+This function accepts [entity](https://github.com/jeremydaly/dynamodb-toolbox/blob/main/src/classes/Entity.ts) to perform the query on, `partitionKey` to query by and [options](https://github.com/jeremydaly/dynamodb-toolbox/blob/main/src/classes/Table.ts#L65) to define the query parameters with.
+
+The `queryAll` method accepts `limit`, a number with which you can load only a certain amount of records. The `queryOne` method does not have that property.
+
+#### [filter](./src/utils/filter.ts)
+Filter the DynamoDB records by given where condition.
+
+This function accepts items (records) to be filtered, a definition of fields to filter by (not required by default if no field modification is required), where conditions (eg. `{published: true, date_gte: "2021-01-01"}`) and filtering plugins.
+
+#### [sort](./src/utils/sort.ts)
+Sort the DynamoDB records by given sort condition.
+
+This function accepts items (records) to be sorted, sort options (eg. createdBy_ASC, id_DESC, etc.) and a definitions of fields to sort by (not required by default if no field modification is required).

package/index.d.ts

@@ -0,0 +1,2 @@
+import { default as DynamoDbDriver } from "./DynamoDbDriver";
+export { DynamoDbDriver };

package/index.js

@@ -0,0 +1,15 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DynamoDbDriver", {
+  enumerable: true,
+  get: function () {
+    return _DynamoDbDriver.default;
+  }
+});
+
+var _DynamoDbDriver = _interopRequireDefault(require("./DynamoDbDriver"));

package/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["import { default as DynamoDbDriver } from \"./DynamoDbDriver\";\n\nexport { DynamoDbDriver };\n"],"mappings":";;;;;;;;;;;;;;AAAA"}

package/operators/comparison/beginsWith.d.ts

@@ -0,0 +1,3 @@
+import { Operator } from "../../types";
+declare const beginsWith: Operator;
+export default beginsWith;

package/operators/comparison/beginsWith.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const beginsWith = {
+  canProcess: ({
+    value
+  }) => {
+    return value && typeof value["$beginsWith"] !== "undefined";
+  },
+  process: ({
+    key,
+    value,
+    args
+  }) => {
+    args.expression += `begins_with (#${key}, :${key})`;
+    args.attributeNames[`#${key}`] = key;
+    args.attributeValues[`:${key}`] = value["$beginsWith"];
+  }
+};
+var _default = beginsWith;
+exports.default = _default;

package/operators/comparison/beginsWith.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["beginsWith","canProcess","value","process","key","args","expression","attributeNames","attributeValues"],"sources":["beginsWith.ts"],"sourcesContent":["import { Operator } from \"~/types\";\n\nconst beginsWith: Operator = {\n    canProcess: ({ value }) => {\n        return value && typeof value[\"$beginsWith\"] !== \"undefined\";\n    },\n    process: ({ key, value, args }) => {\n        args.expression += `begins_with (#${key}, :${key})`;\n        args.attributeNames[`#${key}`] = key;\n        args.attributeValues[`:${key}`] = value[\"$beginsWith\"];\n    }\n};\n\nexport default beginsWith;\n"],"mappings":";;;;;;AAEA,MAAMA,UAAoB,GAAG;EACzBC,UAAU,EAAE,CAAC;IAAEC;EAAF,CAAD,KAAe;IACvB,OAAOA,KAAK,IAAI,OAAOA,KAAK,CAAC,aAAD,CAAZ,KAAgC,WAAhD;EACH,CAHwB;EAIzBC,OAAO,EAAE,CAAC;IAAEC,GAAF;IAAOF,KAAP;IAAcG;EAAd,CAAD,KAA0B;IAC/BA,IAAI,CAACC,UAAL,IAAoB,iBAAgBF,GAAI,MAAKA,GAAI,GAAjD;IACAC,IAAI,CAACE,cAAL,CAAqB,IAAGH,GAAI,EAA5B,IAAiCA,GAAjC;IACAC,IAAI,CAACG,eAAL,CAAsB,IAAGJ,GAAI,EAA7B,IAAkCF,KAAK,CAAC,aAAD,CAAvC;EACH;AARwB,CAA7B;eAWeF,U"}

package/operators/comparison/between.d.ts

@@ -0,0 +1,3 @@
+import { Operator } from "../../types";
+declare const between: Operator;
+export default between;

package/operators/comparison/between.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const between = {
+  canProcess: ({
+    value
+  }) => {
+    return value && typeof value["$between"] !== "undefined";
+  },
+  process: ({
+    key,
+    value
+  }) => {
+    return {
+      statement: `#${key} BETWEEN :${key}Gte AND :${key}Lte`,
+      attributeNames: {
+        [`#${key}`]: key
+      },
+      attributeValues: {
+        [`:${key}Gte`]: value[0],
+        [`:${key}Lte`]: value[1]
+      }
+    };
+  }
+};
+var _default = between;
+exports.default = _default;

package/operators/comparison/between.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["between","canProcess","value","process","key","statement","attributeNames","attributeValues"],"sources":["between.ts"],"sourcesContent":["import { Operator } from \"~/types\";\n\nconst between: Operator = {\n    canProcess: ({ value }) => {\n        return value && typeof value[\"$between\"] !== \"undefined\";\n    },\n    process: ({ key, value }) => {\n        return {\n            statement: `#${key} BETWEEN :${key}Gte AND :${key}Lte`,\n            attributeNames: {\n                [`#${key}`]: key\n            },\n            attributeValues: {\n                [`:${key}Gte`]: value[0],\n                [`:${key}Lte`]: value[1]\n            }\n        };\n    }\n};\n\nexport default between;\n"],"mappings":";;;;;;AAEA,MAAMA,OAAiB,GAAG;EACtBC,UAAU,EAAE,CAAC;IAAEC;EAAF,CAAD,KAAe;IACvB,OAAOA,KAAK,IAAI,OAAOA,KAAK,CAAC,UAAD,CAAZ,KAA6B,WAA7C;EACH,CAHqB;EAItBC,OAAO,EAAE,CAAC;IAAEC,GAAF;IAAOF;EAAP,CAAD,KAAoB;IACzB,OAAO;MACHG,SAAS,EAAG,IAAGD,GAAI,aAAYA,GAAI,YAAWA,GAAI,KAD/C;MAEHE,cAAc,EAAE;QACZ,CAAE,IAAGF,GAAI,EAAT,GAAaA;MADD,CAFb;MAKHG,eAAe,EAAE;QACb,CAAE,IAAGH,GAAI,KAAT,GAAgBF,KAAK,CAAC,CAAD,CADR;QAEb,CAAE,IAAGE,GAAI,KAAT,GAAgBF,KAAK,CAAC,CAAD;MAFR;IALd,CAAP;EAUH;AAfqB,CAA1B;eAkBeF,O"}

package/operators/comparison/eq.d.ts

@@ -0,0 +1,3 @@
+import { Operator } from "../../types";
+declare const eq: Operator;
+export default eq;

package/operators/comparison/eq.js

@@ -0,0 +1,34 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const validTypes = ["string", "boolean", "number"];
+const eq = {
+  canProcess: ({
+    key,
+    value
+  }) => {
+    if (key && key.charAt(0) === "$") {
+      return false;
+    }
+
+    if (value && typeof value["$eq"] !== "undefined") {
+      return true;
+    }
+
+    return validTypes.includes(typeof value);
+  },
+  process: ({
+    key,
+    value,
+    args
+  }) => {
+    args.expression += `#${key} = :${key}`;
+    args.attributeNames[`#${key}`] = key;
+    args.attributeValues[`:${key}`] = value;
+  }
+};
+var _default = eq;
+exports.default = _default;

package/operators/comparison/eq.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["validTypes","eq","canProcess","key","value","charAt","includes","process","args","expression","attributeNames","attributeValues"],"sources":["eq.ts"],"sourcesContent":["import { Operator } from \"~/types\";\n\nconst validTypes = [\"string\", \"boolean\", \"number\"];\n\nconst eq: Operator = {\n    canProcess: ({ key, value }) => {\n        if (key && key.charAt(0) === \"$\") {\n            return false;\n        }\n\n        if (value && typeof value[\"$eq\"] !== \"undefined\") {\n            return true;\n        }\n\n        return validTypes.includes(typeof value);\n    },\n    process: ({ key, value, args }) => {\n        args.expression += `#${key} = :${key}`;\n        args.attributeNames[`#${key}`] = key;\n        args.attributeValues[`:${key}`] = value;\n    }\n};\n\nexport default eq;\n"],"mappings":";;;;;;AAEA,MAAMA,UAAU,GAAG,CAAC,QAAD,EAAW,SAAX,EAAsB,QAAtB,CAAnB;AAEA,MAAMC,EAAY,GAAG;EACjBC,UAAU,EAAE,CAAC;IAAEC,GAAF;IAAOC;EAAP,CAAD,KAAoB;IAC5B,IAAID,GAAG,IAAIA,GAAG,CAACE,MAAJ,CAAW,CAAX,MAAkB,GAA7B,EAAkC;MAC9B,OAAO,KAAP;IACH;;IAED,IAAID,KAAK,IAAI,OAAOA,KAAK,CAAC,KAAD,CAAZ,KAAwB,WAArC,EAAkD;MAC9C,OAAO,IAAP;IACH;;IAED,OAAOJ,UAAU,CAACM,QAAX,CAAoB,OAAOF,KAA3B,CAAP;EACH,CAXgB;EAYjBG,OAAO,EAAE,CAAC;IAAEJ,GAAF;IAAOC,KAAP;IAAcI;EAAd,CAAD,KAA0B;IAC/BA,IAAI,CAACC,UAAL,IAAoB,IAAGN,GAAI,OAAMA,GAAI,EAArC;IACAK,IAAI,CAACE,cAAL,CAAqB,IAAGP,GAAI,EAA5B,IAAiCA,GAAjC;IACAK,IAAI,CAACG,eAAL,CAAsB,IAAGR,GAAI,EAA7B,IAAkCC,KAAlC;EACH;AAhBgB,CAArB;eAmBeH,E"}

package/operators/comparison/gt.d.ts

@@ -0,0 +1,3 @@
+import { Operator } from "../../types";
+declare const gt: Operator;
+export default gt;

package/operators/comparison/gt.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const gt = {
+  canProcess: ({
+    value
+  }) => {
+    return value && typeof value["$gt"] !== "undefined";
+  },
+  process: ({
+    key,
+    value,
+    args
+  }) => {
+    args.expression += `#${key} > :${key}`;
+    args.attributeNames[`#${key}`] = key;
+    args.attributeValues[`:${key}`] = value["$gt"];
+  }
+};
+var _default = gt;
+exports.default = _default;

package/operators/comparison/gt.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["gt","canProcess","value","process","key","args","expression","attributeNames","attributeValues"],"sources":["gt.ts"],"sourcesContent":["import { Operator } from \"~/types\";\n\nconst gt: Operator = {\n    canProcess: ({ value }) => {\n        return value && typeof value[\"$gt\"] !== \"undefined\";\n    },\n    process: ({ key, value, args }) => {\n        args.expression += `#${key} > :${key}`;\n        args.attributeNames[`#${key}`] = key;\n        args.attributeValues[`:${key}`] = value[\"$gt\"];\n    }\n};\n\nexport default gt;\n"],"mappings":";;;;;;AAEA,MAAMA,EAAY,GAAG;EACjBC,UAAU,EAAE,CAAC;IAAEC;EAAF,CAAD,KAAe;IACvB,OAAOA,KAAK,IAAI,OAAOA,KAAK,CAAC,KAAD,CAAZ,KAAwB,WAAxC;EACH,CAHgB;EAIjBC,OAAO,EAAE,CAAC;IAAEC,GAAF;IAAOF,KAAP;IAAcG;EAAd,CAAD,KAA0B;IAC/BA,IAAI,CAACC,UAAL,IAAoB,IAAGF,GAAI,OAAMA,GAAI,EAArC;IACAC,IAAI,CAACE,cAAL,CAAqB,IAAGH,GAAI,EAA5B,IAAiCA,GAAjC;IACAC,IAAI,CAACG,eAAL,CAAsB,IAAGJ,GAAI,EAA7B,IAAkCF,KAAK,CAAC,KAAD,CAAvC;EACH;AARgB,CAArB;eAWeF,E"}

package/operators/comparison/gte.d.ts

@@ -0,0 +1,3 @@
+import { Operator } from "../../types";
+declare const gte: Operator;
+export default gte;

package/operators/comparison/gte.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const gte = {
+  canProcess: ({
+    value
+  }) => {
+    return value && typeof value["$gte"] !== "undefined";
+  },
+  process: ({
+    key,
+    value,
+    args
+  }) => {
+    args.expression += `#${key} >= :${key}`;
+    args.attributeNames[`#${key}`] = key;
+    args.attributeValues[`:${key}`] = value["$gte"];
+  }
+};
+var _default = gte;
+exports.default = _default;

package/operators/comparison/gte.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["gte","canProcess","value","process","key","args","expression","attributeNames","attributeValues"],"sources":["gte.ts"],"sourcesContent":["import { Operator } from \"~/types\";\n\nconst gte: Operator = {\n    canProcess: ({ value }) => {\n        return value && typeof value[\"$gte\"] !== \"undefined\";\n    },\n    process: ({ key, value, args }) => {\n        args.expression += `#${key} >= :${key}`;\n        args.attributeNames[`#${key}`] = key;\n        args.attributeValues[`:${key}`] = value[\"$gte\"];\n    }\n};\n\nexport default gte;\n"],"mappings":";;;;;;AAEA,MAAMA,GAAa,GAAG;EAClBC,UAAU,EAAE,CAAC;IAAEC;EAAF,CAAD,KAAe;IACvB,OAAOA,KAAK,IAAI,OAAOA,KAAK,CAAC,MAAD,CAAZ,KAAyB,WAAzC;EACH,CAHiB;EAIlBC,OAAO,EAAE,CAAC;IAAEC,GAAF;IAAOF,KAAP;IAAcG;EAAd,CAAD,KAA0B;IAC/BA,IAAI,CAACC,UAAL,IAAoB,IAAGF,GAAI,QAAOA,GAAI,EAAtC;IACAC,IAAI,CAACE,cAAL,CAAqB,IAAGH,GAAI,EAA5B,IAAiCA,GAAjC;IACAC,IAAI,CAACG,eAAL,CAAsB,IAAGJ,GAAI,EAA7B,IAAkCF,KAAK,CAAC,MAAD,CAAvC;EACH;AARiB,CAAtB;eAWeF,G"}

package/operators/comparison/lt.d.ts

@@ -0,0 +1,3 @@
+import { Operator } from "../../types";
+declare const lt: Operator;
+export default lt;

package/operators/comparison/lt.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const lt = {
+  canProcess: ({
+    value
+  }) => {
+    return value && typeof value["$lt"] !== "undefined";
+  },
+  process: ({
+    key,
+    value,
+    args
+  }) => {
+    args.expression += `#${key} < :${key}`;
+    args.attributeNames[`#${key}`] = key;
+    args.attributeValues[`:${key}`] = value["$lt"];
+  }
+};
+var _default = lt;
+exports.default = _default;

package/operators/comparison/lt.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["lt","canProcess","value","process","key","args","expression","attributeNames","attributeValues"],"sources":["lt.ts"],"sourcesContent":["import { Operator } from \"~/types\";\n\nconst lt: Operator = {\n    canProcess: ({ value }) => {\n        return value && typeof value[\"$lt\"] !== \"undefined\";\n    },\n    process: ({ key, value, args }) => {\n        args.expression += `#${key} < :${key}`;\n        args.attributeNames[`#${key}`] = key;\n        args.attributeValues[`:${key}`] = value[\"$lt\"];\n    }\n};\n\nexport default lt;\n"],"mappings":";;;;;;AAEA,MAAMA,EAAY,GAAG;EACjBC,UAAU,EAAE,CAAC;IAAEC;EAAF,CAAD,KAAe;IACvB,OAAOA,KAAK,IAAI,OAAOA,KAAK,CAAC,KAAD,CAAZ,KAAwB,WAAxC;EACH,CAHgB;EAIjBC,OAAO,EAAE,CAAC;IAAEC,GAAF;IAAOF,KAAP;IAAcG;EAAd,CAAD,KAA0B;IAC/BA,IAAI,CAACC,UAAL,IAAoB,IAAGF,GAAI,OAAMA,GAAI,EAArC;IACAC,IAAI,CAACE,cAAL,CAAqB,IAAGH,GAAI,EAA5B,IAAiCA,GAAjC;IACAC,IAAI,CAACG,eAAL,CAAsB,IAAGJ,GAAI,EAA7B,IAAkCF,KAAK,CAAC,KAAD,CAAvC;EACH;AARgB,CAArB;eAWeF,E"}

package/operators/comparison/lte.d.ts

@@ -0,0 +1,3 @@
+import { Operator } from "../../types";
+declare const lte: Operator;
+export default lte;

package/operators/comparison/lte.js

@@ -0,0 +1,24 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+const lte = {
+  canProcess: ({
+    value
+  }) => {
+    return value && typeof value["$lte"] !== "undefined";
+  },
+  process: ({
+    key,
+    value,
+    args
+  }) => {
+    args.expression += `#${key} <= :${key}`;
+    args.attributeNames[`#${key}`] = key;
+    args.attributeValues[`:${key}`] = value["$lte"];
+  }
+};
+var _default = lte;
+exports.default = _default;

package/operators/comparison/lte.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["lte","canProcess","value","process","key","args","expression","attributeNames","attributeValues"],"sources":["lte.ts"],"sourcesContent":["import { Operator } from \"~/types\";\n\nconst lte: Operator = {\n    canProcess: ({ value }) => {\n        return value && typeof value[\"$lte\"] !== \"undefined\";\n    },\n    process: ({ key, value, args }) => {\n        args.expression += `#${key} <= :${key}`;\n        args.attributeNames[`#${key}`] = key;\n        args.attributeValues[`:${key}`] = value[\"$lte\"];\n    }\n};\n\nexport default lte;\n"],"mappings":";;;;;;AAEA,MAAMA,GAAa,GAAG;EAClBC,UAAU,EAAE,CAAC;IAAEC;EAAF,CAAD,KAAe;IACvB,OAAOA,KAAK,IAAI,OAAOA,KAAK,CAAC,MAAD,CAAZ,KAAyB,WAAzC;EACH,CAHiB;EAIlBC,OAAO,EAAE,CAAC;IAAEC,GAAF;IAAOF,KAAP;IAAcG;EAAd,CAAD,KAA0B;IAC/BA,IAAI,CAACC,UAAL,IAAoB,IAAGF,GAAI,QAAOA,GAAI,EAAtC;IACAC,IAAI,CAACE,cAAL,CAAqB,IAAGH,GAAI,EAA5B,IAAiCA,GAAjC;IACAC,IAAI,CAACG,eAAL,CAAsB,IAAGJ,GAAI,EAA7B,IAAkCF,KAAK,CAAC,MAAD,CAAvC;EACH;AARiB,CAAtB;eAWeF,G"}

package/operators/index.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    $and: import("../types").Operator;
+    $or: import("../types").Operator;
+    $beginsWith: import("../types").Operator;
+    $between: import("../types").Operator;
+    $eq: import("../types").Operator;
+    $gt: import("../types").Operator;
+    $gte: import("../types").Operator;
+    $lt: import("../types").Operator;
+    $lte: import("../types").Operator;
+};
+export default _default;

package/operators/index.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _and = _interopRequireDefault(require("./logical/and"));
+
+var _or = _interopRequireDefault(require("./logical/or"));
+
+var _beginsWith = _interopRequireDefault(require("./comparison/beginsWith"));
+
+var _between = _interopRequireDefault(require("./comparison/between"));
+
+var _gt = _interopRequireDefault(require("./comparison/gt"));
+
+var _gte = _interopRequireDefault(require("./comparison/gte"));
+
+var _lt = _interopRequireDefault(require("./comparison/lt"));
+
+var _lte = _interopRequireDefault(require("./comparison/lte"));
+
+var _eq = _interopRequireDefault(require("./comparison/eq"));
+
+var _default = {
+  $and: _and.default,
+  $or: _or.default,
+  $beginsWith: _beginsWith.default,
+  $between: _between.default,
+  $eq: _eq.default,
+  $gt: _gt.default,
+  $gte: _gte.default,
+  $lt: _lt.default,
+  $lte: _lte.default
+};
+exports.default = _default;

package/operators/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["$and","$or","$beginsWith","$between","$eq","$gt","$gte","$lt","$lte"],"sources":["index.ts"],"sourcesContent":["import $and from \"./logical/and\";\nimport $or from \"./logical/or\";\nimport $beginsWith from \"./comparison/beginsWith\";\nimport $between from \"./comparison/between\";\nimport $gt from \"./comparison/gt\";\nimport $gte from \"./comparison/gte\";\nimport $lt from \"./comparison/lt\";\nimport $lte from \"./comparison/lte\";\nimport $eq from \"./comparison/eq\";\n\nexport default {\n    $and,\n    $or,\n    $beginsWith,\n    $between,\n    $eq,\n    $gt,\n    $gte,\n    $lt,\n    $lte\n};\n"],"mappings":";;;;;;;;;AAAA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;AACA;;eAEe;EACXA,IAAI,EAAJA,YADW;EAEXC,GAAG,EAAHA,WAFW;EAGXC,WAAW,EAAXA,mBAHW;EAIXC,QAAQ,EAARA,gBAJW;EAKXC,GAAG,EAAHA,WALW;EAMXC,GAAG,EAAHA,WANW;EAOXC,IAAI,EAAJA,YAPW;EAQXC,GAAG,EAAHA,WARW;EASXC,IAAI,EAAJA;AATW,C"}

package/operators/logical/and.d.ts

@@ -0,0 +1,3 @@
+import { Operator } from "../../types";
+declare const and: Operator;
+export default and;

package/operators/logical/and.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+const processQuery = (query, andArgs, processStatement) => {
+  const args = {
+    expression: "",
+    attributeNames: {},
+    attributeValues: {}
+  };
+  processStatement({
+    args,
+    query
+  });
+  Object.assign(andArgs.attributeNames, args.attributeNames);
+  Object.assign(andArgs.attributeValues, args.attributeValues);
+
+  if (andArgs.expression === "") {
+    andArgs.expression = args.expression;
+  } else {
+    andArgs.expression += " and " + args.expression;
+  }
+};
+
+const and = {
+  canProcess: ({
+    key
+  }) => {
+    return key === "$and";
+  },
+  process: ({
+    value,
+    args,
+    processStatement
+  }) => {
+    const andArgs = {
+      expression: "",
+      attributeNames: {},
+      attributeValues: {}
+    };
+
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        processQuery(value[i], andArgs, processStatement);
+      }
+    } else {
+      for (const [andKey, andValue] of Object.entries(value)) {
+        processQuery({
+          [andKey]: andValue
+        }, andArgs, processStatement);
+      }
+    }
+
+    args.expression += "(" + andArgs.expression + ")";
+    Object.assign(args.attributeNames, andArgs.attributeNames);
+    Object.assign(args.attributeValues, andArgs.attributeValues);
+  }
+};
+var _default = and;
+exports.default = _default;

package/operators/logical/and.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["processQuery","query","andArgs","processStatement","args","expression","attributeNames","attributeValues","Object","assign","and","canProcess","key","process","value","Array","isArray","i","length","andKey","andValue","entries"],"sources":["and.ts"],"sourcesContent":["import {\n    Operator,\n    ProcessStatementArgsParam,\n    ProcessStatementCallable,\n    ProcessStatementQueryParam\n} from \"~/types\";\n\nconst processQuery = (\n    query: ProcessStatementQueryParam,\n    andArgs: ProcessStatementArgsParam,\n    processStatement: ProcessStatementCallable\n) => {\n    const args: ProcessStatementArgsParam = {\n        expression: \"\",\n        attributeNames: {},\n        attributeValues: {}\n    };\n\n    processStatement({ args, query });\n\n    Object.assign(andArgs.attributeNames, args.attributeNames);\n    Object.assign(andArgs.attributeValues, args.attributeValues);\n\n    if (andArgs.expression === \"\") {\n        andArgs.expression = args.expression;\n    } else {\n        andArgs.expression += \" and \" + args.expression;\n    }\n};\n\nconst and: Operator = {\n    canProcess: ({ key }) => {\n        return key === \"$and\";\n    },\n    process: ({ value, args, processStatement }) => {\n        const andArgs = {\n            expression: \"\",\n            attributeNames: {},\n            attributeValues: {}\n        };\n\n        if (Array.isArray(value)) {\n            for (let i = 0; i < value.length; i++) {\n                processQuery(value[i], andArgs, processStatement);\n            }\n        } else {\n            for (const [andKey, andValue] of Object.entries(value)) {\n                processQuery({ [andKey]: andValue }, andArgs, processStatement);\n            }\n        }\n\n        args.expression += \"(\" + andArgs.expression + \")\";\n        Object.assign(args.attributeNames, andArgs.attributeNames);\n        Object.assign(args.attributeValues, andArgs.attributeValues);\n    }\n};\n\nexport default and;\n"],"mappings":";;;;;;;AAOA,MAAMA,YAAY,GAAG,CACjBC,KADiB,EAEjBC,OAFiB,EAGjBC,gBAHiB,KAIhB;EACD,MAAMC,IAA+B,GAAG;IACpCC,UAAU,EAAE,EADwB;IAEpCC,cAAc,EAAE,EAFoB;IAGpCC,eAAe,EAAE;EAHmB,CAAxC;EAMAJ,gBAAgB,CAAC;IAAEC,IAAF;IAAQH;EAAR,CAAD,CAAhB;EAEAO,MAAM,CAACC,MAAP,CAAcP,OAAO,CAACI,cAAtB,EAAsCF,IAAI,CAACE,cAA3C;EACAE,MAAM,CAACC,MAAP,CAAcP,OAAO,CAACK,eAAtB,EAAuCH,IAAI,CAACG,eAA5C;;EAEA,IAAIL,OAAO,CAACG,UAAR,KAAuB,EAA3B,EAA+B;IAC3BH,OAAO,CAACG,UAAR,GAAqBD,IAAI,CAACC,UAA1B;EACH,CAFD,MAEO;IACHH,OAAO,CAACG,UAAR,IAAsB,UAAUD,IAAI,CAACC,UAArC;EACH;AACJ,CArBD;;AAuBA,MAAMK,GAAa,GAAG;EAClBC,UAAU,EAAE,CAAC;IAAEC;EAAF,CAAD,KAAa;IACrB,OAAOA,GAAG,KAAK,MAAf;EACH,CAHiB;EAIlBC,OAAO,EAAE,CAAC;IAAEC,KAAF;IAASV,IAAT;IAAeD;EAAf,CAAD,KAAuC;IAC5C,MAAMD,OAAO,GAAG;MACZG,UAAU,EAAE,EADA;MAEZC,cAAc,EAAE,EAFJ;MAGZC,eAAe,EAAE;IAHL,CAAhB;;IAMA,IAAIQ,KAAK,CAACC,OAAN,CAAcF,KAAd,CAAJ,EAA0B;MACtB,KAAK,IAAIG,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,KAAK,CAACI,MAA1B,EAAkCD,CAAC,EAAnC,EAAuC;QACnCjB,YAAY,CAACc,KAAK,CAACG,CAAD,CAAN,EAAWf,OAAX,EAAoBC,gBAApB,CAAZ;MACH;IACJ,CAJD,MAIO;MACH,KAAK,MAAM,CAACgB,MAAD,EAASC,QAAT,CAAX,IAAiCZ,MAAM,CAACa,OAAP,CAAeP,KAAf,CAAjC,EAAwD;QACpDd,YAAY,CAAC;UAAE,CAACmB,MAAD,GAAUC;QAAZ,CAAD,EAAyBlB,OAAzB,EAAkCC,gBAAlC,CAAZ;MACH;IACJ;;IAEDC,IAAI,CAACC,UAAL,IAAmB,MAAMH,OAAO,CAACG,UAAd,GAA2B,GAA9C;IACAG,MAAM,CAACC,MAAP,CAAcL,IAAI,CAACE,cAAnB,EAAmCJ,OAAO,CAACI,cAA3C;IACAE,MAAM,CAACC,MAAP,CAAcL,IAAI,CAACG,eAAnB,EAAoCL,OAAO,CAACK,eAA5C;EACH;AAxBiB,CAAtB;eA2BeG,G"}

package/operators/logical/or.d.ts

@@ -0,0 +1,3 @@
+import { Operator } from "../../types";
+declare const or: Operator;
+export default or;

package/operators/logical/or.js

@@ -0,0 +1,63 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+const processQuery = (query, orArgs, processStatement) => {
+  const args = {
+    expression: "",
+    attributeNames: {},
+    attributeValues: {}
+  };
+  processStatement({
+    args,
+    query
+  });
+  Object.assign(orArgs.attributeNames, args.attributeNames);
+  Object.assign(orArgs.attributeValues, args.attributeValues);
+
+  if (orArgs.expression === "") {
+    orArgs.expression = args.expression;
+  } else {
+    orArgs.expression += " or " + args.expression;
+  }
+};
+
+const or = {
+  canProcess: ({
+    key
+  }) => {
+    return key === "$or";
+  },
+  process: ({
+    value,
+    args,
+    processStatement
+  }) => {
+    const orArgs = {
+      expression: "",
+      attributeNames: {},
+      attributeValues: {}
+    };
+
+    if (Array.isArray(value)) {
+      for (let i = 0; i < value.length; i++) {
+        processQuery(value[i], orArgs, processStatement);
+      }
+    } else {
+      for (const [orKey, orValue] of Object.entries(value)) {
+        processQuery({
+          [orKey]: orValue
+        }, orArgs, processStatement);
+      }
+    }
+
+    args.expression += "(" + orArgs.expression + ")";
+    Object.assign(args.attributeNames, orArgs.attributeNames);
+    Object.assign(args.attributeValues, orArgs.attributeValues);
+  }
+};
+var _default = or;
+exports.default = _default;