@webiny/db-dynamodb 0.0.0-mt-1

package/plugins/filters/eq.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ValueFilterPlugin = require("../definitions/ValueFilterPlugin");
+
+var _default = new _ValueFilterPlugin.ValueFilterPlugin({
+  operation: "eq",
+  matches: ({
+    value,
+    compareValue
+  }) => {
+    return value === compareValue;
+  }
+});
+
+exports.default = _default;

package/plugins/filters/fuzzy.d.ts

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

package/plugins/filters/fuzzy.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _fuse = _interopRequireDefault(require("fuse.js"));
+
+var _ValueFilterPlugin = require("../definitions/ValueFilterPlugin");
+
+var _default = new _ValueFilterPlugin.ValueFilterPlugin({
+  operation: "fuzzy",
+  matches: ({
+    value,
+    compareValue
+  }) => {
+    if (typeof value !== "string") {
+      return false;
+    }
+
+    const f = new _fuse.default([value], {});
+    const result = f.search(compareValue);
+    return result.length > 0;
+  }
+});
+
+exports.default = _default;

package/plugins/filters/gt.d.ts

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

package/plugins/filters/gt.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ValueFilterPlugin = require("../definitions/ValueFilterPlugin");
+
+var _default = new _ValueFilterPlugin.ValueFilterPlugin({
+  operation: "gt",
+  matches: ({
+    value,
+    compareValue
+  }) => {
+    return value > compareValue;
+  }
+});
+
+exports.default = _default;

package/plugins/filters/gte.d.ts

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

package/plugins/filters/gte.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ValueFilterPlugin = require("../definitions/ValueFilterPlugin");
+
+var _default = new _ValueFilterPlugin.ValueFilterPlugin({
+  operation: "gte",
+  matches: ({
+    value,
+    compareValue
+  }) => {
+    return value >= compareValue;
+  }
+});
+
+exports.default = _default;

package/plugins/filters/in.d.ts

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

package/plugins/filters/in.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ValueFilterPlugin = require("../definitions/ValueFilterPlugin");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _default = new _ValueFilterPlugin.ValueFilterPlugin({
+  operation: "in",
+  matches: ({
+    value,
+    compareValue
+  }) => {
+    if (!compareValue || Array.isArray(compareValue) === false) {
+      throw new _error.default(`The value given as "compareValue" must be an array!`, "COMPARE_VALUE_ERROR", {
+        value,
+        compareValue
+      });
+    }
+
+    if (Array.isArray(value) === true) {
+      return compareValue.some(c => value.includes(c));
+    }
+
+    return compareValue.includes(value);
+  }
+});
+
+exports.default = _default;

package/plugins/filters/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("../definitions/ValueFilterPlugin").ValueFilterPlugin[];
+export default _default;

package/plugins/filters/index.js

@@ -0,0 +1,32 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _eq = _interopRequireDefault(require("./eq"));
+
+var _between = _interopRequireDefault(require("./between"));
+
+var _andIn = _interopRequireDefault(require("./andIn"));
+
+var _in = _interopRequireDefault(require("./in"));
+
+var _gt = _interopRequireDefault(require("./gt"));
+
+var _gte = _interopRequireDefault(require("./gte"));
+
+var _lt = _interopRequireDefault(require("./lt"));
+
+var _lte = _interopRequireDefault(require("./lte"));
+
+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];
+
+exports.default = _default;

package/plugins/filters/lt.d.ts

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

package/plugins/filters/lt.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ValueFilterPlugin = require("../definitions/ValueFilterPlugin");
+
+var _default = new _ValueFilterPlugin.ValueFilterPlugin({
+  operation: "lt",
+  matches: ({
+    value,
+    compareValue
+  }) => {
+    return value < compareValue;
+  }
+});
+
+exports.default = _default;

package/plugins/filters/lte.d.ts

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

package/plugins/filters/lte.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ValueFilterPlugin = require("../definitions/ValueFilterPlugin");
+
+var _default = new _ValueFilterPlugin.ValueFilterPlugin({
+  operation: "lte",
+  matches: ({
+    value,
+    compareValue
+  }) => {
+    return value <= compareValue;
+  }
+});
+
+exports.default = _default;

package/plugins/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => import("./definitions/ValueFilterPlugin").ValueFilterPlugin[][];
+export default _default;

package/plugins/index.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _filters = _interopRequireDefault(require("./filters"));
+
+/**
+ * List everything that needs to be loaded by default.
+ */
+var _default = () => {
+  return [(0, _filters.default)()];
+};
+
+exports.default = _default;

package/statements/createKeyConditionExpressionArgs.d.ts

@@ -0,0 +1,12 @@
+declare const _default: ({ query, sort, key }: {
+    query: any;
+    sort: any;
+    key: any;
+}) => {
+    KeyConditionExpression: string;
+    ExpressionAttributeNames: {};
+    ExpressionAttributeValues: {};
+    ScanIndexForward: boolean;
+    IndexName: any;
+};
+export default _default;

package/statements/createKeyConditionExpressionArgs.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _processStatement = _interopRequireDefault(require("./processStatement"));
+
+var _default = ({
+  query,
+  sort,
+  key
+}) => {
+  const args = {
+    expression: "",
+    attributeNames: {},
+    attributeValues: {}
+  };
+  (0, _processStatement.default)({
+    args,
+    query: {
+      $and: query
+    }
+  });
+  const output = {
+    KeyConditionExpression: args.expression,
+    ExpressionAttributeNames: args.attributeNames,
+    ExpressionAttributeValues: args.attributeValues,
+    ScanIndexForward: true,
+    IndexName: null
+  };
+  const sortKey = key.fields && key.fields[1];
+
+  if (sort && sort[sortKey.name] === -1) {
+    output.ScanIndexForward = false;
+  }
+
+  if (!key.primary) {
+    output.IndexName = key.name;
+  }
+
+  return output;
+};
+
+exports.default = _default;

package/statements/processStatement.d.ts

@@ -0,0 +1,4 @@
+export default function processStatement({ args, query }: {
+    args: any;
+    query: any;
+}): void;

package/statements/processStatement.js

@@ -0,0 +1,39 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = processStatement;
+
+var _operators = _interopRequireDefault(require("./../operators"));
+
+function processStatement({
+  args,
+  query
+}) {
+  outerLoop: for (const [key, value] of Object.entries(query)) {
+    const operators = Object.values(_operators.default);
+
+    for (let i = 0; i < operators.length; i++) {
+      const operator = operators[i];
+
+      if (operator.canProcess({
+        key,
+        value,
+        args
+      })) {
+        operator.process({
+          key,
+          value,
+          args,
+          processStatement
+        });
+        continue outerLoop;
+      }
+    }
+
+    throw new Error(`Invalid operator {${key} : ${value}}.`);
+  }
+}

package/types.d.ts

@@ -0,0 +1,29 @@
+export declare type OperatorArgs = {
+    expression: string;
+    attributeNames: Record<string, any>;
+    attributeValues: Record<string, any>;
+};
+declare type CanProcessArgs = {
+    key: string;
+    value: any;
+    args: OperatorArgs;
+};
+declare type ProcessArgs = {
+    key: string;
+    value: any;
+    args: OperatorArgs;
+    processStatement: any;
+};
+export declare type 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.
+ */
+export interface DynamoDbContainsFilter {
+    fields: string[];
+    value: string;
+}
+export {};

package/types.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/utils/attributes.d.ts

@@ -0,0 +1,10 @@
+import { ContextInterface } from "@webiny/handler/types";
+import { DefinitionParams } from "../plugins/definitions/AttributePlugin";
+import { PluginsContainer } from "@webiny/plugins";
+/**
+ * Will be removed in favor of directly assigning attributes to a certain entity when creating the storage operations.
+ *
+ * @deprecated
+ */
+export declare const getExtraAttributes: (context: ContextInterface, entity: string) => Record<string, DefinitionParams>;
+export declare const getExtraAttributesFromPlugins: (plugins: PluginsContainer, entity: string) => Record<string, DefinitionParams>;

package/utils/attributes.js

@@ -0,0 +1,35 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtraAttributesFromPlugins = exports.getExtraAttributes = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+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 _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; }
+
+/**
+ * Will be removed in favor of directly assigning attributes to a certain entity when creating the storage operations.
+ *
+ * @deprecated
+ */
+const getExtraAttributes = (context, entity) => {
+  return getExtraAttributesFromPlugins(context.plugins, entity);
+};
+
+exports.getExtraAttributes = getExtraAttributes;
+
+const getExtraAttributesFromPlugins = (plugins, entity) => {
+  return plugins.byType(_AttributePlugin.AttributePlugin.type).filter(plugin => plugin.entity === entity).reduce((attributes, plugin) => {
+    return _objectSpread(_objectSpread({}, attributes), plugin.getDefinition());
+  }, {});
+};
+
+exports.getExtraAttributesFromPlugins = getExtraAttributesFromPlugins;

package/utils/batchRead.d.ts

@@ -0,0 +1,15 @@
+import { Table } from "dynamodb-toolbox";
+interface Item {
+    Table: Table;
+    Key: any;
+}
+interface Params {
+    table: Table;
+    items: Item[];
+}
+/**
+ * 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 {};

package/utils/batchRead.js

@@ -0,0 +1,58 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.batchReadAll = void 0;
+
+const flatten = responses => {
+  const entries = [];
+  const values = Object.values(responses);
+
+  for (const items of values) {
+    entries.push(...items);
+  }
+
+  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 batchReadAll = async params => {
+  if (params.items.length === 0) {
+    return [];
+  }
+
+  const items = [];
+  const result = await params.table.batchGet(params.items);
+
+  if (result.Responses) {
+    items.push(...flatten(result.Responses));
+  }
+
+  if (typeof result.next === "function") {
+    let previous = result;
+    let nextResult;
+
+    while (nextResult = await previous.next()) {
+      if (!nextResult) {
+        return items;
+      }
+
+      items.push(...flatten(nextResult.Responses));
+
+      if (!nextResult || typeof nextResult.next !== "function") {
+        return items;
+      }
+
+      previous = nextResult;
+    }
+  }
+
+  return items;
+};
+
+exports.batchReadAll = batchReadAll;

package/utils/batchWrite.d.ts

@@ -0,0 +1,17 @@
+import { Table } from "dynamodb-toolbox";
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
+interface Item {
+    [key: string]: DocumentClient.WriteRequest;
+}
+interface Params {
+    table: Table;
+    items: Item[];
+}
+/**
+ * Method is meant for batch writing to a single table.
+ * It expects already prepared items for the write.
+ * It can either delete or put items
+ * The method does not check items before actually sending them into the underlying library.
+ */
+export declare const batchWriteAll: (params: Params, maxChunk?: number) => Promise<void>;
+export {};

package/utils/batchWrite.js

@@ -0,0 +1,30 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.batchWriteAll = void 0;
+
+var _chunk = _interopRequireDefault(require("lodash/chunk"));
+
+/**
+ * Method is meant for batch writing to a single table.
+ * It expects already prepared items for the write.
+ * It can either delete or put items
+ * The method does not check items before actually sending them into the underlying library.
+ */
+const batchWriteAll = async (params, maxChunk = 25) => {
+  if (params.items.length === 0) {
+    return;
+  }
+
+  const chunkedItems = (0, _chunk.default)(params.items, maxChunk);
+
+  for (const items of chunkedItems) {
+    await params.table.batchWrite(items);
+  }
+};
+
+exports.batchWriteAll = batchWriteAll;

package/utils/cleanup.d.ts

@@ -0,0 +1,3 @@
+import { Entity } from "dynamodb-toolbox";
+export declare const cleanupItem: <T>(entity: Entity<any>, item?: T & Record<string, any>, removeAttributes?: string[]) => T;
+export declare const cleanupItems: <T>(entity: Entity<any>, items: (T & Record<string, any>)[], removeAttributes?: string[]) => T[];

package/utils/cleanup.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanupItems = exports.cleanupItem = 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; }
+
+/**
+ * The attributes defined by us or the dynamodb-toolbox library.
+ * Add more attributes if necessary.
+ */
+const attributesToRemove = ["PK", "SK", "created", "_ct", "modified", "_mt", "entity", "_et", "GSI1_PK", "GSI1_SK", "TYPE"];
+
+const cleanupItem = (entity, item, removeAttributes = []) => {
+  if (!item) {
+    return null;
+  }
+
+  const newItem = _objectSpread({}, item);
+
+  const targets = attributesToRemove.concat(removeAttributes);
+  const attributes = entity.schema.attributes;
+
+  for (const key in item) {
+    if (item.hasOwnProperty(key) === false) {
+      continue;
+    }
+
+    if (attributes[key] && targets.includes(key) === false) {
+      continue;
+    }
+
+    delete newItem[key];
+  }
+
+  return newItem;
+};
+
+exports.cleanupItem = cleanupItem;
+
+const cleanupItems = (entity, items, removeAttributes = []) => {
+  return items.map(item => cleanupItem(entity, item, removeAttributes));
+};
+
+exports.cleanupItems = cleanupItems;

package/utils/cursor.d.ts

@@ -0,0 +1,2 @@
+export declare const encodeCursor: (cursor?: any) => string;
+export declare const decodeCursor: (cursor?: string) => any;

package/utils/cursor.js

@@ -0,0 +1,26 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.encodeCursor = exports.decodeCursor = void 0;
+
+const encodeCursor = cursor => {
+  if (!cursor) {
+    return null;
+  }
+
+  return Buffer.from(JSON.stringify(cursor)).toString("base64");
+};
+
+exports.encodeCursor = encodeCursor;
+
+const decodeCursor = cursor => {
+  if (!cursor) {
+    return null;
+  }
+
+  return JSON.parse(Buffer.from(cursor, "base64").toString("ascii"));
+};
+
+exports.decodeCursor = decodeCursor;