@webiny/db-dynamodb 0.0.0-mt-1

package/utils/documentClient.d.ts

@@ -0,0 +1,8 @@
+import { DocumentClient } from "aws-sdk/clients/dynamodb";
+import { DbContext } from "@webiny/handler-db/types";
+/**
+ * Will be removed in favor of directly passing the documentClient to the storage operations.
+ *
+ * @deprecated
+ */
+export declare const getDocumentClient: <T extends DbContext>(context: T) => DocumentClient;

package/utils/documentClient.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getDocumentClient = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+/**
+ * Will be removed in favor of directly passing the documentClient to the storage operations.
+ *
+ * @deprecated
+ */
+const getDocumentClient = context => {
+  if (!context.db) {
+    throw new _error.default("Missing db on context.", "DB_ERROR");
+  } else if (!context.db.driver) {
+    throw new _error.default(`Missing driver on the context.db property.`, "DRIVER_ERROR");
+  }
+
+  const driver = context.db.driver;
+
+  if (!driver.documentClient) {
+    throw new _error.default(`Missing documentClient on the context.db.driver property.`, "DOCUMENT_CLIENT_ERROR");
+  }
+
+  return driver.documentClient;
+};
+
+exports.getDocumentClient = getDocumentClient;

package/utils/filter.d.ts

@@ -0,0 +1,12 @@
+import { PluginsContainer } from "@webiny/plugins";
+import { FieldPlugin } from "../plugins/definitions/FieldPlugin";
+export interface Params<T extends any = any> {
+    plugins: PluginsContainer;
+    items: T[];
+    where: Record<string, any>;
+    /**
+     * An array of fields that require some special operation.
+     */
+    fields: FieldPlugin[];
+}
+export declare const filterItems: <T extends unknown = any>(params: Params<T>) => T[];

package/utils/filter.js

@@ -0,0 +1,212 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterItems = void 0;
+
+var _dotProp = _interopRequireDefault(require("dot-prop"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _ValueFilterPlugin = require("../plugins/definitions/ValueFilterPlugin");
+
+const getMappedPlugins = params => {
+  return params.plugins.byType(params.type).reduce((plugins, plugin) => {
+    const op = plugin[params.property];
+    plugins[op] = plugin;
+    return plugins;
+  }, {});
+};
+
+const extractWhereArgs = key => {
+  const result = key.split("_");
+  const field = result.shift();
+  const rawOp = result.length === 0 ? "eq" : result.join("_");
+  /**
+   * When rawOp is not, it means it is equal negated so just return that.
+   */
+
+  if (rawOp === "not") {
+    return {
+      field,
+      operation: "eq",
+      negate: true
+    };
+  }
+
+  const negate = rawOp.match("not_") !== null;
+  const operation = rawOp.replace("not_", "");
+  return {
+    field,
+    operation,
+    negate
+  };
+};
+
+const findFilterPlugin = (plugins, operation) => {
+  if (plugins[operation]) {
+    return plugins[operation];
+  }
+
+  throw new _error.default(`Missing filter plugin definition.`, "FILTER_PLUGIN_ERROR", {
+    operation
+  });
+};
+
+const multiSearchFieldOperations = ["contains", "fuzzy"];
+
+const createFilters = params => {
+  const {
+    plugins,
+    where,
+    fields
+  } = params;
+  const keys = Object.keys(where);
+  /**
+   * Skip everything if there are no conditions to be applied.
+   */
+
+  if (keys.length === 0) {
+    return [];
+  }
+
+  const filterPlugins = getMappedPlugins({
+    plugins,
+    type: _ValueFilterPlugin.ValueFilterPlugin.type,
+    property: "operation"
+  });
+  return keys.reduce((filters, key) => {
+    const compareValue = where[key];
+
+    if (compareValue === undefined) {
+      return filters;
+    }
+    /**
+     * @see DynamoDbContainsFilter
+     */
+
+
+    if (multiSearchFieldOperations.includes(key) === true) {
+      const data = compareValue;
+      let transformValue = undefined;
+      const paths = data.fields.map(field => {
+        const fieldPlugin = fields.find(plugin => plugin.getField() === field);
+
+        if (fieldPlugin) {
+          transformValue = value => {
+            return fieldPlugin.transformValue(value);
+          };
+
+          return fieldPlugin.getPath();
+        }
+
+        return field;
+      });
+      filters.push({
+        compareValue: data.value,
+        filterPlugin: findFilterPlugin(filterPlugins, key),
+        transformValue,
+        paths,
+        negate: false
+      });
+      return filters;
+    }
+
+    const {
+      field,
+      operation,
+      negate
+    } = extractWhereArgs(key);
+    const filterPlugin = findFilterPlugin(filterPlugins, operation);
+    const fieldPlugin = fields.find(plugin => plugin.getField() === field);
+    let path = field;
+    let transformValue = undefined;
+
+    if (fieldPlugin) {
+      transformValue = value => {
+        return fieldPlugin.transformValue(value);
+      };
+
+      path = fieldPlugin.getPath();
+    }
+
+    filters.push({
+      compareValue,
+      filterPlugin,
+      transformValue,
+      paths: [path],
+      negate
+    });
+    return filters;
+  }, []);
+};
+/**
+ * Transforms the value with given transformer callable.
+ */
+
+
+const transform = (value, transformValue) => {
+  if (!transformValue) {
+    return value;
+  }
+
+  if (Array.isArray(value)) {
+    return value.map(v => transformValue(v));
+  }
+
+  return transformValue(value);
+};
+/**
+ * Creates a filter callable that we can send to the .filter() method of the array.
+ */
+
+
+const createFilterCallable = params => {
+  const filters = createFilters(params);
+  /**
+   * Just return null so there are no filters to be applied.
+   * Later in the code we check for null so we do not loop through the items.
+   */
+
+  if (filters.length === 0) {
+    return null;
+  }
+
+  return item => {
+    for (const filter of filters) {
+      const result = filter.paths.some(path => {
+        const value = transform(_dotProp.default.get(item, path), filter.transformValue);
+        const compareValue = transform(filter.compareValue, filter.transformValue);
+        const matched = filter.filterPlugin.matches({
+          value,
+          compareValue
+        });
+        return filter.negate ? !matched : matched;
+      });
+
+      if (result === false) {
+        return false;
+      }
+    }
+
+    return true;
+  };
+};
+
+const filterItems = params => {
+  const filter = createFilterCallable(params);
+  /**
+   * No point in going through all the items when there are no filters to be applied.
+   */
+
+  if (!filter) {
+    return params.items;
+  }
+
+  return params.items.filter(filter);
+};
+
+exports.filterItems = filterItems;

package/utils/get.d.ts

@@ -0,0 +1,17 @@
+import { Entity } from "dynamodb-toolbox";
+export interface Params {
+    entity: Entity<any>;
+    keys: {
+        PK: string;
+        SK: string;
+    };
+}
+/**
+ * Gets a single record from the DynamoDB table.
+ * Returns either record or null.
+ *
+ * Be aware to wrap in try/catch to avoid the error killing your app.
+ *
+ * @throws
+ */
+export declare const get: <T>(params: Params) => Promise<T>;

package/utils/get.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.get = void 0;
+
+/**
+ * Gets a single record from the DynamoDB table.
+ * Returns either record or null.
+ *
+ * Be aware to wrap in try/catch to avoid the error killing your app.
+ *
+ * @throws
+ */
+const get = async params => {
+  const {
+    entity,
+    keys
+  } = params;
+  const result = await entity.get(keys);
+
+  if (!result || !result.Item) {
+    return null;
+  }
+
+  return result.Item;
+};
+
+exports.get = get;

package/utils/listResponse.d.ts

@@ -0,0 +1,13 @@
+interface MetaResponse {
+    cursor: string | null;
+    totalCount: number;
+    hasMoreItems: boolean;
+}
+interface CreateListResponseParams<T> {
+    items: T[];
+    after?: string | null;
+    totalCount: number;
+    limit: number;
+}
+export declare const createListResponse: <T>(params: CreateListResponseParams<T>) => [T[], MetaResponse];
+export {};

package/utils/listResponse.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createListResponse = void 0;
+
+var _cursor = require("./cursor");
+
+const createListResponse = params => {
+  const {
+    items: initialItems,
+    after,
+    totalCount,
+    limit
+  } = params;
+  const start = (0, _cursor.decodeCursor)(after) || 0;
+  const hasMoreItems = totalCount > start + limit;
+  const end = limit > totalCount + start + limit ? undefined : start + limit;
+  const items = end ? initialItems.slice(start, end) : initialItems;
+  const cursor = items.length > 0 ? (0, _cursor.encodeCursor)(start + limit) : null;
+  const meta = {
+    hasMoreItems,
+    totalCount,
+    cursor
+  };
+  return [items, meta];
+};
+
+exports.createListResponse = createListResponse;

package/utils/query.d.ts

@@ -0,0 +1,33 @@
+import { queryOptions as DynamoDBToolboxQueryOptions } from "dynamodb-toolbox/dist/classes/Table";
+import { Entity } from "dynamodb-toolbox";
+export interface QueryAllParams {
+    entity: Entity<any>;
+    partitionKey: string;
+    options?: DynamoDBToolboxQueryOptions;
+}
+export interface QueryOneParams extends QueryAllParams {
+    options?: Omit<DynamoDBToolboxQueryOptions, "limit">;
+}
+export interface QueryParams extends QueryAllParams {
+    previous?: any;
+}
+export interface QueryResult<T> {
+    result: any | null;
+    items: T[];
+}
+declare type DbItem<T> = T & {
+    PK: string;
+    SK: string;
+    TYPE: string;
+    GSI1_PK?: string;
+    GSI1_SK?: string;
+};
+/**
+ * Will run the query to fetch the first possible item from the database.
+ */
+export declare const queryOne: <T>(params: QueryOneParams) => Promise<DbItem<T>>;
+/**
+ * Will run the query to fetch the results no matter how much iterations it needs to go through.
+ */
+export declare const queryAll: <T>(params: QueryAllParams) => Promise<DbItem<T>[]>;
+export {};

package/utils/query.js

@@ -0,0 +1,127 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.queryOne = exports.queryAll = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+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 run query only once. Pass the previous to run the query again to fetch new data.
+ * It returns the result and the items it found.
+ * Result is required to fetch the items that were not fetched in the previous run.
+ */
+const query = async params => {
+  const {
+    entity,
+    previous,
+    partitionKey,
+    options
+  } = params;
+  let result;
+  /**
+   * In case there is no previous result we must make a new query.
+   * This is the first query on the given partition key.
+   */
+
+  if (!previous) {
+    result = await entity.query(partitionKey, options);
+  } else if (typeof previous.next === "function") {
+    /**
+     * In case we have a previous result and it has a next method, we run it.
+     * In case result of the next method is false, it means it has nothing else to read
+     * and we return a null to keep the query from repeating.
+     */
+    result = await previous.next();
+
+    if (result === false) {
+      return {
+        result: null,
+        items: []
+      };
+    }
+  } else {
+    /**
+     * This could probably never happen but keep it here just in case to break the query loop.
+     * Basically, either previous does not exist or it exists and it does not have the next method
+     * and at that point a result returned will be null and loop should not start again.
+     */
+    return {
+      result: null,
+      items: []
+    };
+  }
+  /**
+   * We expect the result to contain an Items array and if not, something went wrong, very wrong.
+   */
+
+
+  if (!result || !result.Items || !Array.isArray(result.Items)) {
+    throw new _error.default("Error when querying for content entries - no result.", "QUERY_ERROR", {
+      partitionKey,
+      options
+    });
+  }
+
+  return {
+    result,
+    items: result.Items
+  };
+};
+/**
+ * Will run the query to fetch the first possible item from the database.
+ */
+
+
+const queryOne = async params => {
+  const {
+    items
+  } = await query(_objectSpread(_objectSpread({}, params), {}, {
+    options: _objectSpread(_objectSpread({}, params.options || {}), {}, {
+      limit: 1
+    })
+  }));
+
+  if (items.length === 0) {
+    return null;
+  }
+
+  return items.shift();
+};
+/**
+ * Will run the query to fetch the results no matter how much iterations it needs to go through.
+ */
+
+
+exports.queryOne = queryOne;
+
+const queryAll = async params => {
+  const items = [];
+  let results;
+  let previousResult = undefined;
+
+  while (results = await query(_objectSpread(_objectSpread({}, params), {}, {
+    previous: previousResult
+  }))) {
+    items.push(...results.items);
+
+    if (!results.result) {
+      return items;
+    }
+
+    previousResult = results.result;
+  }
+
+  return items;
+};
+
+exports.queryAll = queryAll;

package/utils/sort.d.ts

@@ -0,0 +1,17 @@
+import { FieldPlugin } from "../plugins/definitions/FieldPlugin";
+interface Params<T> {
+    /**
+     * The items we are sorting.
+     */
+    items: T[];
+    /**
+     * Sort options. For example: ["id_ASC"]
+     */
+    sort: string[];
+    /**
+     * Fields we can sort by.
+     */
+    fields?: FieldPlugin[];
+}
+export declare const sortItems: <T extends unknown = any>(params: Params<T>) => T[];
+export {};

package/utils/sort.js

@@ -0,0 +1,93 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.sortItems = void 0;
+
+var _orderBy = _interopRequireDefault(require("lodash/orderBy"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const extractSort = (sortBy, fields) => {
+  const result = sortBy.split("_");
+
+  if (result.length !== 2) {
+    throw new _error.default("Problem in determining the sorting for the entry items.", "SORT_ERROR", {
+      sortBy
+    });
+  }
+
+  const [field, order] = result;
+
+  if (!field) {
+    throw new _error.default("Sorting field does not exist.", "SORTING_FIELD_ERROR", {
+      field,
+      order,
+      fields
+    });
+  }
+
+  const fieldPlugin = fields.find(f => f.getField() === field);
+  const isSortable = fieldPlugin ? fieldPlugin.isSortable() : true;
+
+  if (isSortable === false) {
+    throw new _error.default(`Cannot sort by given field: "${field}".`, "UNSUPPORTED_SORT_ERROR", {
+      fields,
+      field
+    });
+  }
+
+  return {
+    field,
+    reverse: order.toUpperCase() === "DESC"
+  };
+};
+
+const sortItems = params => {
+  const {
+    items,
+    sort: initialSort = [],
+    fields = []
+  } = params;
+  /**
+   * Skip sorting if nothing was passed to sort by or nothing to sort.
+   */
+
+  if (items.length <= 1 || Array.isArray(initialSort) === false || initialSort.length === 0) {
+    return items;
+  }
+
+  const info = {
+    sorters: [],
+    orders: []
+  };
+
+  for (const sort of initialSort) {
+    /**
+     * Possibly empty array item was passed.
+     */
+    if (!sort) {
+      continue;
+    }
+
+    const {
+      field,
+      reverse
+    } = extractSort(sort, fields);
+    const fieldPlugin = fields.find(f => f.getField() === field);
+    const path = fieldPlugin ? fieldPlugin.getPath() : field;
+    info.sorters.push(path);
+    info.orders.push(reverse === true ? "desc" : "asc");
+  }
+
+  if (info.sorters.length === 0) {
+    return items;
+  }
+
+  return (0, _orderBy.default)(items, info.sorters, info.orders);
+};
+
+exports.sortItems = sortItems;

package/utils/table.d.ts

@@ -0,0 +1,7 @@
+import { DbContext } from "@webiny/handler-db/types";
+/**
+ * Will be removed in favor of passing the table name directly to the storage operations.
+ *
+ * @deprecated
+ */
+export declare const getTable: <T extends DbContext>(context: T) => string;

package/utils/table.js

@@ -0,0 +1,27 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getTable = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+/**
+ * Will be removed in favor of passing the table name directly to the storage operations.
+ *
+ * @deprecated
+ */
+const getTable = context => {
+  if (!context.db) {
+    throw new _error.default("Missing db on context.", "DB_ERROR");
+  } else if (!context.db.table) {
+    throw new _error.default("Missing table on context.db.", "TABLE_ERROR");
+  }
+
+  return context.db.table;
+};
+
+exports.getTable = getTable;