@webiny/db-dynamodb 0.0.0-mt-1

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");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "DynamoDbDriver", {
+  enumerable: true,
+  get: function () {
+    return _DynamoDbDriver.default;
+  }
+});
+
+var _DynamoDbDriver = _interopRequireDefault(require("./DynamoDbDriver"));

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/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/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/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/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/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/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/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");
+
+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/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/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;

package/package.json

@@ -0,0 +1,45 @@
+{
+	"name": "@webiny/db-dynamodb",
+	"version": "0.0.0-mt-1",
+	"main": "index.js",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git"
+	},
+	"description": "A DynamoDB driver for the @webiny/db database client.",
+	"author": "Webiny Ltd",
+	"license": "MIT",
+	"dependencies": {
+		"@webiny/db": "0.0.0-mt-1",
+		"@webiny/error": "0.0.0-mt-1",
+		"@webiny/handler": "0.0.0-mt-1",
+		"@webiny/handler-db": "0.0.0-mt-1",
+		"@webiny/plugins": "0.0.0-mt-1",
+		"date-fns": "2.25.0",
+		"dot-prop": "6.0.1",
+		"fuse.js": "6.4.6",
+		"is-number": "7.0.0",
+		"lodash": "4.17.21"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.5.5",
+		"@babel/core": "^7.5.5",
+		"@webiny/cli": "^0.0.0-mt-1",
+		"@webiny/project-utils": "^0.0.0-mt-1",
+		"dynamodb-toolbox": "^0.3.4",
+		"jest": "^26.6.3",
+		"jest-dynalite": "^3.2.0",
+		"rimraf": "^3.0.2",
+		"ttypescript": "^1.5.12",
+		"typescript": "^4.1.3"
+	},
+	"publishConfig": {
+		"access": "public",
+		"directory": "dist"
+	},
+	"scripts": {
+		"build": "yarn webiny run build",
+		"watch": "yarn webiny run watch"
+	},
+	"gitHead": "37736d8456a6ecb342a6c3645060bd9a3f2d4bb0"
+}

package/plugins/definitions/AttributePlugin.d.ts

@@ -0,0 +1,20 @@
+import { Plugin } from "@webiny/plugins";
+import { DynamoDBTypes } from "dynamodb-toolbox/dist/classes/Table";
+import { EntityAttributeConfig, EntityCompositeAttributes } from "dynamodb-toolbox/dist/classes/Entity";
+export declare type DefinitionParams = DynamoDBTypes | EntityAttributeConfig | EntityCompositeAttributes;
+export interface Params {
+    entity: string;
+    attribute: string;
+    params: DefinitionParams;
+}
+export declare abstract class AttributePlugin extends Plugin {
+    static readonly type = "db.dynamodb.attribute";
+    private readonly _entity;
+    private readonly _attribute;
+    private readonly _params;
+    get entity(): string;
+    get attribute(): string;
+    constructor({ entity, attribute, params }: Params);
+    getDefinition(): Record<string, DefinitionParams>;
+    private validateReserved;
+}

package/plugins/definitions/AttributePlugin.js

@@ -0,0 +1,61 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AttributePlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const reservedFields = ["PK", "SK", "index", "data"];
+
+class AttributePlugin extends _plugins.Plugin {
+  get entity() {
+    return this._entity;
+  }
+
+  get attribute() {
+    return this._attribute;
+  }
+
+  constructor({
+    entity,
+    attribute,
+    params
+  }) {
+    super();
+    (0, _defineProperty2.default)(this, "_entity", void 0);
+    (0, _defineProperty2.default)(this, "_attribute", void 0);
+    (0, _defineProperty2.default)(this, "_params", void 0);
+    this.validateReserved(attribute);
+    this._entity = entity;
+    this._attribute = attribute;
+    this._params = params;
+  }
+
+  getDefinition() {
+    return {
+      [this.attribute]: this._params
+    };
+  }
+
+  validateReserved(attribute) {
+    if (reservedFields.includes(attribute) === false) {
+      return;
+    }
+
+    throw new _error.default(`Attribute name "${attribute}" is not allowed.`, "ATTRIBUTE_NOT_ALLOWED", {
+      attribute
+    });
+  }
+
+}
+
+exports.AttributePlugin = AttributePlugin;
+(0, _defineProperty2.default)(AttributePlugin, "type", "db.dynamodb.attribute");

package/plugins/definitions/DateTimeTransformPlugin.d.ts

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