@webiny/db-dynamodb 0.0.0-ee-vpcs.549378cf03

package/statements/createKeyConditionExpressionArgs.d.ts

@@ -0,0 +1,15 @@
+import { Query, QueryKey, QuerySort } from "../types";
+interface Output {
+    KeyConditionExpression: string;
+    ExpressionAttributeNames: Record<string, any>;
+    ExpressionAttributeValues: Record<string, any>;
+    ScanIndexForward: boolean;
+    IndexName: string;
+}
+interface Params {
+    query: Query;
+    sort: QuerySort;
+    key: QueryKey;
+}
+declare const _default: ({ query, sort, key }: Params) => Output;
+export default _default;

package/statements/createKeyConditionExpressionArgs.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _processStatement = _interopRequireDefault(require("./processStatement"));
+
+/**
+ * Remove this when no apps are using our internal db drivers anymore
+ */
+// @ts-nocheck
+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/createKeyConditionExpressionArgs.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["query","sort","key","args","expression","attributeNames","attributeValues","processStatement","$and","output","KeyConditionExpression","ExpressionAttributeNames","ExpressionAttributeValues","ScanIndexForward","IndexName","sortKey","fields","name","primary"],"sources":["createKeyConditionExpressionArgs.ts"],"sourcesContent":["/**\n * Remove this when no apps are using our internal db drivers anymore\n */\n// @ts-nocheck\nimport processStatement from \"./processStatement\";\nimport { ProcessStatementArgsParam, Query, QueryKey, QuerySort } from \"~/types\";\n\ninterface Output {\n    KeyConditionExpression: string;\n    ExpressionAttributeNames: Record<string, any>;\n    ExpressionAttributeValues: Record<string, any>;\n    ScanIndexForward: boolean;\n    IndexName: string;\n}\ninterface Params {\n    query: Query;\n    sort: QuerySort;\n    key: QueryKey;\n}\nexport default ({ query, sort, key }: Params): Output => {\n    const args: ProcessStatementArgsParam = {\n        expression: \"\",\n        attributeNames: {},\n        attributeValues: {}\n    };\n\n    processStatement({ args, query: { $and: query } });\n\n    const output: Output = {\n        KeyConditionExpression: args.expression,\n        ExpressionAttributeNames: args.attributeNames,\n        ExpressionAttributeValues: args.attributeValues,\n        ScanIndexForward: true,\n        IndexName: null\n    };\n\n    const sortKey = key.fields && key.fields[1];\n    if (sort && sort[sortKey.name] === -1) {\n        output.ScanIndexForward = false;\n    }\n\n    if (!key.primary) {\n        output.IndexName = key.name;\n    }\n\n    return output;\n};\n"],"mappings":";;;;;;;;;AAIA;;AAJA;AACA;AACA;AACA;eAgBe,CAAC;EAAEA,KAAF;EAASC,IAAT;EAAeC;AAAf,CAAD,KAA0C;EACrD,MAAMC,IAA+B,GAAG;IACpCC,UAAU,EAAE,EADwB;IAEpCC,cAAc,EAAE,EAFoB;IAGpCC,eAAe,EAAE;EAHmB,CAAxC;EAMA,IAAAC,yBAAA,EAAiB;IAAEJ,IAAF;IAAQH,KAAK,EAAE;MAAEQ,IAAI,EAAER;IAAR;EAAf,CAAjB;EAEA,MAAMS,MAAc,GAAG;IACnBC,sBAAsB,EAAEP,IAAI,CAACC,UADV;IAEnBO,wBAAwB,EAAER,IAAI,CAACE,cAFZ;IAGnBO,yBAAyB,EAAET,IAAI,CAACG,eAHb;IAInBO,gBAAgB,EAAE,IAJC;IAKnBC,SAAS,EAAE;EALQ,CAAvB;EAQA,MAAMC,OAAO,GAAGb,GAAG,CAACc,MAAJ,IAAcd,GAAG,CAACc,MAAJ,CAAW,CAAX,CAA9B;;EACA,IAAIf,IAAI,IAAIA,IAAI,CAACc,OAAO,CAACE,IAAT,CAAJ,KAAuB,CAAC,CAApC,EAAuC;IACnCR,MAAM,CAACI,gBAAP,GAA0B,KAA1B;EACH;;EAED,IAAI,CAACX,GAAG,CAACgB,OAAT,EAAkB;IACdT,MAAM,CAACK,SAAP,GAAmBZ,GAAG,CAACe,IAAvB;EACH;;EAED,OAAOR,MAAP;AACH,C"}

package/statements/processStatement.d.ts

@@ -0,0 +1,3 @@
+import { ProcessStatementCallable } from "../types";
+declare const processStatement: ProcessStatementCallable;
+export default processStatement;

package/statements/processStatement.js

@@ -0,0 +1,42 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+var _operators = _interopRequireDefault(require("./../operators"));
+
+const 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}}.`);
+  }
+};
+
+var _default = processStatement;
+exports.default = _default;

package/statements/processStatement.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["processStatement","args","query","outerLoop","key","value","Object","entries","operators","values","allOperators","i","length","operator","canProcess","process","Error"],"sources":["processStatement.ts"],"sourcesContent":["import allOperators from \"./../operators\";\nimport { ProcessStatementCallable } from \"~/types\";\n\nconst processStatement: ProcessStatementCallable = ({ args, query }) => {\n    outerLoop: for (const [key, value] of Object.entries(query)) {\n        const operators = Object.values(allOperators);\n        for (let i = 0; i < operators.length; i++) {\n            const operator = operators[i];\n            if (operator.canProcess({ key, value, args })) {\n                operator.process({ key, value, args, processStatement });\n                continue outerLoop;\n            }\n        }\n        throw new Error(`Invalid operator {${key} : ${value}}.`);\n    }\n};\nexport default processStatement;\n"],"mappings":";;;;;;;;;AAAA;;AAGA,MAAMA,gBAA0C,GAAG,CAAC;EAAEC,IAAF;EAAQC;AAAR,CAAD,KAAqB;EACpEC,SAAS,EAAE,KAAK,MAAM,CAACC,GAAD,EAAMC,KAAN,CAAX,IAA2BC,MAAM,CAACC,OAAP,CAAeL,KAAf,CAA3B,EAAkD;IACzD,MAAMM,SAAS,GAAGF,MAAM,CAACG,MAAP,CAAcC,kBAAd,CAAlB;;IACA,KAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,SAAS,CAACI,MAA9B,EAAsCD,CAAC,EAAvC,EAA2C;MACvC,MAAME,QAAQ,GAAGL,SAAS,CAACG,CAAD,CAA1B;;MACA,IAAIE,QAAQ,CAACC,UAAT,CAAoB;QAAEV,GAAF;QAAOC,KAAP;QAAcJ;MAAd,CAApB,CAAJ,EAA+C;QAC3CY,QAAQ,CAACE,OAAT,CAAiB;UAAEX,GAAF;UAAOC,KAAP;UAAcJ,IAAd;UAAoBD;QAApB,CAAjB;QACA,SAASG,SAAT;MACH;IACJ;;IACD,MAAM,IAAIa,KAAJ,CAAW,qBAAoBZ,GAAI,MAAKC,KAAM,IAA9C,CAAN;EACH;AACJ,CAZD;;eAaeL,gB"}

package/types.d.ts

@@ -0,0 +1,58 @@
+export interface OperatorArgs {
+    expression: string;
+    attributeNames: Record<string, any>;
+    attributeValues: Record<string, any>;
+}
+interface CanProcessArgs {
+    key: string;
+    value: any;
+    args: OperatorArgs;
+}
+interface ProcessArgs {
+    key: string;
+    value: any;
+    args: OperatorArgs;
+    processStatement: any;
+}
+export interface 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 interface ProcessStatementArgsParam {
+    expression: string;
+    attributeNames: Record<string, any>;
+    attributeValues: Record<string, any>;
+}
+export interface ProcessStatementQueryParam {
+    [key: string]: any;
+}
+export interface ProcessStatementParams {
+    args: ProcessStatementArgsParam;
+    query: ProcessStatementQueryParam;
+}
+export interface ProcessStatementCallable {
+    (params: ProcessStatementParams): void;
+}
+export interface Query {
+    [key: string]: string;
+}
+export interface QueryKeyField {
+    name: string;
+}
+export interface QueryKey {
+    fields: QueryKeyField[];
+    primary?: boolean;
+    unique?: boolean;
+    name: string;
+}
+export declare type QueryKeys = QueryKey[];
+export declare type QuerySort = Record<string, -1 | 1>;
+export {};

package/types.js

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

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["export interface OperatorArgs {\n    expression: string;\n    attributeNames: Record<string, any>;\n    attributeValues: Record<string, any>;\n}\n\ninterface CanProcessArgs {\n    key: string;\n    value: any;\n    args: OperatorArgs;\n}\n\ninterface ProcessArgs {\n    key: string;\n    value: any;\n    args: OperatorArgs;\n    processStatement: any;\n}\n\nexport interface Operator {\n    canProcess: ({ key }: CanProcessArgs) => boolean;\n    process: ({ key, value, args }: ProcessArgs) => void;\n}\n\n/**\n * We use this definition to search for a value in any given field that was passed.\n * It works as an \"OR\" condition.\n */\nexport interface DynamoDbContainsFilter {\n    fields: string[];\n    value: string;\n}\n\nexport interface ProcessStatementArgsParam {\n    expression: string;\n    attributeNames: Record<string, any>;\n    attributeValues: Record<string, any>;\n}\nexport interface ProcessStatementQueryParam {\n    [key: string]: any;\n}\nexport interface ProcessStatementParams {\n    args: ProcessStatementArgsParam;\n    query: ProcessStatementQueryParam;\n}\n\nexport interface ProcessStatementCallable {\n    (params: ProcessStatementParams): void;\n}\n\nexport interface Query {\n    [key: string]: string;\n}\nexport interface QueryKeyField {\n    name: string;\n}\nexport interface QueryKey {\n    fields: QueryKeyField[];\n    primary?: boolean;\n    unique?: boolean;\n    name: string;\n}\nexport type QueryKeys = QueryKey[];\n\nexport type QuerySort = Record<string, -1 | 1>;\n"],"mappings":""}

package/utils/attributes.d.ts

@@ -0,0 +1,10 @@
+import { Context } from "@webiny/api/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: Context, entity: string) => Record<string, DefinitionParams>;
+export declare const getExtraAttributesFromPlugins: (plugins: PluginsContainer, entity: string) => Record<string, DefinitionParams>;

package/utils/attributes.js

@@ -0,0 +1,31 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExtraAttributesFromPlugins = exports.getExtraAttributes = void 0;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+var _AttributePlugin = require("../plugins/definitions/AttributePlugin");
+
+/**
+ * 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 (0, _objectSpread2.default)((0, _objectSpread2.default)({}, attributes), plugin.getDefinition());
+  }, {});
+};
+
+exports.getExtraAttributesFromPlugins = getExtraAttributesFromPlugins;

package/utils/attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["getExtraAttributes","context","entity","getExtraAttributesFromPlugins","plugins","byType","AttributePlugin","type","filter","plugin","reduce","attributes","getDefinition"],"sources":["attributes.ts"],"sourcesContent":["import { Context } from \"@webiny/api/types\";\nimport { AttributePlugin, DefinitionParams } from \"~/plugins/definitions/AttributePlugin\";\nimport { PluginsContainer } from \"@webiny/plugins\";\n\n/**\n * Will be removed in favor of directly assigning attributes to a certain entity when creating the storage operations.\n *\n * @deprecated\n */\nexport const getExtraAttributes = (\n    context: Context,\n    entity: string\n): Record<string, DefinitionParams> => {\n    return getExtraAttributesFromPlugins(context.plugins, entity);\n};\n\nexport const getExtraAttributesFromPlugins = (\n    plugins: PluginsContainer,\n    entity: string\n): Record<string, DefinitionParams> => {\n    return plugins\n        .byType<AttributePlugin>(AttributePlugin.type)\n        .filter(plugin => plugin.entity === entity)\n        .reduce((attributes, plugin) => {\n            return {\n                ...attributes,\n                ...plugin.getDefinition()\n            };\n        }, {});\n};\n"],"mappings":";;;;;;;;;;;AACA;;AAGA;AACA;AACA;AACA;AACA;AACO,MAAMA,kBAAkB,GAAG,CAC9BC,OAD8B,EAE9BC,MAF8B,KAGK;EACnC,OAAOC,6BAA6B,CAACF,OAAO,CAACG,OAAT,EAAkBF,MAAlB,CAApC;AACH,CALM;;;;AAOA,MAAMC,6BAA6B,GAAG,CACzCC,OADyC,EAEzCF,MAFyC,KAGN;EACnC,OAAOE,OAAO,CACTC,MADE,CACsBC,gCAAA,CAAgBC,IADtC,EAEFC,MAFE,CAEKC,MAAM,IAAIA,MAAM,CAACP,MAAP,KAAkBA,MAFjC,EAGFQ,MAHE,CAGK,CAACC,UAAD,EAAaF,MAAb,KAAwB;IAC5B,mEACOE,UADP,GAEOF,MAAM,CAACG,aAAP,EAFP;EAIH,CARE,EAQA,EARA,CAAP;AASH,CAbM"}

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, maxChunk?: number) => Promise<T[]>;
+export {};

package/utils/batchRead.js

@@ -0,0 +1,89 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.batchReadAll = void 0;
+
+var _chunk = _interopRequireDefault(require("lodash/chunk"));
+
+var _error = _interopRequireDefault(require("@webiny/error"));
+
+const MAX_BATCH_ITEMS = 100;
+
+const flatten = responses => {
+  const entries = [];
+  const values = Object.values(responses);
+
+  for (const items of values) {
+    entries.push(...items);
+  }
+
+  return entries;
+};
+
+const batchReadAllChunk = async params => {
+  const {
+    table,
+    items
+  } = params;
+  const records = [];
+  const result = await table.batchGet(items);
+
+  if (!result || !result.Responses) {
+    return records;
+  }
+
+  records.push(...flatten(result.Responses));
+
+  if (!result.next || typeof result.next !== "function") {
+    return records;
+  }
+
+  let previous = result;
+
+  while (typeof previous.next === "function") {
+    const nextResult = await previous.next();
+
+    if (!nextResult) {
+      return records;
+    }
+
+    records.push(...flatten(nextResult.Responses));
+    previous = nextResult;
+  }
+
+  return records;
+};
+/**
+ * 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, maxChunk = MAX_BATCH_ITEMS) => {
+  if (params.items.length === 0) {
+    return [];
+  } else if (maxChunk > MAX_BATCH_ITEMS) {
+    throw new _error.default(`Cannot set to load more than ${MAX_BATCH_ITEMS} items from the DynamoDB at once.`, "DYNAMODB_MAX_BATCH_GET_LIMIT_ERROR", {
+      maxChunk
+    });
+  }
+
+  const records = [];
+  const chunkItemsList = (0, _chunk.default)(params.items, maxChunk);
+
+  for (const chunkItems of chunkItemsList) {
+    const results = await batchReadAllChunk({
+      table: params.table,
+      items: chunkItems
+    });
+    records.push(...results);
+  }
+
+  return records;
+};
+
+exports.batchReadAll = batchReadAll;

package/utils/batchRead.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["MAX_BATCH_ITEMS","flatten","responses","entries","values","Object","items","push","batchReadAllChunk","params","table","records","result","batchGet","Responses","next","previous","nextResult","batchReadAll","maxChunk","length","WebinyError","chunkItemsList","lodashChunk","chunkItems","results"],"sources":["batchRead.ts"],"sourcesContent":["import { Table } from \"dynamodb-toolbox\";\nimport lodashChunk from \"lodash/chunk\";\nimport WebinyError from \"@webiny/error\";\n\ninterface Item {\n    Table: Table;\n    Key: any;\n}\ninterface Params {\n    table: Table;\n    items: Item[];\n}\n\nconst MAX_BATCH_ITEMS = 100;\n\nconst flatten = (responses: Record<string, any[]>): any[] => {\n    const entries = [];\n    const values = Object.values(responses);\n    for (const items of values) {\n        entries.push(...items);\n    }\n    return entries;\n};\n\ninterface BatchReadAllChunkParams {\n    table: Table;\n    items: Item[];\n}\nconst batchReadAllChunk = async <T = any>(params: BatchReadAllChunkParams): Promise<T[]> => {\n    const { table, items } = params;\n    const records: T[] = [];\n\n    const result = await table.batchGet(items);\n    if (!result || !result.Responses) {\n        return records;\n    }\n    records.push(...flatten(result.Responses));\n    if (!result.next || typeof result.next !== \"function\") {\n        return records;\n    }\n    let previous = result;\n    while (typeof previous.next === \"function\") {\n        const nextResult = await previous.next();\n        if (!nextResult) {\n            return records;\n        }\n        records.push(...flatten(nextResult.Responses));\n        previous = nextResult;\n    }\n    return records;\n};\n/**\n * This helper function is meant to be used to batch read from one table.\n * It will fetch all results, as there is a next() method call built in.\n */\nexport const batchReadAll = async <T = any>(\n    params: Params,\n    maxChunk = MAX_BATCH_ITEMS\n): Promise<T[]> => {\n    if (params.items.length === 0) {\n        return [];\n    } else if (maxChunk > MAX_BATCH_ITEMS) {\n        throw new WebinyError(\n            `Cannot set to load more than ${MAX_BATCH_ITEMS} items from the DynamoDB at once.`,\n            \"DYNAMODB_MAX_BATCH_GET_LIMIT_ERROR\",\n            {\n                maxChunk\n            }\n        );\n    }\n\n    const records: T[] = [];\n\n    const chunkItemsList: Item[][] = lodashChunk(params.items, maxChunk);\n\n    for (const chunkItems of chunkItemsList) {\n        const results = await batchReadAllChunk<T>({\n            table: params.table,\n            items: chunkItems\n        });\n\n        records.push(...results);\n    }\n\n    return records;\n};\n"],"mappings":";;;;;;;;;AACA;;AACA;;AAWA,MAAMA,eAAe,GAAG,GAAxB;;AAEA,MAAMC,OAAO,GAAIC,SAAD,IAA6C;EACzD,MAAMC,OAAO,GAAG,EAAhB;EACA,MAAMC,MAAM,GAAGC,MAAM,CAACD,MAAP,CAAcF,SAAd,CAAf;;EACA,KAAK,MAAMI,KAAX,IAAoBF,MAApB,EAA4B;IACxBD,OAAO,CAACI,IAAR,CAAa,GAAGD,KAAhB;EACH;;EACD,OAAOH,OAAP;AACH,CAPD;;AAaA,MAAMK,iBAAiB,GAAG,MAAgBC,MAAhB,IAAkE;EACxF,MAAM;IAAEC,KAAF;IAASJ;EAAT,IAAmBG,MAAzB;EACA,MAAME,OAAY,GAAG,EAArB;EAEA,MAAMC,MAAM,GAAG,MAAMF,KAAK,CAACG,QAAN,CAAeP,KAAf,CAArB;;EACA,IAAI,CAACM,MAAD,IAAW,CAACA,MAAM,CAACE,SAAvB,EAAkC;IAC9B,OAAOH,OAAP;EACH;;EACDA,OAAO,CAACJ,IAAR,CAAa,GAAGN,OAAO,CAACW,MAAM,CAACE,SAAR,CAAvB;;EACA,IAAI,CAACF,MAAM,CAACG,IAAR,IAAgB,OAAOH,MAAM,CAACG,IAAd,KAAuB,UAA3C,EAAuD;IACnD,OAAOJ,OAAP;EACH;;EACD,IAAIK,QAAQ,GAAGJ,MAAf;;EACA,OAAO,OAAOI,QAAQ,CAACD,IAAhB,KAAyB,UAAhC,EAA4C;IACxC,MAAME,UAAU,GAAG,MAAMD,QAAQ,CAACD,IAAT,EAAzB;;IACA,IAAI,CAACE,UAAL,EAAiB;MACb,OAAON,OAAP;IACH;;IACDA,OAAO,CAACJ,IAAR,CAAa,GAAGN,OAAO,CAACgB,UAAU,CAACH,SAAZ,CAAvB;IACAE,QAAQ,GAAGC,UAAX;EACH;;EACD,OAAON,OAAP;AACH,CAtBD;AAuBA;AACA;AACA;AACA;;;AACO,MAAMO,YAAY,GAAG,OACxBT,MADwB,EAExBU,QAAQ,GAAGnB,eAFa,KAGT;EACf,IAAIS,MAAM,CAACH,KAAP,CAAac,MAAb,KAAwB,CAA5B,EAA+B;IAC3B,OAAO,EAAP;EACH,CAFD,MAEO,IAAID,QAAQ,GAAGnB,eAAf,EAAgC;IACnC,MAAM,IAAIqB,cAAJ,CACD,gCAA+BrB,eAAgB,mCAD9C,EAEF,oCAFE,EAGF;MACImB;IADJ,CAHE,CAAN;EAOH;;EAED,MAAMR,OAAY,GAAG,EAArB;EAEA,MAAMW,cAAwB,GAAG,IAAAC,cAAA,EAAYd,MAAM,CAACH,KAAnB,EAA0Ba,QAA1B,CAAjC;;EAEA,KAAK,MAAMK,UAAX,IAAyBF,cAAzB,EAAyC;IACrC,MAAMG,OAAO,GAAG,MAAMjB,iBAAiB,CAAI;MACvCE,KAAK,EAAED,MAAM,CAACC,KADyB;MAEvCJ,KAAK,EAAEkB;IAFgC,CAAJ,CAAvC;IAKAb,OAAO,CAACJ,IAAR,CAAa,GAAGkB,OAAhB;EACH;;EAED,OAAOd,OAAP;AACH,CA9BM"}

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").default;
+
+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/batchWrite.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["batchWriteAll","params","maxChunk","items","length","chunkedItems","lodashChunk","table","batchWrite"],"sources":["batchWrite.ts"],"sourcesContent":["import { Table } from \"dynamodb-toolbox\";\nimport lodashChunk from \"lodash/chunk\";\nimport { DocumentClient } from \"aws-sdk/clients/dynamodb\";\n\ninterface Item {\n    [key: string]: DocumentClient.WriteRequest;\n}\ninterface Params {\n    table: Table;\n    items: Item[];\n}\n\n/**\n * Method is meant for batch writing to a single table.\n * It expects already prepared items for the write.\n * It can either delete or put items\n * The method does not check items before actually sending them into the underlying library.\n */\nexport const batchWriteAll = async (params: Params, maxChunk = 25): Promise<void> => {\n    if (params.items.length === 0) {\n        return;\n    }\n    const chunkedItems: Item[][] = lodashChunk(params.items, maxChunk);\n    for (const items of chunkedItems) {\n        await params.table.batchWrite(items);\n    }\n};\n"],"mappings":";;;;;;;;;AACA;;AAWA;AACA;AACA;AACA;AACA;AACA;AACO,MAAMA,aAAa,GAAG,OAAOC,MAAP,EAAuBC,QAAQ,GAAG,EAAlC,KAAwD;EACjF,IAAID,MAAM,CAACE,KAAP,CAAaC,MAAb,KAAwB,CAA5B,EAA+B;IAC3B;EACH;;EACD,MAAMC,YAAsB,GAAG,IAAAC,cAAA,EAAYL,MAAM,CAACE,KAAnB,EAA0BD,QAA1B,CAA/B;;EACA,KAAK,MAAMC,KAAX,IAAoBE,YAApB,EAAkC;IAC9B,MAAMJ,MAAM,CAACM,KAAP,CAAaC,UAAb,CAAwBL,KAAxB,CAAN;EACH;AACJ,CARM"}

package/utils/cleanup.d.ts

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

package/utils/cleanup.js

@@ -0,0 +1,45 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault").default;
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.cleanupItem = cleanupItem;
+exports.cleanupItems = cleanupItems;
+
+var _objectSpread2 = _interopRequireDefault(require("@babel/runtime/helpers/objectSpread2"));
+
+/**
+ * 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"];
+
+function cleanupItem(entity, item, removeAttributes = []) {
+  if (!item) {
+    return null;
+  }
+
+  const newItem = (0, _objectSpread2.default)({}, 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;
+}
+
+function cleanupItems(entity, items, removeAttributes = []) {
+  return items.map(item => cleanupItem(entity, item, removeAttributes));
+}

package/utils/cleanup.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["attributesToRemove","cleanupItem","entity","item","removeAttributes","newItem","targets","concat","attributes","schema","key","hasOwnProperty","includes","cleanupItems","items","map"],"sources":["cleanup.ts"],"sourcesContent":["import { Entity } from \"dynamodb-toolbox\";\n\n/**\n * The attributes defined by us or the dynamodb-toolbox library.\n * Add more attributes if necessary.\n */\nconst attributesToRemove = [\n    \"PK\",\n    \"SK\",\n    \"created\",\n    \"_ct\",\n    \"modified\",\n    \"_mt\",\n    \"entity\",\n    \"_et\",\n    \"GSI1_PK\",\n    \"GSI1_SK\",\n    \"TYPE\"\n];\n\nexport function cleanupItem<T>(\n    entity: Entity<any>,\n    item?: (T & Record<string, any>) | null,\n    removeAttributes: string[] = []\n): T | null {\n    if (!item) {\n        return null;\n    }\n    const newItem = {\n        ...item\n    };\n    const targets = attributesToRemove.concat(removeAttributes);\n    const attributes = entity.schema.attributes;\n    for (const key in item) {\n        if (item.hasOwnProperty(key) === false) {\n            continue;\n        }\n        if (attributes[key] && targets.includes(key) === false) {\n            continue;\n        }\n        delete newItem[key];\n    }\n    return newItem;\n}\n\nexport function cleanupItems<T>(\n    entity: Entity<any>,\n    items: (T & Record<string, any>)[],\n    removeAttributes: string[] = []\n): T[] {\n    return items.map(item => cleanupItem<T>(entity, item, removeAttributes) as T);\n}\n"],"mappings":";;;;;;;;;;;;AAEA;AACA;AACA;AACA;AACA,MAAMA,kBAAkB,GAAG,CACvB,IADuB,EAEvB,IAFuB,EAGvB,SAHuB,EAIvB,KAJuB,EAKvB,UALuB,EAMvB,KANuB,EAOvB,QAPuB,EAQvB,KARuB,EASvB,SATuB,EAUvB,SAVuB,EAWvB,MAXuB,CAA3B;;AAcO,SAASC,WAAT,CACHC,MADG,EAEHC,IAFG,EAGHC,gBAA0B,GAAG,EAH1B,EAIK;EACR,IAAI,CAACD,IAAL,EAAW;IACP,OAAO,IAAP;EACH;;EACD,MAAME,OAAO,mCACNF,IADM,CAAb;EAGA,MAAMG,OAAO,GAAGN,kBAAkB,CAACO,MAAnB,CAA0BH,gBAA1B,CAAhB;EACA,MAAMI,UAAU,GAAGN,MAAM,CAACO,MAAP,CAAcD,UAAjC;;EACA,KAAK,MAAME,GAAX,IAAkBP,IAAlB,EAAwB;IACpB,IAAIA,IAAI,CAACQ,cAAL,CAAoBD,GAApB,MAA6B,KAAjC,EAAwC;MACpC;IACH;;IACD,IAAIF,UAAU,CAACE,GAAD,CAAV,IAAmBJ,OAAO,CAACM,QAAR,CAAiBF,GAAjB,MAA0B,KAAjD,EAAwD;MACpD;IACH;;IACD,OAAOL,OAAO,CAACK,GAAD,CAAd;EACH;;EACD,OAAOL,OAAP;AACH;;AAEM,SAASQ,YAAT,CACHX,MADG,EAEHY,KAFG,EAGHV,gBAA0B,GAAG,EAH1B,EAIA;EACH,OAAOU,KAAK,CAACC,GAAN,CAAUZ,IAAI,IAAIF,WAAW,CAAIC,MAAJ,EAAYC,IAAZ,EAAkBC,gBAAlB,CAA7B,CAAP;AACH"}

package/utils/cursor.d.ts

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

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;

package/utils/cursor.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["encodeCursor","cursor","Buffer","from","JSON","stringify","toString","decodeCursor","parse"],"sources":["cursor.ts"],"sourcesContent":["export const encodeCursor = (cursor?: any): string | null => {\n    if (!cursor) {\n        return null;\n    }\n\n    return Buffer.from(JSON.stringify(cursor)).toString(\"base64\");\n};\n\nexport const decodeCursor = (cursor?: string | null): string | null => {\n    if (!cursor) {\n        return null;\n    }\n\n    return JSON.parse(Buffer.from(cursor, \"base64\").toString(\"ascii\"));\n};\n"],"mappings":";;;;;;;AAAO,MAAMA,YAAY,GAAIC,MAAD,IAAiC;EACzD,IAAI,CAACA,MAAL,EAAa;IACT,OAAO,IAAP;EACH;;EAED,OAAOC,MAAM,CAACC,IAAP,CAAYC,IAAI,CAACC,SAAL,CAAeJ,MAAf,CAAZ,EAAoCK,QAApC,CAA6C,QAA7C,CAAP;AACH,CANM;;;;AAQA,MAAMC,YAAY,GAAIN,MAAD,IAA2C;EACnE,IAAI,CAACA,MAAL,EAAa;IACT,OAAO,IAAP;EACH;;EAED,OAAOG,IAAI,CAACI,KAAL,CAAWN,MAAM,CAACC,IAAP,CAAYF,MAAZ,EAAoB,QAApB,EAA8BK,QAA9B,CAAuC,OAAvC,CAAX,CAAP;AACH,CANM"}

package/utils/filter.d.ts

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