@webiny/db-dynamodb 0.0.0-mt-1

package/BatchProcess.d.ts

@@ -0,0 +1,31 @@
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
+import { Batch } from "@webiny/db";
+declare type BatchType = "batchWrite" | "batchGet";
+declare class BatchProcess {
+    documentClient: DocumentClient;
+    batch: Batch;
+    resolveBuild: () => void;
+    rejectBuild: ({ message: string }: {
+        message: any;
+    }) => void;
+    queryBuild: Promise<void>;
+    resolveExecution: () => void;
+    rejectExecution: ({ message: string }: {
+        message: any;
+    }) => void;
+    queryExecution: Promise<void>;
+    operations: [Record<string, any>, Record<string, any>][];
+    batchType: BatchType;
+    results: Record<string, any>[];
+    response: Record<string, any>;
+    constructor(batch: Batch, documentClient: DocumentClient);
+    waitStartExecution(): Promise<void>;
+    waitExecution(): Promise<void>;
+    addBatchOperation(type: BatchType, args: any, meta?: {}): () => any;
+    addBatchWrite(args: any): () => any;
+    addBatchDelete(args: any): () => any;
+    addBatchGet(args: any): () => any;
+    allOperationsAdded(): boolean;
+    startExecution(): import("aws-sdk/lib/request").Request<DocumentClient.BatchWriteItemOutput, import("aws-sdk/lib/error").AWSError> | import("aws-sdk/lib/request").Request<DocumentClient.BatchGetItemOutput, import("aws-sdk/lib/error").AWSError>;
+}
+export default BatchProcess;

package/BatchProcess.js

@@ -0,0 +1,196 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+class BatchProcess {
+  constructor(batch, documentClient) {
+    (0, _defineProperty2.default)(this, "documentClient", void 0);
+    (0, _defineProperty2.default)(this, "batch", void 0);
+    (0, _defineProperty2.default)(this, "resolveBuild", void 0);
+    (0, _defineProperty2.default)(this, "rejectBuild", void 0);
+    (0, _defineProperty2.default)(this, "queryBuild", void 0);
+    (0, _defineProperty2.default)(this, "resolveExecution", void 0);
+    (0, _defineProperty2.default)(this, "rejectExecution", void 0);
+    (0, _defineProperty2.default)(this, "queryExecution", void 0);
+    (0, _defineProperty2.default)(this, "operations", void 0);
+    (0, _defineProperty2.default)(this, "batchType", void 0);
+    (0, _defineProperty2.default)(this, "results", void 0);
+    (0, _defineProperty2.default)(this, "response", void 0);
+    this.documentClient = documentClient;
+    this.batch = batch;
+    this.resolveBuild = null;
+    this.rejectBuild = null;
+    this.queryBuild = new Promise((resolve, reject) => {
+      this.resolveBuild = resolve;
+      this.rejectBuild = reject;
+    });
+    this.resolveExecution = null;
+    this.rejectExecution = null;
+    this.queryExecution = new Promise((resolve, reject) => {
+      this.resolveExecution = resolve;
+      this.rejectExecution = reject;
+    });
+    this.operations = [];
+    this.results = [];
+    this.response = [];
+    this.batchType;
+  }
+
+  waitStartExecution() {
+    return this.queryBuild;
+  }
+
+  waitExecution() {
+    return this.queryExecution;
+  }
+
+  addBatchOperation(type, args, meta = {}) {
+    if (!this.batchType) {
+      this.batchType = type;
+    } else if (this.batchType !== type) {
+      const initial = this.batchType;
+      const index = this.operations.length;
+      this.rejectBuild({
+        message: `Cannot batch operations - all operations must be of the same type (the initial operation type was "${initial}", and operation type on index "${index}" is "${type}").`
+      });
+      return;
+    }
+
+    this.operations.push([args, meta]);
+    const index = this.operations.length - 1;
+    return () => this.results[index];
+  }
+
+  addBatchWrite(args) {
+    return this.addBatchOperation("batchWrite", args);
+  }
+
+  addBatchDelete(args) {
+    return this.addBatchOperation("batchWrite", _objectSpread({}, args), {
+      delete: true
+    });
+  }
+
+  addBatchGet(args) {
+    return this.addBatchOperation("batchGet", args);
+  }
+
+  allOperationsAdded() {
+    return this.operations.length === this.batch.operations.length;
+  }
+
+  startExecution() {
+    this.resolveBuild();
+    const documentClientArgs = {
+      ReturnConsumedCapacity: "TOTAL",
+      RequestItems: {}
+    };
+
+    const reject = e => {
+      e.message = `An error occurred while executing "${this.batchType}" batch operation: ${e.message}`;
+      return this.rejectExecution(e);
+    };
+
+    let resolve = response => {
+      this.response = response;
+      this.resolveExecution();
+    };
+
+    switch (this.batchType) {
+      case "batchWrite":
+        documentClientArgs.RequestItems = {};
+
+        for (let i = 0; i < this.operations.length; i++) {
+          const [args, meta] = this.operations[i];
+
+          if (!documentClientArgs.RequestItems[args.table]) {
+            documentClientArgs.RequestItems[args.table] = [];
+          }
+
+          const push = {};
+
+          if (meta.delete) {
+            push.DeleteRequest = {
+              Key: args.query
+            };
+          } else {
+            push.PutRequest = {
+              Item: args.data
+            };
+          }
+
+          documentClientArgs.RequestItems[args.table].push(push);
+        }
+
+        break;
+
+      case "batchGet":
+        documentClientArgs.RequestItems = {};
+
+        for (let i = 0; i < this.operations.length; i++) {
+          const [args] = this.operations[i];
+
+          if (!documentClientArgs.RequestItems[args.table]) {
+            documentClientArgs.RequestItems[args.table] = {
+              Keys: []
+            };
+          }
+
+          documentClientArgs.RequestItems[args.table].Keys.push(args.query);
+        }
+
+        resolve = response => {
+          this.response = response;
+          const results = []; // The results of batchGet aren't ordered so we have to figure out the order of results ourselves.
+
+          for (let i = 0; i < this.operations.length; i++) {
+            const [args] = this.operations[i];
+            const responseItems = response.Responses[args.table];
+            let foundResult = null;
+
+            outer: for (let j = 0; j < responseItems.length; j++) {
+              const responseItem = responseItems[j];
+
+              for (const queryKey in args.query) {
+                if (typeof responseItem[queryKey] === "undefined" || args.query[queryKey] !== responseItem[queryKey]) {
+                  continue outer;
+                }
+              }
+
+              foundResult = responseItem;
+            }
+
+            results.push(foundResult);
+          }
+
+          this.results = results;
+          this.resolveExecution();
+        };
+
+        break;
+    }
+
+    return this.documentClient[this.batchType](documentClientArgs, (error, result) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(result);
+      }
+    });
+  }
+
+}
+
+var _default = BatchProcess;
+exports.default = _default;

package/DynamoDbDriver.d.ts

@@ -0,0 +1,27 @@
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
+import BatchProcess from "./BatchProcess";
+import { DbDriver, Args, Result } from "@webiny/db";
+declare type ConstructorArgs = {
+    documentClient?: DocumentClient;
+};
+declare class DynamoDbDriver implements DbDriver {
+    batchProcesses: Record<string, BatchProcess>;
+    documentClient: DocumentClient;
+    constructor({ documentClient }?: ConstructorArgs);
+    getClient(): DocumentClient;
+    create({ table, data, meta, __batch: batch }: Args): Promise<Result>;
+    update({ query, data, table, meta, __batch: batch }: Args): Promise<Result>;
+    delete({ query, table, meta, __batch: batch }: Args): Promise<Result>;
+    read<T>({ table, query, sort, limit, keys, meta, __batch: batch }: Args): Promise<Result<T[]>>;
+    createLog({ id, operation, data, table }: {
+        id: any;
+        operation: any;
+        data: any;
+        table: any;
+    }): Promise<Result>;
+    readLogs<T>({ table }: {
+        table: any;
+    }): Promise<Result<T[]>>;
+    getBatchProcess(__batch: any): BatchProcess;
+}
+export default DynamoDbDriver;

package/DynamoDbDriver.js

@@ -0,0 +1,272 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _dynamodb = require("aws-sdk/clients/dynamodb");
+
+var _BatchProcess = _interopRequireDefault(require("./BatchProcess"));
+
+var _QueryGenerator = _interopRequireDefault(require("./QueryGenerator"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const LOG_KEYS = [{
+  primary: true,
+  unique: true,
+  name: "primary",
+  fields: [{
+    name: "PK"
+  }, {
+    name: "SK"
+  }]
+}];
+
+class DynamoDbDriver {
+  constructor({
+    documentClient
+  } = {}) {
+    (0, _defineProperty2.default)(this, "batchProcesses", void 0);
+    (0, _defineProperty2.default)(this, "documentClient", void 0);
+    this.batchProcesses = {};
+    this.documentClient = documentClient || new _dynamodb.DocumentClient();
+  }
+
+  getClient() {
+    return this.documentClient;
+  }
+
+  async create({
+    table,
+    data,
+    meta,
+    __batch: batch
+  }) {
+    if (!batch) {
+      const result = await this.documentClient.put({
+        TableName: table,
+        Item: data,
+        ReturnConsumedCapacity: meta ? "TOTAL" : "NONE"
+      }).promise();
+      return [true, {
+        response: result.$response
+      }];
+    }
+
+    const batchProcess = this.getBatchProcess(batch);
+    batchProcess.addBatchWrite({
+      table,
+      data
+    });
+
+    if (batchProcess.allOperationsAdded()) {
+      batchProcess.startExecution();
+    } else {
+      await batchProcess.waitStartExecution();
+    }
+
+    await batchProcess.waitExecution();
+    return [true, {
+      response: batchProcess.response
+    }];
+  }
+
+  async update({
+    query,
+    data,
+    table,
+    meta,
+    __batch: batch
+  }) {
+    if (!batch) {
+      const update = {
+        UpdateExpression: "SET ",
+        ExpressionAttributeNames: {},
+        ExpressionAttributeValues: {}
+      };
+      const updateExpression = [];
+
+      for (const key in data) {
+        updateExpression.push(`#${key} = :${key}`);
+        update.ExpressionAttributeNames[`#${key}`] = key;
+        update.ExpressionAttributeValues[`:${key}`] = data[key];
+      }
+
+      update.UpdateExpression += updateExpression.join(", ");
+      const result = await this.documentClient.update(_objectSpread({
+        TableName: table,
+        Key: query,
+        ReturnConsumedCapacity: meta ? "TOTAL" : "NONE"
+      }, update)).promise();
+      return [true, {
+        response: result.$response
+      }];
+    }
+
+    const batchProcess = this.getBatchProcess(batch);
+    batchProcess.addBatchWrite({
+      table,
+      data
+    });
+
+    if (batchProcess.allOperationsAdded()) {
+      batchProcess.startExecution();
+    } else {
+      await batchProcess.waitStartExecution();
+    }
+
+    await batchProcess.waitExecution();
+    return [true, {
+      response: batchProcess.response
+    }];
+  }
+
+  async delete({
+    query,
+    table,
+    meta,
+    __batch: batch
+  }) {
+    if (!batch) {
+      const result = await this.documentClient.delete({
+        TableName: table,
+        Key: query,
+        ReturnConsumedCapacity: meta ? "TOTAL" : "NONE"
+      }).promise();
+      return [true, {
+        response: result.$response
+      }];
+    }
+
+    const batchProcess = this.getBatchProcess(batch);
+    batchProcess.addBatchDelete({
+      table,
+      query
+    });
+
+    if (batchProcess.allOperationsAdded()) {
+      batchProcess.startExecution();
+    } else {
+      await batchProcess.waitStartExecution();
+    }
+
+    await batchProcess.waitExecution();
+    return [true, {
+      response: batchProcess.response
+    }];
+  }
+
+  async read({
+    table,
+    query,
+    sort,
+    limit,
+    keys,
+    meta,
+    __batch: batch
+  }) {
+    if (!batch) {
+      const queryGenerator = new _QueryGenerator.default();
+      const queryParams = queryGenerator.generate({
+        query,
+        keys,
+        sort,
+        limit,
+        tableName: table
+      });
+      const response = await this.documentClient.query(_objectSpread(_objectSpread({}, queryParams), {}, {
+        ReturnConsumedCapacity: meta ? "TOTAL" : "NONE"
+      })).promise();
+
+      if (Array.isArray(response.Items)) {
+        return [response.Items, {
+          response: response.$response
+        }];
+      }
+
+      return [[], {
+        response: response.$response
+      }];
+    } // DynamoDb doesn't support batch queries, so we can immediately assume the GetRequest operation.
+
+
+    const batchProcess = this.getBatchProcess(batch);
+    const getResult = batchProcess.addBatchGet({
+      table,
+      query
+    });
+
+    if (batchProcess.allOperationsAdded()) {
+      batchProcess.startExecution();
+    } else {
+      await batchProcess.waitStartExecution();
+    }
+
+    await batchProcess.waitExecution();
+    const result = getResult();
+
+    if (result) {
+      return [[result], {
+        response: batchProcess.response
+      }];
+    }
+
+    return [[], {
+      response: batchProcess.response
+    }];
+  }
+
+  async createLog({
+    id,
+    operation,
+    data,
+    table
+  }) {
+    await this.create({
+      table: table,
+      keys: LOG_KEYS,
+      data: _objectSpread({
+        PK: "log",
+        SK: id,
+        id,
+        operation
+      }, data)
+    });
+    return [true, {}];
+  }
+
+  async readLogs({
+    table
+  }) {
+    return this.read({
+      table,
+      keys: LOG_KEYS,
+      query: {
+        PK: "log",
+        SK: {
+          $gte: " "
+        }
+      }
+    });
+  }
+
+  getBatchProcess(__batch) {
+    if (!this.batchProcesses[__batch.instance.id]) {
+      this.batchProcesses[__batch.instance.id] = new _BatchProcess.default(__batch.instance, this.documentClient);
+    }
+
+    return this.batchProcesses[__batch.instance.id];
+  }
+
+}
+
+var _default = DynamoDbDriver;
+exports.default = _default;

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/QueryGenerator.d.ts

@@ -0,0 +1,19 @@
+declare class QueryGenerator {
+    generate({ query, keys, sort, limit, tableName }: {
+        query: any;
+        keys: any;
+        sort: any;
+        limit: any;
+        tableName: any;
+    }): {
+        TableName: any;
+        Limit: any;
+        KeyConditionExpression: string;
+        ExpressionAttributeNames: {};
+        ExpressionAttributeValues: {};
+        ScanIndexForward: boolean;
+        IndexName: any;
+    };
+    findQueryKey(query?: {}, keys?: any[]): any;
+}
+export default QueryGenerator;

package/QueryGenerator.js

@@ -0,0 +1,79 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _createKeyConditionExpressionArgs = _interopRequireDefault(require("./statements/createKeyConditionExpressionArgs"));
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+class QueryGenerator {
+  generate({
+    query,
+    keys,
+    sort,
+    limit,
+    tableName
+  }) {
+    // 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 = {},
+          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 _objectSpread(_objectSpread({}, 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;
+      }
+    }
+  }
+
+}
+
+var _default = QueryGenerator;
+exports.default = _default;