@webiny/db-dynamodb 0.0.0-mt-2 → 0.0.0-unstable.06b2ede40f

package/types.d.ts

@@ -1,23 +1,3 @@
-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.
@@ -26,4 +6,40 @@ export interface DynamoDbContainsFilter {
     fields: string[];
     value: string;
 }
-export {};
+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 type QueryKeys = QueryKey[];
+export type QuerySort = Record<string, -1 | 1>;
+export type DbItem<TData extends Record<string, any> = Record<string, any>> = {
+    PK: string;
+    SK: string;
+    GSI1_PK: string;
+    GSI1_SK: string;
+    TYPE: string;
+    data: TData;
+};

package/types.js

@@ -2,4 +2,6 @@
 
 Object.defineProperty(exports, "__esModule", {
   value: true
-});
+});
+
+//# sourceMappingURL=types.js.map

package/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["/**\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\nexport type DbItem<TData extends Record<string, any> = Record<string, any>> = {\n    PK: string;\n    SK: string;\n    GSI1_PK: string;\n    GSI1_SK: string;\n    TYPE: string;\n    data: TData;\n};\n"],"mappings":"","ignoreList":[]}

package/utils/attributes.d.ts

@@ -1,10 +1,10 @@
-import { ContextInterface } from "@webiny/handler/types";
-import { DefinitionParams } from "../plugins/definitions/AttributePlugin";
-import { PluginsContainer } from "@webiny/plugins";
+import type { Context } from "@webiny/api/types";
+import { AttributePlugin } from "../plugins/definitions/AttributePlugin";
+import type { 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>;
+export declare const getExtraAttributes: (context: Context, entity: string) => Record<string, AttributePlugin["_params"]>;
+export declare const getExtraAttributesFromPlugins: (plugins: PluginsContainer, entity: string) => Record<string, AttributePlugin["_params"]>;

package/utils/attributes.js

@@ -1,20 +1,10 @@
 "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.
  *
@@ -23,13 +13,15 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 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());
+    return {
+      ...attributes,
+      ...plugin.getDefinition()
+    };
   }, {});
 };
+exports.getExtraAttributesFromPlugins = getExtraAttributesFromPlugins;
 
-exports.getExtraAttributesFromPlugins = getExtraAttributesFromPlugins;
+//# sourceMappingURL=attributes.js.map

package/utils/attributes.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_AttributePlugin","require","getExtraAttributes","context","entity","getExtraAttributesFromPlugins","plugins","exports","byType","AttributePlugin","type","filter","plugin","reduce","attributes","getDefinition"],"sources":["attributes.ts"],"sourcesContent":["import type { Context } from \"@webiny/api/types\";\nimport { AttributePlugin } from \"~/plugins/definitions/AttributePlugin\";\nimport type { 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, AttributePlugin[\"_params\"]> => {\n    return getExtraAttributesFromPlugins(context.plugins, entity);\n};\n\nexport const getExtraAttributesFromPlugins = (\n    plugins: PluginsContainer,\n    entity: string\n): Record<string, AttributePlugin[\"_params\"]> => {\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,IAAAA,gBAAA,GAAAC,OAAA;AAGA;AACA;AACA;AACA;AACA;AACO,MAAMC,kBAAkB,GAAGA,CAC9BC,OAAgB,EAChBC,MAAc,KAC+B;EAC7C,OAAOC,6BAA6B,CAACF,OAAO,CAACG,OAAO,EAAEF,MAAM,CAAC;AACjE,CAAC;AAACG,OAAA,CAAAL,kBAAA,GAAAA,kBAAA;AAEK,MAAMG,6BAA6B,GAAGA,CACzCC,OAAyB,EACzBF,MAAc,KAC+B;EAC7C,OAAOE,OAAO,CACTE,MAAM,CAAkBC,gCAAe,CAACC,IAAI,CAAC,CAC7CC,MAAM,CAACC,MAAM,IAAIA,MAAM,CAACR,MAAM,KAAKA,MAAM,CAAC,CAC1CS,MAAM,CAAC,CAACC,UAAU,EAAEF,MAAM,KAAK;IAC5B,OAAO;MACH,GAAGE,UAAU;MACb,GAAGF,MAAM,CAACG,aAAa,CAAC;IAC5B,CAAC;EACL,CAAC,EAAE,CAAC,CAAC,CAAC;AACd,CAAC;AAACR,OAAA,CAAAF,6BAAA,GAAAA,6BAAA","ignoreList":[]}

package/utils/batch/batchRead.d.ts

@@ -0,0 +1,15 @@
+import type { TableDef } from "../../toolbox";
+import type { GenericRecord } from "@webiny/api/types";
+export interface BatchReadItem {
+    Table?: TableDef;
+    Key: any;
+}
+export interface BatchReadParams {
+    table?: TableDef;
+    items: BatchReadItem[];
+}
+/**
+ * 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 = GenericRecord>(params: BatchReadParams, maxChunk?: number) => Promise<T[]>;

package/utils/batch/batchRead.js

@@ -0,0 +1,72 @@
+"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 = [];
+  if (!table) {
+    return 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;
+
+//# sourceMappingURL=batchRead.js.map

package/utils/batch/batchRead.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chunk","_interopRequireDefault","require","_error","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","exports"],"sources":["batchRead.ts"],"sourcesContent":["import lodashChunk from \"lodash/chunk\";\nimport WebinyError from \"@webiny/error\";\nimport type { TableDef } from \"~/toolbox\";\nimport type { GenericRecord } from \"@webiny/api/types\";\n\nexport interface BatchReadItem {\n    Table?: TableDef;\n    Key: any;\n}\nexport interface BatchReadParams {\n    table?: TableDef;\n    items: BatchReadItem[];\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?: TableDef;\n    items: BatchReadItem[];\n}\nconst batchReadAllChunk = async <T = any>(params: BatchReadAllChunkParams): Promise<T[]> => {\n    const { table, items } = params;\n    const records: T[] = [];\n\n    if (!table) {\n        return records;\n    }\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 = GenericRecord>(\n    params: BatchReadParams,\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 = 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":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AACA,IAAAC,MAAA,GAAAF,sBAAA,CAAAC,OAAA;AAaA,MAAME,eAAe,GAAG,GAAG;AAE3B,MAAMC,OAAO,GAAIC,SAAgC,IAAY;EACzD,MAAMC,OAAO,GAAG,EAAE;EAClB,MAAMC,MAAM,GAAGC,MAAM,CAACD,MAAM,CAACF,SAAS,CAAC;EACvC,KAAK,MAAMI,KAAK,IAAIF,MAAM,EAAE;IACxBD,OAAO,CAACI,IAAI,CAAC,GAAGD,KAAK,CAAC;EAC1B;EACA,OAAOH,OAAO;AAClB,CAAC;AAMD,MAAMK,iBAAiB,GAAG,MAAgBC,MAA+B,IAAmB;EACxF,MAAM;IAAEC,KAAK;IAAEJ;EAAM,CAAC,GAAGG,MAAM;EAC/B,MAAME,OAAY,GAAG,EAAE;EAEvB,IAAI,CAACD,KAAK,EAAE;IACR,OAAOC,OAAO;EAClB;EAEA,MAAMC,MAAM,GAAG,MAAMF,KAAK,CAACG,QAAQ,CAACP,KAAK,CAAC;EAC1C,IAAI,CAACM,MAAM,IAAI,CAACA,MAAM,CAACE,SAAS,EAAE;IAC9B,OAAOH,OAAO;EAClB;EACAA,OAAO,CAACJ,IAAI,CAAC,GAAGN,OAAO,CAACW,MAAM,CAACE,SAAS,CAAC,CAAC;EAC1C,IAAI,CAACF,MAAM,CAACG,IAAI,IAAI,OAAOH,MAAM,CAACG,IAAI,KAAK,UAAU,EAAE;IACnD,OAAOJ,OAAO;EAClB;EACA,IAAIK,QAAQ,GAAGJ,MAAM;EACrB,OAAO,OAAOI,QAAQ,CAACD,IAAI,KAAK,UAAU,EAAE;IACxC,MAAME,UAAU,GAAG,MAAMD,QAAQ,CAACD,IAAI,CAAC,CAAC;IACxC,IAAI,CAACE,UAAU,EAAE;MACb,OAAON,OAAO;IAClB;IACAA,OAAO,CAACJ,IAAI,CAAC,GAAGN,OAAO,CAACgB,UAAU,CAACH,SAAS,CAAC,CAAC;IAC9CE,QAAQ,GAAGC,UAAU;EACzB;EACA,OAAON,OAAO;AAClB,CAAC;AACD;AACA;AACA;AACA;AACO,MAAMO,YAAY,GAAG,MAAAA,CACxBT,MAAuB,EACvBU,QAAQ,GAAGnB,eAAe,KACX;EACf,IAAIS,MAAM,CAACH,KAAK,CAACc,MAAM,KAAK,CAAC,EAAE;IAC3B,OAAO,EAAE;EACb,CAAC,MAAM,IAAID,QAAQ,GAAGnB,eAAe,EAAE;IACnC,MAAM,IAAIqB,cAAW,CACjB,gCAAgCrB,eAAe,mCAAmC,EAClF,oCAAoC,EACpC;MACImB;IACJ,CACJ,CAAC;EACL;EAEA,MAAMR,OAAY,GAAG,EAAE;EAEvB,MAAMW,cAAc,GAAG,IAAAC,cAAW,EAACd,MAAM,CAACH,KAAK,EAAEa,QAAQ,CAAC;EAE1D,KAAK,MAAMK,UAAU,IAAIF,cAAc,EAAE;IACrC,MAAMG,OAAO,GAAG,MAAMjB,iBAAiB,CAAI;MACvCE,KAAK,EAAED,MAAM,CAACC,KAAK;MACnBJ,KAAK,EAAEkB;IACX,CAAC,CAAC;IAEFb,OAAO,CAACJ,IAAI,CAAC,GAAGkB,OAAO,CAAC;EAC5B;EAEA,OAAOd,OAAO;AAClB,CAAC;AAACe,OAAA,CAAAR,YAAA,GAAAA,YAAA","ignoreList":[]}

package/utils/batch/batchWrite.d.ts

@@ -0,0 +1,13 @@
+import type { TableDef } from "../../toolbox";
+import type { BatchWriteItem, BatchWriteResult } from "./types";
+export interface BatchWriteParams {
+    table: TableDef | undefined;
+    items: BatchWriteItem[];
+}
+/**
+ * Method is meant for batch writing to a single table.
+ * It expects already prepared items for writing.
+ * 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: BatchWriteParams, maxChunk?: number) => Promise<BatchWriteResult>;

package/utils/batch/batchWrite.js

@@ -0,0 +1,65 @@
+"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"));
+const hasUnprocessedItems = result => {
+  if (typeof result.next !== "function") {
+    return false;
+  }
+  const items = result.UnprocessedItems;
+  if (!items || typeof items !== "object") {
+    return false;
+  }
+  const keys = Object.keys(items);
+  return keys.some(key => {
+    const value = items[key];
+    if (!Array.isArray(value)) {
+      return false;
+    }
+    return value.some(val => {
+      return val.PutRequest || val.DeleteRequest;
+    });
+  });
+};
+const retry = async (input, results) => {
+  if (!hasUnprocessedItems(input)) {
+    return;
+  }
+  const result = await input.next();
+  await retry(result, results);
+};
+/**
+ * Method is meant for batch writing to a single table.
+ * It expects already prepared items for writing.
+ * 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) => {
+  const {
+    items: collection,
+    table
+  } = params;
+  if (!table) {
+    console.log("No table provided.");
+    return [];
+  } else if (collection.length === 0) {
+    return [];
+  }
+  const chunkedItems = (0, _chunk.default)(collection, maxChunk);
+  const results = [];
+  for (const items of chunkedItems) {
+    const result = await table.batchWrite(items, {
+      execute: true
+    });
+    results.push(result);
+    await retry(result, results);
+  }
+  return results;
+};
+exports.batchWriteAll = batchWriteAll;
+
+//# sourceMappingURL=batchWrite.js.map

package/utils/batch/batchWrite.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_chunk","_interopRequireDefault","require","hasUnprocessedItems","result","next","items","UnprocessedItems","keys","Object","some","key","value","Array","isArray","val","PutRequest","DeleteRequest","retry","input","results","batchWriteAll","params","maxChunk","collection","table","console","log","length","chunkedItems","lodashChunk","batchWrite","execute","push","exports"],"sources":["batchWrite.ts"],"sourcesContent":["import lodashChunk from \"lodash/chunk\";\nimport type { TableDef } from \"~/toolbox\";\nimport type { BatchWriteItem, BatchWriteResponse, BatchWriteResult } from \"./types\";\n\nexport interface BatchWriteParams {\n    table: TableDef | undefined;\n    items: BatchWriteItem[];\n}\n\nconst hasUnprocessedItems = (result: BatchWriteResponse): boolean => {\n    if (typeof result.next !== \"function\") {\n        return false;\n    }\n    const items = result.UnprocessedItems;\n    if (!items || typeof items !== \"object\") {\n        return false;\n    }\n    const keys = Object.keys(items);\n    return keys.some(key => {\n        const value = items[key];\n        if (!Array.isArray(value)) {\n            return false;\n        }\n        return value.some(val => {\n            return val.PutRequest || val.DeleteRequest;\n        });\n    });\n};\n\nconst retry = async (input: BatchWriteResponse, results: BatchWriteResult): Promise<void> => {\n    if (!hasUnprocessedItems(input)) {\n        return;\n    }\n    const result = await input.next!();\n    await retry(result, results);\n};\n/**\n * Method is meant for batch writing to a single table.\n * It expects already prepared items for writing.\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 (\n    params: BatchWriteParams,\n    maxChunk = 25\n): Promise<BatchWriteResult> => {\n    const { items: collection, table } = params;\n    if (!table) {\n        console.log(\"No table provided.\");\n        return [];\n    } else if (collection.length === 0) {\n        return [];\n    }\n\n    const chunkedItems: BatchWriteItem[][] = lodashChunk(collection, maxChunk);\n    const results: BatchWriteResult = [];\n    for (const items of chunkedItems) {\n        const result = (await table.batchWrite(items, {\n            execute: true\n        })) as BatchWriteResponse;\n        results.push(result);\n        await retry(result, results);\n    }\n    return results;\n};\n"],"mappings":";;;;;;;AAAA,IAAAA,MAAA,GAAAC,sBAAA,CAAAC,OAAA;AASA,MAAMC,mBAAmB,GAAIC,MAA0B,IAAc;EACjE,IAAI,OAAOA,MAAM,CAACC,IAAI,KAAK,UAAU,EAAE;IACnC,OAAO,KAAK;EAChB;EACA,MAAMC,KAAK,GAAGF,MAAM,CAACG,gBAAgB;EACrC,IAAI,CAACD,KAAK,IAAI,OAAOA,KAAK,KAAK,QAAQ,EAAE;IACrC,OAAO,KAAK;EAChB;EACA,MAAME,IAAI,GAAGC,MAAM,CAACD,IAAI,CAACF,KAAK,CAAC;EAC/B,OAAOE,IAAI,CAACE,IAAI,CAACC,GAAG,IAAI;IACpB,MAAMC,KAAK,GAAGN,KAAK,CAACK,GAAG,CAAC;IACxB,IAAI,CAACE,KAAK,CAACC,OAAO,CAACF,KAAK,CAAC,EAAE;MACvB,OAAO,KAAK;IAChB;IACA,OAAOA,KAAK,CAACF,IAAI,CAACK,GAAG,IAAI;MACrB,OAAOA,GAAG,CAACC,UAAU,IAAID,GAAG,CAACE,aAAa;IAC9C,CAAC,CAAC;EACN,CAAC,CAAC;AACN,CAAC;AAED,MAAMC,KAAK,GAAG,MAAAA,CAAOC,KAAyB,EAAEC,OAAyB,KAAoB;EACzF,IAAI,CAACjB,mBAAmB,CAACgB,KAAK,CAAC,EAAE;IAC7B;EACJ;EACA,MAAMf,MAAM,GAAG,MAAMe,KAAK,CAACd,IAAI,CAAE,CAAC;EAClC,MAAMa,KAAK,CAACd,MAAM,EAAEgB,OAAO,CAAC;AAChC,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACO,MAAMC,aAAa,GAAG,MAAAA,CACzBC,MAAwB,EACxBC,QAAQ,GAAG,EAAE,KACe;EAC5B,MAAM;IAAEjB,KAAK,EAAEkB,UAAU;IAAEC;EAAM,CAAC,GAAGH,MAAM;EAC3C,IAAI,CAACG,KAAK,EAAE;IACRC,OAAO,CAACC,GAAG,CAAC,oBAAoB,CAAC;IACjC,OAAO,EAAE;EACb,CAAC,MAAM,IAAIH,UAAU,CAACI,MAAM,KAAK,CAAC,EAAE;IAChC,OAAO,EAAE;EACb;EAEA,MAAMC,YAAgC,GAAG,IAAAC,cAAW,EAACN,UAAU,EAAED,QAAQ,CAAC;EAC1E,MAAMH,OAAyB,GAAG,EAAE;EACpC,KAAK,MAAMd,KAAK,IAAIuB,YAAY,EAAE;IAC9B,MAAMzB,MAAM,GAAI,MAAMqB,KAAK,CAACM,UAAU,CAACzB,KAAK,EAAE;MAC1C0B,OAAO,EAAE;IACb,CAAC,CAAwB;IACzBZ,OAAO,CAACa,IAAI,CAAC7B,MAAM,CAAC;IACpB,MAAMc,KAAK,CAACd,MAAM,EAAEgB,OAAO,CAAC;EAChC;EACA,OAAOA,OAAO;AAClB,CAAC;AAACc,OAAA,CAAAb,aAAA,GAAAA,aAAA","ignoreList":[]}

package/utils/batch/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./batchRead";
+export * from "./batchWrite";
+export * from "./types";

package/utils/batch/index.js

@@ -0,0 +1,40 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+var _batchRead = require("./batchRead");
+Object.keys(_batchRead).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _batchRead[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _batchRead[key];
+    }
+  });
+});
+var _batchWrite = require("./batchWrite");
+Object.keys(_batchWrite).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _batchWrite[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _batchWrite[key];
+    }
+  });
+});
+var _types = require("./types");
+Object.keys(_types).forEach(function (key) {
+  if (key === "default" || key === "__esModule") return;
+  if (key in exports && exports[key] === _types[key]) return;
+  Object.defineProperty(exports, key, {
+    enumerable: true,
+    get: function () {
+      return _types[key];
+    }
+  });
+});
+
+//# sourceMappingURL=index.js.map

package/utils/batch/index.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_batchRead","require","Object","keys","forEach","key","exports","defineProperty","enumerable","get","_batchWrite","_types"],"sources":["index.ts"],"sourcesContent":["export * from \"./batchRead\";\nexport * from \"./batchWrite\";\nexport * from \"./types\";\n"],"mappings":";;;;;AAAA,IAAAA,UAAA,GAAAC,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAH,UAAA,EAAAI,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAL,UAAA,CAAAK,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAT,UAAA,CAAAK,GAAA;IAAA;EAAA;AAAA;AACA,IAAAK,WAAA,GAAAT,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAO,WAAA,EAAAN,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAK,WAAA,CAAAL,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAC,WAAA,CAAAL,GAAA;IAAA;EAAA;AAAA;AACA,IAAAM,MAAA,GAAAV,OAAA;AAAAC,MAAA,CAAAC,IAAA,CAAAQ,MAAA,EAAAP,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAA,GAAA,IAAAC,OAAA,IAAAA,OAAA,CAAAD,GAAA,MAAAM,MAAA,CAAAN,GAAA;EAAAH,MAAA,CAAAK,cAAA,CAAAD,OAAA,EAAAD,GAAA;IAAAG,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAE,MAAA,CAAAN,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/utils/batch/types.d.ts

@@ -0,0 +1,25 @@
+import type { WriteRequest } from "@webiny/aws-sdk/client-dynamodb";
+export interface BatchWriteResponse {
+    next?: () => Promise<BatchWriteResponse>;
+    $metadata: {
+        httpStatusCode: number;
+        requestId: string;
+        attempts: number;
+        totalRetryDelay: number;
+    };
+    UnprocessedItems?: {
+        [table: string]: WriteRequest[];
+    };
+}
+export type BatchWriteResult = BatchWriteResponse[];
+export interface IDeleteBatchItem {
+    PK: string;
+    SK: string;
+}
+export type IPutBatchItem<T extends Record<string, any> = Record<string, any>> = {
+    PK: string;
+    SK: string;
+} & T;
+export interface BatchWriteItem {
+    [key: string]: WriteRequest;
+}

package/utils/batch/types.js

@@ -0,0 +1,7 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+
+//# sourceMappingURL=types.js.map

package/utils/batch/types.js.map

@@ -0,0 +1 @@
+{"version":3,"names":[],"sources":["types.ts"],"sourcesContent":["import type { WriteRequest } from \"@webiny/aws-sdk/client-dynamodb\";\n\nexport interface BatchWriteResponse {\n    next?: () => Promise<BatchWriteResponse>;\n    $metadata: {\n        httpStatusCode: number;\n        requestId: string;\n        attempts: number;\n        totalRetryDelay: number;\n    };\n    UnprocessedItems?: {\n        [table: string]: WriteRequest[];\n    };\n}\n\nexport type BatchWriteResult = BatchWriteResponse[];\n\nexport interface IDeleteBatchItem {\n    PK: string;\n    SK: string;\n}\n\nexport type IPutBatchItem<T extends Record<string, any> = Record<string, any>> = {\n    PK: string;\n    SK: string;\n} & T;\n\nexport interface BatchWriteItem {\n    [key: string]: WriteRequest;\n}\n"],"mappings":"","ignoreList":[]}

package/utils/cleanup.d.ts

@@ -1,3 +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[];
+import type { Entity } from "../toolbox";
+export declare function cleanupItem<T>(entity: Entity<any>, item?: T | null, removeAttributes?: string[]): T | null;
+export declare function cleanupItems<T>(entity: Entity<any>, items: T[], removeAttributes?: string[]): T[];

package/utils/cleanup.js

@@ -1,53 +1,37 @@
 "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; }
-
+exports.cleanupItem = cleanupItem;
+exports.cleanupItems = cleanupItems;
 /**
  * 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 = []) => {
+const attributesToRemove = ["PK", "SK", "created", "_ct", "modified", "_mt", "entity", "_et", "GSI1_PK", "GSI1_SK", "GSI2_PK", "GSI2_SK", "GSI3_PK", "GSI3_SK", "GSI4_PK", "GSI4_SK", "GSI5_PK", "GSI5_SK", "TYPE"];
+function cleanupItem(entity, item, removeAttributes = []) {
   if (!item) {
     return null;
   }
-
-  const newItem = _objectSpread({}, item);
-
+  const newItem = {
+    ...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 = []) => {
+}
+function cleanupItems(entity, items, removeAttributes = []) {
   return items.map(item => cleanupItem(entity, item, removeAttributes));
-};
+}
 
-exports.cleanupItems = cleanupItems;
+//# sourceMappingURL=cleanup.js.map

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 type { Entity } from \"~/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    \"GSI2_PK\",\n    \"GSI2_SK\",\n    \"GSI3_PK\",\n    \"GSI3_SK\",\n    \"GSI4_PK\",\n    \"GSI4_SK\",\n    \"GSI5_PK\",\n    \"GSI5_SK\",\n    \"TYPE\"\n];\n\nexport function cleanupItem<T>(\n    entity: Entity<any>,\n    item?: T | 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[],\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,IAAI,EACJ,IAAI,EACJ,SAAS,EACT,KAAK,EACL,UAAU,EACV,KAAK,EACL,QAAQ,EACR,KAAK,EACL,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,SAAS,EACT,MAAM,CACT;AAEM,SAASC,WAAWA,CACvBC,MAAmB,EACnBC,IAAe,EACfC,gBAA0B,GAAG,EAAE,EACvB;EACR,IAAI,CAACD,IAAI,EAAE;IACP,OAAO,IAAI;EACf;EACA,MAAME,OAAO,GAAG;IACZ,GAAGF;EACP,CAAC;EACD,MAAMG,OAAO,GAAGN,kBAAkB,CAACO,MAAM,CAACH,gBAAgB,CAAC;EAC3D,MAAMI,UAAU,GAAGN,MAAM,CAACO,MAAM,CAACD,UAAU;EAC3C,KAAK,MAAME,GAAG,IAAIP,IAAI,EAAE;IACpB,IAAIA,IAAI,CAACQ,cAAc,CAACD,GAAG,CAAC,KAAK,KAAK,EAAE;MACpC;IACJ;IACA,IAAIF,UAAU,CAACE,GAAG,CAAC,IAAIJ,OAAO,CAACM,QAAQ,CAACF,GAAG,CAAC,KAAK,KAAK,EAAE;MACpD;IACJ;IACA,OAAOL,OAAO,CAACK,GAAG,CAAC;EACvB;EACA,OAAOL,OAAO;AAClB;AAEO,SAASQ,YAAYA,CACxBX,MAAmB,EACnBY,KAAU,EACVV,gBAA0B,GAAG,EAAE,EAC5B;EACH,OAAOU,KAAK,CAACC,GAAG,CAACZ,IAAI,IAAIF,WAAW,CAAIC,MAAM,EAAEC,IAAI,EAAEC,gBAAgB,CAAM,CAAC;AACjF","ignoreList":[]}

package/utils/count.d.ts

@@ -0,0 +1,2 @@
+import type { QueryAllParams } from "./query";
+export declare const count: (params: QueryAllParams) => Promise<number>;

package/utils/count.js

@@ -0,0 +1,23 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.count = void 0;
+const count = async params => {
+  const {
+    entity,
+    partitionKey,
+    options = {}
+  } = params;
+  const {
+    Count
+  } = await entity.query(partitionKey, {
+    ...options,
+    select: "count"
+  });
+  return Count || 0;
+};
+exports.count = count;
+
+//# sourceMappingURL=count.js.map

package/utils/count.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["count","params","entity","partitionKey","options","Count","query","select","exports"],"sources":["count.ts"],"sourcesContent":["import type { QueryAllParams } from \"~/utils/query\";\n\nexport const count = async (params: QueryAllParams): Promise<number> => {\n    const { entity, partitionKey, options = {} } = params;\n    const { Count } = await entity.query(partitionKey, { ...options, select: \"count\" });\n    return Count || 0;\n};\n"],"mappings":";;;;;;AAEO,MAAMA,KAAK,GAAG,MAAOC,MAAsB,IAAsB;EACpE,MAAM;IAAEC,MAAM;IAAEC,YAAY;IAAEC,OAAO,GAAG,CAAC;EAAE,CAAC,GAAGH,MAAM;EACrD,MAAM;IAAEI;EAAM,CAAC,GAAG,MAAMH,MAAM,CAACI,KAAK,CAACH,YAAY,EAAE;IAAE,GAAGC,OAAO;IAAEG,MAAM,EAAE;EAAQ,CAAC,CAAC;EACnF,OAAOF,KAAK,IAAI,CAAC;AACrB,CAAC;AAACG,OAAA,CAAAR,KAAA,GAAAA,KAAA","ignoreList":[]}

package/utils/createEntity.d.ts

@@ -0,0 +1,54 @@
+import type { AttributeDefinitions, Table } from "../toolbox";
+import { Entity } from "../toolbox";
+interface CreateStandardEntityParams {
+    table: Table<string, string, string>;
+    name: string;
+}
+export declare const createStandardEntity: (params: CreateStandardEntityParams) => Entity<any>;
+interface CreateLegacyEntityParams {
+    table: Table<string, string, string>;
+    name: string;
+    attributes?: AttributeDefinitions;
+}
+export declare const createLegacyEntity: (params: CreateLegacyEntityParams) => Entity<string, import("dynamodb-toolbox/dist/cjs/classes/Entity").Overlay, import("dynamodb-toolbox/dist/cjs/classes/Entity").Overlay, Table<string, string, string>, boolean, boolean, boolean, string, string, string, boolean, {
+    PK: {
+        partitionKey: true;
+    };
+    SK: {
+        sortKey: true;
+    };
+    GSI1_PK: {
+        type: "string";
+    };
+    GSI1_SK: {
+        type: "string";
+    };
+    TYPE: {
+        type: "string";
+    };
+}, {
+    PK: {
+        partitionKey: true;
+    };
+    SK: {
+        sortKey: true;
+    };
+    GSI1_PK: {
+        type: "string";
+    };
+    GSI1_SK: {
+        type: "string";
+    };
+    TYPE: {
+        type: "string";
+    };
+}, import("dynamodb-toolbox/dist/cjs/classes/Entity").ParsedAttributes<import("ts-toolbelt/out/Any/Key").Key>, any, {
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+}, {
+    [x: string]: any;
+    [x: number]: any;
+    [x: symbol]: any;
+}>;
+export {};