@webiny/db-dynamodb 0.0.0-mt-1

package/plugins/definitions/DateTimeTransformPlugin.js

@@ -0,0 +1,54 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DateTimeTransformPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ValueTransformPlugin = require("./ValueTransformPlugin");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _dateFns = require("date-fns");
+
+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 transformDateTime = params => {
+  const {
+    value
+  } = params;
+
+  if (value && typeof value.getTime === "function") {
+    /**
+     * In this case we assume this is a date object and we just get the time.
+     */
+    return value.getTime();
+  }
+
+  const parsedDateTime = (0, _dateFns.parseISO)(value).getTime();
+
+  if (isNaN(parsedDateTime) === false) {
+    return parsedDateTime;
+  }
+
+  throw new _error.default("Could not parse given dateTime value.", "PARSE_DATE_ERROR", {
+    value
+  });
+};
+
+class DateTimeTransformPlugin extends _ValueTransformPlugin.ValueTransformPlugin {
+  constructor(params) {
+    super(_objectSpread({
+      transform: transformDateTime
+    }, params));
+  }
+
+}
+
+exports.DateTimeTransformPlugin = DateTimeTransformPlugin;

package/plugins/definitions/FieldPathPlugin.d.ts

@@ -0,0 +1,22 @@
+import { Plugin } from "@webiny/plugins";
+export interface CreatePath {
+    (field: string): string;
+}
+export interface Params {
+    /**
+     * Which field(s) is this plugin for.
+     */
+    fields: string | string[];
+    /**
+     * Create a path for given field.
+     * Field is passed because it can be a multi-field plugin.
+     */
+    createPath: CreatePath;
+}
+export declare class FieldPathPlugin extends Plugin {
+    static readonly type = "dynamodb.value.path";
+    private readonly _params;
+    constructor(params: Params);
+    canCreate(field: string): boolean;
+    createPath(field: string): string;
+}

package/plugins/definitions/FieldPathPlugin.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FieldPathPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _assignFields = require("./assignFields");
+
+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 FieldPathPlugin extends _plugins.Plugin {
+  constructor(params) {
+    super();
+    (0, _defineProperty2.default)(this, "_params", void 0);
+    this._params = _objectSpread(_objectSpread({}, params), {}, {
+      fields: (0, _assignFields.assignFields)(params.fields)
+    });
+  }
+
+  canCreate(field) {
+    return this._params.fields.includes(field);
+  }
+
+  createPath(field) {
+    if (!this._params.createPath) {
+      throw new _error.default(`Missing "createPath" in the plugin.`, "TRANSFORM_ERROR", {
+        fields: this._params.fields
+      });
+    }
+
+    return this._params.createPath(field);
+  }
+
+}
+
+exports.FieldPathPlugin = FieldPathPlugin;
+(0, _defineProperty2.default)(FieldPathPlugin, "type", "dynamodb.value.path");

package/plugins/definitions/FieldPlugin.d.ts

@@ -0,0 +1,34 @@
+import { Plugin } from "@webiny/plugins";
+import { DynamoDBTypes } from "dynamodb-toolbox/dist/classes/Table";
+export declare type FieldType = DynamoDBTypes & "date" & any;
+export interface TransformValueCb {
+    (value: any): any;
+}
+export interface Params {
+    /**
+     * Default is string.
+     */
+    type?: FieldType;
+    field: string;
+    path?: string;
+    /**
+     * Default is true.
+     */
+    sortable?: boolean;
+    transformValue?: TransformValueCb;
+}
+export declare abstract class FieldPlugin extends Plugin {
+    private readonly path;
+    private readonly field;
+    private readonly fieldType;
+    private readonly dynamoDbType;
+    private readonly sortable;
+    private readonly _transformValue;
+    constructor(params: Params);
+    getPath(): string;
+    getType(): FieldType;
+    getField(): string;
+    getDynamoDbType(): string;
+    transformValue(value: any): any;
+    isSortable(): boolean;
+}

package/plugins/definitions/FieldPlugin.js

@@ -0,0 +1,73 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.FieldPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+class FieldPlugin extends _plugins.Plugin {
+  constructor(params) {
+    super();
+    (0, _defineProperty2.default)(this, "path", void 0);
+    (0, _defineProperty2.default)(this, "field", void 0);
+    (0, _defineProperty2.default)(this, "fieldType", void 0);
+    (0, _defineProperty2.default)(this, "dynamoDbType", void 0);
+    (0, _defineProperty2.default)(this, "sortable", void 0);
+    (0, _defineProperty2.default)(this, "_transformValue", void 0);
+    this.fieldType = params.type || "string";
+    this.dynamoDbType = params.type === "date" ? "string" : params.type;
+    this.field = params.field;
+    this.path = params.path;
+    this.sortable = params.sortable === undefined ? true : params.sortable;
+    this._transformValue = params.transformValue;
+  }
+
+  getPath() {
+    return this.path || this.field;
+  }
+
+  getType() {
+    return this.fieldType;
+  }
+
+  getField() {
+    return this.field;
+  }
+
+  getDynamoDbType() {
+    return this.dynamoDbType;
+  }
+
+  transformValue(value) {
+    if (this._transformValue) {
+      return this.transformValue(value);
+    }
+
+    switch (this.fieldType) {
+      case "number":
+        return Number(value);
+
+      case "date":
+        if (!value) {
+          return null;
+        }
+
+        return new Date(value);
+    }
+
+    return value;
+  }
+
+  isSortable() {
+    return this.sortable;
+  }
+
+}
+
+exports.FieldPlugin = FieldPlugin;

package/plugins/definitions/NumberTransformPlugin.d.ts

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

package/plugins/definitions/NumberTransformPlugin.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.NumberTransformPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ValueTransformPlugin = require("./ValueTransformPlugin");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _isNumber = _interopRequireDefault(require("is-number"));
+
+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 transformNumber = params => {
+  const {
+    value
+  } = params;
+  const typeOf = typeof value;
+  /**
+   * Due to some internal JS stuff, we must check for a number like this.
+   */
+
+  if (typeOf === "number" || (0, _isNumber.default)(value) === true) {
+    return Number(value);
+  }
+
+  throw new _error.default("Field value must be a number because.", "NUMBER_ERROR", {
+    value
+  });
+};
+
+class NumberTransformPlugin extends _ValueTransformPlugin.ValueTransformPlugin {
+  constructor(params) {
+    super(_objectSpread({
+      transform: transformNumber
+    }, params));
+  }
+
+}
+
+exports.NumberTransformPlugin = NumberTransformPlugin;

package/plugins/definitions/TimeTransformPlugin.d.ts

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

package/plugins/definitions/TimeTransformPlugin.js

@@ -0,0 +1,65 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TimeTransformPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _ValueTransformPlugin = require("./ValueTransformPlugin");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _isNumber = _interopRequireDefault(require("is-number"));
+
+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 transformTime = params => {
+  const {
+    value
+  } = params;
+  const typeOf = typeof value;
+  /**
+   * Due to some internal JS stuff, we must check for a number like this.
+   */
+
+  if (typeOf === "number" || (0, _isNumber.default)(value) === true) {
+    return Number(value);
+  } else if (typeOf !== "string") {
+    throw new _error.default("Field value must be a string because field is defined as time.", "TIME_PARSE_ERROR", {
+      value
+    });
+  }
+  /**
+   * This is for the time format, eg. 12:36:25 or 12:36:25.881
+   */
+
+
+  const [time, milliseconds = 0] = value.split(".");
+  const values = time.split(":").map(Number);
+
+  if (values.length < 2) {
+    throw new _error.default("Time must contain at least hours and minutes.", "TIME_PARSE_ERROR", {
+      value
+    });
+  }
+
+  const [hours, minutes, seconds = 0] = values;
+  return (hours * 60 * 60 + minutes * 60 + seconds) * 1000 + Number(milliseconds);
+};
+
+class TimeTransformPlugin extends _ValueTransformPlugin.ValueTransformPlugin {
+  constructor(params) {
+    super(_objectSpread({
+      transform: transformTime
+    }, params));
+  }
+
+}
+
+exports.TimeTransformPlugin = TimeTransformPlugin;

package/plugins/definitions/ValueFilterPlugin.d.ts

@@ -0,0 +1,20 @@
+import { Plugin } from "@webiny/plugins";
+export interface MatchesParams {
+    value: any;
+    compareValue: any;
+}
+export interface Matches {
+    (params: MatchesParams): boolean;
+}
+export interface Params {
+    operation: string;
+    matches: Matches;
+}
+export declare class ValueFilterPlugin extends Plugin {
+    static readonly type = "dynamodb.value.filter";
+    private readonly _params;
+    get operation(): string;
+    constructor(params: Params);
+    matches(params: MatchesParams): boolean;
+    getOperation(): string;
+}

package/plugins/definitions/ValueFilterPlugin.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValueFilterPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+class ValueFilterPlugin extends _plugins.Plugin {
+  get operation() {
+    return this.getOperation();
+  }
+
+  constructor(params) {
+    super();
+    (0, _defineProperty2.default)(this, "_params", void 0);
+    this._params = params;
+  }
+
+  matches(params) {
+    if (!this._params || !this._params.matches) {
+      throw new _error.default(`Missing "matches" in the plugin.`, "MATCHES_ERROR", {
+        plugin: this,
+        params
+      });
+    }
+
+    return this._params.matches(params);
+  }
+
+  getOperation() {
+    if (!this._params || !this._params.operation) {
+      throw new _error.default(`Missing "operation" in the plugin.`, "OPERATION_ERROR");
+    }
+
+    return this._params.operation;
+  }
+
+}
+
+exports.ValueFilterPlugin = ValueFilterPlugin;
+(0, _defineProperty2.default)(ValueFilterPlugin, "type", "dynamodb.value.filter");

package/plugins/definitions/ValueTransformPlugin.d.ts

@@ -0,0 +1,22 @@
+import { Plugin } from "@webiny/plugins";
+export interface TransformParams {
+    value: any;
+}
+export interface Transform {
+    (params: TransformParams): any;
+}
+export interface CanTransform {
+    (field: string): boolean;
+}
+export interface Params {
+    fields: string[];
+    transform: Transform;
+    canTransform?: CanTransform;
+}
+export declare class ValueTransformPlugin extends Plugin {
+    static readonly type = "dynamodb.value.transform";
+    private readonly _params;
+    constructor(params: Params);
+    canTransform(field: string): boolean;
+    transform(params: TransformParams): any;
+}

package/plugins/definitions/ValueTransformPlugin.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValueTransformPlugin = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _plugins = require("@webiny/plugins");
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _assignFields = require("./assignFields");
+
+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 ValueTransformPlugin extends _plugins.Plugin {
+  constructor(params) {
+    super();
+    (0, _defineProperty2.default)(this, "_params", void 0);
+    this._params = _objectSpread(_objectSpread({}, params), {}, {
+      fields: (0, _assignFields.assignFields)(params.fields)
+    });
+  }
+
+  canTransform(field) {
+    if (!this._params.canTransform) {
+      return this._params.fields.includes(field);
+    }
+
+    return this._params.canTransform(field);
+  }
+
+  transform(params) {
+    if (!this._params.transform) {
+      throw new _error.default(`Missing "transform" in the plugin.`, "TRANSFORM_ERROR", {
+        fields: this._params.fields
+      });
+    }
+
+    return this._params.transform(params);
+  }
+
+}
+
+exports.ValueTransformPlugin = ValueTransformPlugin;
+(0, _defineProperty2.default)(ValueTransformPlugin, "type", "dynamodb.value.transform");

package/plugins/definitions/assignFields.d.ts

@@ -0,0 +1 @@
+export declare const assignFields: (rawInput: string | string[]) => string[];

package/plugins/definitions/assignFields.js

@@ -0,0 +1,37 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.assignFields = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const assignFields = rawInput => {
+  const input = Array.isArray(rawInput) ? rawInput : [rawInput];
+
+  if (input.length === 0) {
+    throw new _error.default("Could not assign fields because there are none.", "ASSIGN_FIELDS_ERROR");
+  }
+
+  const fields = [];
+
+  for (const field of input) {
+    /**
+     * Need to make sure that no field is empty.
+     */
+    if (!field) {
+      throw new _error.default("Passed empty field value into the plugin.", "EMPTY_FIELD_VALUE", {
+        fields: input
+      });
+    }
+
+    fields.push(field);
+  }
+
+  return fields;
+};
+
+exports.assignFields = assignFields;

package/plugins/filters/andIn.d.ts

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

package/plugins/filters/andIn.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: "and_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.every(c => value.includes(c));
+    }
+
+    return compareValue.includes(value);
+  }
+});
+
+exports.default = _default;

package/plugins/filters/between.d.ts

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

package/plugins/filters/between.js

@@ -0,0 +1,36 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+var _ValueFilterPlugin = require("../definitions/ValueFilterPlugin");
+
+var _default = new _ValueFilterPlugin.ValueFilterPlugin({
+  operation: "between",
+  matches: ({
+    value,
+    compareValue
+  }) => {
+    if (Array.isArray(compareValue)) {
+      if (compareValue.length !== 2) {
+        throw new _error.default("When comparing between and you give an array, there must be two items in it.", "FILTER_ERROR", {
+          value,
+          compareValue
+        });
+      }
+
+      const [from, to] = compareValue;
+      return value >= from && value <= to;
+    }
+
+    return value >= compareValue && value <= compareValue;
+  }
+});
+
+exports.default = _default;

package/plugins/filters/contains.d.ts

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

package/plugins/filters/contains.js

@@ -0,0 +1,32 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _ValueFilterPlugin = require("../definitions/ValueFilterPlugin");
+
+var _default = new _ValueFilterPlugin.ValueFilterPlugin({
+  operation: "contains",
+  matches: ({
+    value,
+    compareValue
+  }) => {
+    if (typeof value !== "string") {
+      if (Array.isArray(value) === true) {
+        const re = new RegExp(compareValue, "i");
+        return value.some(v => {
+          return v.match(re) !== null;
+        });
+      }
+
+      return false;
+    }
+
+    const re = new RegExp(compareValue, "i");
+    return value.match(re) !== null;
+  }
+});
+
+exports.default = _default;

package/plugins/filters/eq.d.ts

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