@webiny/db-dynamodb 5.41.4-beta.4 → 5.41.4-beta.5

package/README.md

@@ -14,6 +14,86 @@ For more information, please visit
 yarn add @webiny/db-dynamodb
 ```
 
+### Helper classes
+We have some classes that ease the use of dynamodb-toolbox.
+#### [Table](./src/utils/table/Table.ts)
+```typescript
+import { createTable } from "@webiny/db-dynamodb";
+
+const table = createTable({...params});
+const writer = table.createWriter(); // see TableWriteBatch
+const reader = table.createReader(); // see TableReadBatch
+
+const result = await table.scan({...params}); // see scan
+```
+
+#### [Entity](./src/utils/entity/Entity.ts)
+```typescript
+
+import { createEntity } from "@webiny/db-dynamodb";
+
+const entity = createEntity({...params});
+const writer = entity.createWriter(); // see EntityWriteBatch
+const reader = entity.createReader(); // see EntityReadBatch
+const tableWriter = entity.createTableWriter(); // see TableWriteBatch
+
+const getResult = await entity.get({...params}); // see get
+const getCleanResult = await entity.getClean({...params}); // see get
+const queryAllResult = await entity.queryAll({...params}); // see queryAllClean
+const queryOneResult = await entity.queryOne({...params}); // see queryOneClean
+const putResult = await entity.put({...params}); // see put
+
+```
+
+#### [EntityWriteBatch](./src/utils/entity/EntityWriteBatch.ts)
+```typescript
+import { createEntityWriteBatch } from "@webiny/db-dynamodb";
+
+const writer = createEntityWriteBatch({...params});
+
+writer.put({...item});
+writer.delete({...keys});
+writer.delete({...moreKeys});
+
+await writer.execute();
+```
+
+#### [EntityReadBatch](./src/utils/entity/EntityReadBatch.ts)
+```typescript
+import { createEntityReadBatch } from "@webiny/db-dynamodb";
+
+const reader = createEntityReadBatch({...params});
+
+reader.get({...keys});
+reader.get({...moreKeys});
+
+const result = await reader.execute();
+```
+#### [TableWriteBatch](./src/utils/table/TableWriteBatch.ts)
+```typescript
+import { createTableWriteBatch } from "@webiny/db-dynamodb";
+
+const writer = createTableWriteBatch({...params});
+
+writer.put(entity, {...item});
+writer.delete(entity, {...keys});
+writer.delete(entity, {...moreKeys});
+
+await writer.execute();
+```
+#### [TableReadBatch](./src/utils/table/TableReadBatch.ts)
+```typescript
+import {createTableReadBatch} from "@webiny/db-dynamodb";
+
+const reader = createTableReadBatch({...params});
+
+writer.get(entity, {...keys});
+writer.get(entity, {...moreKeys});
+
+const result = await reader.execute();
+```
+
+
 
 ### Helper functions
 We have a number [helper](./src/utils) functions that ease the use of either dynamodb-toolbox, filtering, sorting or just creating proper response.
@@ -64,4 +144,4 @@ This function accepts items (records) to be filtered, a definition of fields to
 #### [sort](./src/utils/sort.ts)
 Sort the DynamoDB records by given sort condition.
 
-This function accepts items (records) to be sorted, sort options (eg. createdBy_ASC, id_DESC, etc.) and a definitions of fields to sort by (not required by default if no field modification is required).
+This function accepts items (records) to be sorted, sort options (eg. createdBy_ASC, id_DESC, etc.) and a definitions of fields to sort by (not required by default if no field modification is required).

package/index.d.ts

@@ -1,4 +1,4 @@
 import { default as DynamoDbDriver } from "./DynamoDbDriver";
 export * from "./utils";
-export { DbItem } from "./types";
+export type { DbItem } from "./types";
 export { DynamoDbDriver };

package/index.js

@@ -5,15 +5,8 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 var _exportNames = {
-  DynamoDbDriver: true,
-  DbItem: true
+  DynamoDbDriver: true
 };
-Object.defineProperty(exports, "DbItem", {
-  enumerable: true,
-  get: function () {
-    return _types.DbItem;
-  }
-});
 Object.defineProperty(exports, "DynamoDbDriver", {
   enumerable: true,
   get: function () {
@@ -33,6 +26,5 @@ Object.keys(_utils).forEach(function (key) {
     }
   });
 });
-var _types = require("./types");
 
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_DynamoDbDriver","_interopRequireDefault","require","_utils","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get","_types"],"sources":["index.ts"],"sourcesContent":["import { default as DynamoDbDriver } from \"./DynamoDbDriver\";\n\nexport * from \"./utils\";\nexport { DbItem } from \"./types\";\n\nexport { DynamoDbDriver };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAF,MAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,MAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,MAAA,CAAAI,GAAA;IAAA;EAAA;AAAA;AACA,IAAAS,MAAA,GAAAd,OAAA","ignoreList":[]}
+{"version":3,"names":["_DynamoDbDriver","_interopRequireDefault","require","_utils","Object","keys","forEach","key","prototype","hasOwnProperty","call","_exportNames","exports","defineProperty","enumerable","get"],"sources":["index.ts"],"sourcesContent":["import { default as DynamoDbDriver } from \"./DynamoDbDriver\";\n\nexport * from \"./utils\";\nexport type { DbItem } from \"./types\";\n\nexport { DynamoDbDriver };\n"],"mappings":";;;;;;;;;;;;;;;AAAA,IAAAA,eAAA,GAAAC,sBAAA,CAAAC,OAAA;AAEA,IAAAC,MAAA,GAAAD,OAAA;AAAAE,MAAA,CAAAC,IAAA,CAAAF,MAAA,EAAAG,OAAA,WAAAC,GAAA;EAAA,IAAAA,GAAA,kBAAAA,GAAA;EAAA,IAAAH,MAAA,CAAAI,SAAA,CAAAC,cAAA,CAAAC,IAAA,CAAAC,YAAA,EAAAJ,GAAA;EAAA,IAAAA,GAAA,IAAAK,OAAA,IAAAA,OAAA,CAAAL,GAAA,MAAAJ,MAAA,CAAAI,GAAA;EAAAH,MAAA,CAAAS,cAAA,CAAAD,OAAA,EAAAL,GAAA;IAAAO,UAAA;IAAAC,GAAA,WAAAA,CAAA;MAAA,OAAAZ,MAAA,CAAAI,GAAA;IAAA;EAAA;AAAA","ignoreList":[]}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@webiny/db-dynamodb",
-	"version": "5.41.4-beta.4",
+	"version": "5.41.4-beta.5",
 	"main": "index.js",
 	"repository": {
 		"type": "git",
@@ -10,13 +10,12 @@
 	"author": "Webiny Ltd",
 	"license": "MIT",
 	"dependencies": {
-		"@webiny/api": "5.41.4-beta.4",
-		"@webiny/aws-sdk": "5.41.4-beta.4",
-		"@webiny/db": "5.41.4-beta.4",
-		"@webiny/error": "5.41.4-beta.4",
-		"@webiny/handler-db": "5.41.4-beta.4",
-		"@webiny/plugins": "5.41.4-beta.4",
-		"@webiny/utils": "5.41.4-beta.4",
+		"@webiny/api": "5.41.4-beta.5",
+		"@webiny/aws-sdk": "5.41.4-beta.5",
+		"@webiny/db": "5.41.4-beta.5",
+		"@webiny/error": "5.41.4-beta.5",
+		"@webiny/plugins": "5.41.4-beta.5",
+		"@webiny/utils": "5.41.4-beta.5",
 		"date-fns": "2.29.3",
 		"dot-prop": "6.0.1",
 		"dynamodb-toolbox": "0.9.2",
@@ -27,8 +26,8 @@
 		"@babel/cli": "7.24.1",
 		"@babel/core": "7.24.3",
 		"@types/is-number": "7.0.3",
-		"@webiny/cli": "5.41.4-beta.4",
-		"@webiny/project-utils": "5.41.4-beta.4",
+		"@webiny/cli": "5.41.4-beta.5",
+		"@webiny/project-utils": "5.41.4-beta.5",
 		"jest": "29.7.0",
 		"jest-dynalite": "3.6.1",
 		"rimraf": "5.0.5",
@@ -43,5 +42,5 @@
 		"build": "yarn webiny run build",
 		"watch": "yarn webiny run watch"
 	},
-	"gitHead": "1bd23a34dd4fa6095946a1eb433741ac7da7cbee"
+	"gitHead": "e3f273ea63f0c426c2ddde0794d303bc8ffaa6c4"
 }

package/toolbox.d.ts

@@ -1,3 +1,3 @@
 export { Entity, Table } from "dynamodb-toolbox";
 export type { DynamoDBTypes, ScanOptions, TableDef, TableConstructor } from "dynamodb-toolbox/dist/cjs/classes/Table";
-export type { AttributeDefinition, EntityQueryOptions, AttributeDefinitions } from "dynamodb-toolbox/dist/cjs/classes/Entity";
+export type { Readonly, EntityConstructor, AttributeDefinition, EntityQueryOptions, AttributeDefinitions } from "dynamodb-toolbox/dist/cjs/classes/Entity";

package/toolbox.js.map

@@ -1 +1 @@
-{"version":3,"names":["_dynamodbToolbox","require"],"sources":["toolbox.ts"],"sourcesContent":["export { Entity, Table } from \"dynamodb-toolbox\";\nexport type {\n    DynamoDBTypes,\n    ScanOptions,\n    TableDef,\n    TableConstructor\n} from \"dynamodb-toolbox/dist/cjs/classes/Table\";\nexport type {\n    AttributeDefinition,\n    EntityQueryOptions,\n    AttributeDefinitions\n} from \"dynamodb-toolbox/dist/cjs/classes/Entity\";\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA","ignoreList":[]}
+{"version":3,"names":["_dynamodbToolbox","require"],"sources":["toolbox.ts"],"sourcesContent":["export { Entity, Table } from \"dynamodb-toolbox\";\nexport type {\n    DynamoDBTypes,\n    ScanOptions,\n    TableDef,\n    TableConstructor\n} from \"dynamodb-toolbox/dist/cjs/classes/Table\";\nexport type {\n    Readonly,\n    EntityConstructor,\n    AttributeDefinition,\n    EntityQueryOptions,\n    AttributeDefinitions\n} from \"dynamodb-toolbox/dist/cjs/classes/Entity\";\n"],"mappings":";;;;;;;;;;;;;;;;;AAAA,IAAAA,gBAAA,GAAAC,OAAA","ignoreList":[]}

package/utils/{batchRead.d.ts → batch/batchRead.d.ts}

@@ -1,4 +1,4 @@
-import { TableDef } from "../toolbox";
+import { TableDef } from "../../toolbox";
 import { GenericRecord } from "@webiny/api/types";
 export interface BatchReadItem {
     Table?: TableDef;

package/utils/batch/batchWrite.d.ts

@@ -0,0 +1,13 @@
+import { TableDef } from "../../toolbox";
+import { BatchWriteItem, BatchWriteResult } from "./types";
+export interface BatchWriteParams {
+    table?: TableDef;
+    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.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 { TableDef } from \"~/toolbox\";\nimport { BatchWriteItem, BatchWriteResponse, BatchWriteResult } from \"./types\";\n\nexport interface BatchWriteParams {\n    table?: TableDef;\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/delete.d.ts

@@ -1,10 +1,10 @@
 import { Entity } from "../toolbox";
-interface Params {
+export interface IDeleteItemKeys {
+    PK: string;
+    SK: string;
+}
+export interface IDeleteItemParams {
     entity: Entity;
-    keys: {
-        PK: string;
-        SK: string;
-    };
+    keys: IDeleteItemKeys;
 }
-export declare const deleteItem: (params: Params) => Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput>;
-export {};
+export declare const deleteItem: (params: IDeleteItemParams) => Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput>;

package/utils/delete.js.map

@@ -1 +1 @@
-{"version":3,"names":["deleteItem","params","entity","keys","delete","execute","exports"],"sources":["delete.ts"],"sourcesContent":["import { Entity } from \"~/toolbox\";\n\ninterface Params {\n    entity: Entity;\n    keys: {\n        PK: string;\n        SK: string;\n    };\n}\n\nexport const deleteItem = async (params: Params) => {\n    const { entity, keys } = params;\n\n    return await entity.delete(keys, {\n        execute: true\n    });\n};\n"],"mappings":";;;;;;AAUO,MAAMA,UAAU,GAAG,MAAOC,MAAc,IAAK;EAChD,MAAM;IAAEC,MAAM;IAAEC;EAAK,CAAC,GAAGF,MAAM;EAE/B,OAAO,MAAMC,MAAM,CAACE,MAAM,CAACD,IAAI,EAAE;IAC7BE,OAAO,EAAE;EACb,CAAC,CAAC;AACN,CAAC;AAACC,OAAA,CAAAN,UAAA,GAAAA,UAAA","ignoreList":[]}
+{"version":3,"names":["deleteItem","params","entity","keys","delete","execute","exports"],"sources":["delete.ts"],"sourcesContent":["import { Entity } from \"~/toolbox\";\nexport interface IDeleteItemKeys {\n    PK: string;\n    SK: string;\n}\nexport interface IDeleteItemParams {\n    entity: Entity;\n    keys: IDeleteItemKeys;\n}\n\nexport const deleteItem = async (params: IDeleteItemParams) => {\n    const { entity, keys } = params;\n\n    return await entity.delete(keys, {\n        execute: true\n    });\n};\n"],"mappings":";;;;;;AAUO,MAAMA,UAAU,GAAG,MAAOC,MAAyB,IAAK;EAC3D,MAAM;IAAEC,MAAM;IAAEC;EAAK,CAAC,GAAGF,MAAM;EAE/B,OAAO,MAAMC,MAAM,CAACE,MAAM,CAACD,IAAI,EAAE;IAC7BE,OAAO,EAAE;EACb,CAAC,CAAC;AACN,CAAC;AAACC,OAAA,CAAAN,UAAA,GAAAA,UAAA","ignoreList":[]}

package/utils/entity/Entity.d.ts

@@ -0,0 +1,25 @@
+import type { AttributeDefinitions, EntityConstructor as BaseEntityConstructor, Readonly, TableDef } from "../../toolbox";
+import { Entity as BaseEntity } from "../../toolbox";
+import type { ITableWriteBatch } from "../table/types";
+import type { IEntity, IEntityQueryAllParams, IEntityQueryOneParams, IEntityReadBatch, IEntityWriteBatch } from "./types";
+import type { IPutParamsItem } from "../put";
+import { put } from "../put";
+import type { GetRecordParamsKeys } from "../get";
+import { get, getClean } from "../get";
+import type { IDeleteItemKeys } from "../delete";
+import { deleteItem } from "../delete";
+export type EntityConstructor<T extends Readonly<AttributeDefinitions> = Readonly<AttributeDefinitions>> = BaseEntityConstructor<TableDef, string, true, true, true, "created", "modified", "entity", false, T>;
+export declare class Entity implements IEntity {
+    readonly entity: BaseEntity;
+    constructor(params: EntityConstructor);
+    createEntityReader(): IEntityReadBatch;
+    createEntityWriter(): IEntityWriteBatch;
+    createTableWriter(): ITableWriteBatch;
+    put(item: IPutParamsItem): ReturnType<typeof put>;
+    get<T>(keys: GetRecordParamsKeys): ReturnType<typeof get<T>>;
+    getClean<T>(keys: GetRecordParamsKeys): ReturnType<typeof getClean<T>>;
+    delete(keys: IDeleteItemKeys): ReturnType<typeof deleteItem>;
+    queryOne<T>(params: IEntityQueryOneParams): Promise<T | null>;
+    queryAll<T>(params: IEntityQueryAllParams): Promise<T[]>;
+}
+export declare const createEntity: (params: EntityConstructor) => IEntity;

package/utils/entity/Entity.js

@@ -0,0 +1,77 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEntity = exports.Entity = void 0;
+var _toolbox = require("../../toolbox");
+var _put = require("../put");
+var _get = require("../get");
+var _delete = require("../delete");
+var _EntityReadBatch = require("./EntityReadBatch");
+var _EntityWriteBatch = require("./EntityWriteBatch");
+var _TableWriteBatch = require("../table/TableWriteBatch");
+var _query = require("../query");
+class Entity {
+  constructor(params) {
+    this.entity = new _toolbox.Entity(params);
+  }
+  createEntityReader() {
+    return (0, _EntityReadBatch.createEntityReadBatch)({
+      entity: this.entity
+    });
+  }
+  createEntityWriter() {
+    return (0, _EntityWriteBatch.createEntityWriteBatch)({
+      entity: this.entity
+    });
+  }
+  createTableWriter() {
+    return (0, _TableWriteBatch.createTableWriteBatch)({
+      table: this.entity.table
+    });
+  }
+  async put(item) {
+    return (0, _put.put)({
+      entity: this.entity,
+      item
+    });
+  }
+  async get(keys) {
+    return (0, _get.get)({
+      entity: this.entity,
+      keys
+    });
+  }
+  async getClean(keys) {
+    return (0, _get.getClean)({
+      entity: this.entity,
+      keys
+    });
+  }
+  async delete(keys) {
+    return (0, _delete.deleteItem)({
+      entity: this.entity,
+      keys
+    });
+  }
+  queryOne(params) {
+    return (0, _query.queryOneClean)({
+      ...params,
+      entity: this.entity
+    });
+  }
+  queryAll(params) {
+    return (0, _query.queryAllClean)({
+      ...params,
+      entity: this.entity
+    });
+  }
+}
+exports.Entity = Entity;
+const createEntity = params => {
+  return new Entity(params);
+};
+exports.createEntity = createEntity;
+
+//# sourceMappingURL=Entity.js.map

package/utils/entity/Entity.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_toolbox","require","_put","_get","_delete","_EntityReadBatch","_EntityWriteBatch","_TableWriteBatch","_query","Entity","constructor","params","entity","BaseEntity","createEntityReader","createEntityReadBatch","createEntityWriter","createEntityWriteBatch","createTableWriter","createTableWriteBatch","table","put","item","get","keys","getClean","delete","deleteItem","queryOne","queryOneClean","queryAll","queryAllClean","exports","createEntity"],"sources":["Entity.ts"],"sourcesContent":["import type {\n    AttributeDefinitions,\n    EntityConstructor as BaseEntityConstructor,\n    Readonly,\n    TableDef\n} from \"~/toolbox\";\nimport { Entity as BaseEntity } from \"~/toolbox\";\nimport type { ITableWriteBatch } from \"../table/types\";\nimport type {\n    IEntity,\n    IEntityQueryAllParams,\n    IEntityQueryOneParams,\n    IEntityReadBatch,\n    IEntityWriteBatch\n} from \"./types\";\nimport type { IPutParamsItem } from \"../put\";\nimport { put } from \"../put\";\nimport type { GetRecordParamsKeys } from \"../get\";\nimport { get, getClean } from \"../get\";\nimport type { IDeleteItemKeys } from \"../delete\";\nimport { deleteItem } from \"../delete\";\nimport { createEntityReadBatch } from \"./EntityReadBatch\";\nimport { createEntityWriteBatch } from \"./EntityWriteBatch\";\nimport { createTableWriteBatch } from \"~/utils/table/TableWriteBatch\";\nimport { queryAllClean, queryOneClean } from \"../query\";\n\nexport type EntityConstructor<\n    T extends Readonly<AttributeDefinitions> = Readonly<AttributeDefinitions>\n> = BaseEntityConstructor<\n    TableDef,\n    string,\n    true,\n    true,\n    true,\n    \"created\",\n    \"modified\",\n    \"entity\",\n    false,\n    T\n>;\n\nexport class Entity implements IEntity {\n    public readonly entity: BaseEntity;\n\n    public constructor(params: EntityConstructor) {\n        this.entity = new BaseEntity(params);\n    }\n\n    public createEntityReader(): IEntityReadBatch {\n        return createEntityReadBatch({\n            entity: this.entity\n        });\n    }\n\n    public createEntityWriter(): IEntityWriteBatch {\n        return createEntityWriteBatch({\n            entity: this.entity\n        });\n    }\n\n    public createTableWriter(): ITableWriteBatch {\n        return createTableWriteBatch({\n            table: this.entity.table as TableDef\n        });\n    }\n\n    public async put(item: IPutParamsItem): ReturnType<typeof put> {\n        return put({\n            entity: this.entity,\n            item\n        });\n    }\n\n    public async get<T>(keys: GetRecordParamsKeys): ReturnType<typeof get<T>> {\n        return get<T>({\n            entity: this.entity,\n            keys\n        });\n    }\n\n    public async getClean<T>(keys: GetRecordParamsKeys): ReturnType<typeof getClean<T>> {\n        return getClean<T>({\n            entity: this.entity,\n            keys\n        });\n    }\n\n    public async delete(keys: IDeleteItemKeys): ReturnType<typeof deleteItem> {\n        return deleteItem({\n            entity: this.entity,\n            keys\n        });\n    }\n\n    public queryOne<T>(params: IEntityQueryOneParams): Promise<T | null> {\n        return queryOneClean<T>({\n            ...params,\n            entity: this.entity\n        });\n    }\n\n    public queryAll<T>(params: IEntityQueryAllParams): Promise<T[]> {\n        return queryAllClean<T>({\n            ...params,\n            entity: this.entity\n        });\n    }\n}\n\nexport const createEntity = (params: EntityConstructor): IEntity => {\n    return new Entity(params);\n};\n"],"mappings":";;;;;;AAMA,IAAAA,QAAA,GAAAC,OAAA;AAUA,IAAAC,IAAA,GAAAD,OAAA;AAEA,IAAAE,IAAA,GAAAF,OAAA;AAEA,IAAAG,OAAA,GAAAH,OAAA;AACA,IAAAI,gBAAA,GAAAJ,OAAA;AACA,IAAAK,iBAAA,GAAAL,OAAA;AACA,IAAAM,gBAAA,GAAAN,OAAA;AACA,IAAAO,MAAA,GAAAP,OAAA;AAiBO,MAAMQ,MAAM,CAAoB;EAG5BC,WAAWA,CAACC,MAAyB,EAAE;IAC1C,IAAI,CAACC,MAAM,GAAG,IAAIC,eAAU,CAACF,MAAM,CAAC;EACxC;EAEOG,kBAAkBA,CAAA,EAAqB;IAC1C,OAAO,IAAAC,sCAAqB,EAAC;MACzBH,MAAM,EAAE,IAAI,CAACA;IACjB,CAAC,CAAC;EACN;EAEOI,kBAAkBA,CAAA,EAAsB;IAC3C,OAAO,IAAAC,wCAAsB,EAAC;MAC1BL,MAAM,EAAE,IAAI,CAACA;IACjB,CAAC,CAAC;EACN;EAEOM,iBAAiBA,CAAA,EAAqB;IACzC,OAAO,IAAAC,sCAAqB,EAAC;MACzBC,KAAK,EAAE,IAAI,CAACR,MAAM,CAACQ;IACvB,CAAC,CAAC;EACN;EAEA,MAAaC,GAAGA,CAACC,IAAoB,EAA0B;IAC3D,OAAO,IAAAD,QAAG,EAAC;MACPT,MAAM,EAAE,IAAI,CAACA,MAAM;MACnBU;IACJ,CAAC,CAAC;EACN;EAEA,MAAaC,GAAGA,CAAIC,IAAyB,EAA6B;IACtE,OAAO,IAAAD,QAAG,EAAI;MACVX,MAAM,EAAE,IAAI,CAACA,MAAM;MACnBY;IACJ,CAAC,CAAC;EACN;EAEA,MAAaC,QAAQA,CAAID,IAAyB,EAAkC;IAChF,OAAO,IAAAC,aAAQ,EAAI;MACfb,MAAM,EAAE,IAAI,CAACA,MAAM;MACnBY;IACJ,CAAC,CAAC;EACN;EAEA,MAAaE,MAAMA,CAACF,IAAqB,EAAiC;IACtE,OAAO,IAAAG,kBAAU,EAAC;MACdf,MAAM,EAAE,IAAI,CAACA,MAAM;MACnBY;IACJ,CAAC,CAAC;EACN;EAEOI,QAAQA,CAAIjB,MAA6B,EAAqB;IACjE,OAAO,IAAAkB,oBAAa,EAAI;MACpB,GAAGlB,MAAM;MACTC,MAAM,EAAE,IAAI,CAACA;IACjB,CAAC,CAAC;EACN;EAEOkB,QAAQA,CAAInB,MAA6B,EAAgB;IAC5D,OAAO,IAAAoB,oBAAa,EAAI;MACpB,GAAGpB,MAAM;MACTC,MAAM,EAAE,IAAI,CAACA;IACjB,CAAC,CAAC;EACN;AACJ;AAACoB,OAAA,CAAAvB,MAAA,GAAAA,MAAA;AAEM,MAAMwB,YAAY,GAAItB,MAAyB,IAAc;EAChE,OAAO,IAAIF,MAAM,CAACE,MAAM,CAAC;AAC7B,CAAC;AAACqB,OAAA,CAAAC,YAAA,GAAAA,YAAA","ignoreList":[]}

package/utils/entity/EntityReadBatch.d.ts

@@ -0,0 +1,17 @@
+import type { IPutBatchItem } from "../batch/types";
+import type { IEntityReadBatch, IEntityReadBatchKey } from "./types";
+import { GenericRecord } from "@webiny/api/types";
+import type { EntityOption } from "./getEntity";
+export interface IEntityReadBatchParams {
+    entity: EntityOption;
+    read?: IPutBatchItem[];
+}
+export declare class EntityReadBatch implements IEntityReadBatch {
+    private readonly entity;
+    private readonly builder;
+    private readonly _items;
+    constructor(params: IEntityReadBatchParams);
+    get(input: IEntityReadBatchKey | IEntityReadBatchKey[]): void;
+    execute<T = GenericRecord>(): Promise<T[]>;
+}
+export declare const createEntityReadBatch: (params: IEntityReadBatchParams) => IEntityReadBatch;

package/utils/entity/EntityReadBatch.js

@@ -0,0 +1,41 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEntityReadBatch = exports.EntityReadBatch = void 0;
+var _batchRead = require("../batch/batchRead");
+var _EntityReadBatchBuilder = require("./EntityReadBatchBuilder");
+var _getEntity = require("./getEntity");
+class EntityReadBatch {
+  _items = [];
+  constructor(params) {
+    this.entity = (0, _getEntity.getEntity)(params.entity);
+    this.builder = (0, _EntityReadBatchBuilder.createEntityReadBatchBuilder)(this.entity);
+    for (const item of params.read || []) {
+      this.get(item);
+    }
+  }
+  get(input) {
+    if (Array.isArray(input)) {
+      this._items.push(...input.map(item => {
+        return this.builder.get(item);
+      }));
+      return;
+    }
+    this._items.push(this.builder.get(input));
+  }
+  async execute() {
+    return await (0, _batchRead.batchReadAll)({
+      table: this.entity.table,
+      items: this._items
+    });
+  }
+}
+exports.EntityReadBatch = EntityReadBatch;
+const createEntityReadBatch = params => {
+  return new EntityReadBatch(params);
+};
+exports.createEntityReadBatch = createEntityReadBatch;
+
+//# sourceMappingURL=EntityReadBatch.js.map

package/utils/entity/EntityReadBatch.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_batchRead","require","_EntityReadBatchBuilder","_getEntity","EntityReadBatch","_items","constructor","params","entity","getEntity","builder","createEntityReadBatchBuilder","item","read","get","input","Array","isArray","push","map","execute","batchReadAll","table","items","exports","createEntityReadBatch"],"sources":["EntityReadBatch.ts"],"sourcesContent":["import type { IPutBatchItem } from \"~/utils/batch/types\";\nimport type {\n    IEntityReadBatch,\n    IEntityReadBatchBuilder,\n    IEntityReadBatchBuilderGetResponse,\n    IEntityReadBatchKey\n} from \"./types\";\nimport type { TableDef } from \"~/toolbox\";\nimport type { Entity as ToolboxEntity } from \"~/toolbox\";\nimport { batchReadAll } from \"~/utils/batch/batchRead\";\nimport { GenericRecord } from \"@webiny/api/types\";\nimport { createEntityReadBatchBuilder } from \"./EntityReadBatchBuilder\";\nimport type { EntityOption } from \"./getEntity\";\nimport { getEntity } from \"./getEntity\";\n\nexport interface IEntityReadBatchParams {\n    entity: EntityOption;\n    read?: IPutBatchItem[];\n}\n\nexport class EntityReadBatch implements IEntityReadBatch {\n    private readonly entity: ToolboxEntity;\n    private readonly builder: IEntityReadBatchBuilder;\n    private readonly _items: IEntityReadBatchBuilderGetResponse[] = [];\n\n    public constructor(params: IEntityReadBatchParams) {\n        this.entity = getEntity(params.entity);\n        this.builder = createEntityReadBatchBuilder(this.entity);\n        for (const item of params.read || []) {\n            this.get(item);\n        }\n    }\n    public get(input: IEntityReadBatchKey | IEntityReadBatchKey[]): void {\n        if (Array.isArray(input)) {\n            this._items.push(\n                ...input.map(item => {\n                    return this.builder.get(item);\n                })\n            );\n            return;\n        }\n        this._items.push(this.builder.get(input));\n    }\n\n    public async execute<T = GenericRecord>() {\n        return await batchReadAll<T>({\n            table: this.entity.table as TableDef,\n            items: this._items\n        });\n    }\n}\n\nexport const createEntityReadBatch = (params: IEntityReadBatchParams): IEntityReadBatch => {\n    return new EntityReadBatch(params);\n};\n"],"mappings":";;;;;;AASA,IAAAA,UAAA,GAAAC,OAAA;AAEA,IAAAC,uBAAA,GAAAD,OAAA;AAEA,IAAAE,UAAA,GAAAF,OAAA;AAOO,MAAMG,eAAe,CAA6B;EAGpCC,MAAM,GAAyC,EAAE;EAE3DC,WAAWA,CAACC,MAA8B,EAAE;IAC/C,IAAI,CAACC,MAAM,GAAG,IAAAC,oBAAS,EAACF,MAAM,CAACC,MAAM,CAAC;IACtC,IAAI,CAACE,OAAO,GAAG,IAAAC,oDAA4B,EAAC,IAAI,CAACH,MAAM,CAAC;IACxD,KAAK,MAAMI,IAAI,IAAIL,MAAM,CAACM,IAAI,IAAI,EAAE,EAAE;MAClC,IAAI,CAACC,GAAG,CAACF,IAAI,CAAC;IAClB;EACJ;EACOE,GAAGA,CAACC,KAAkD,EAAQ;IACjE,IAAIC,KAAK,CAACC,OAAO,CAACF,KAAK,CAAC,EAAE;MACtB,IAAI,CAACV,MAAM,CAACa,IAAI,CACZ,GAAGH,KAAK,CAACI,GAAG,CAACP,IAAI,IAAI;QACjB,OAAO,IAAI,CAACF,OAAO,CAACI,GAAG,CAACF,IAAI,CAAC;MACjC,CAAC,CACL,CAAC;MACD;IACJ;IACA,IAAI,CAACP,MAAM,CAACa,IAAI,CAAC,IAAI,CAACR,OAAO,CAACI,GAAG,CAACC,KAAK,CAAC,CAAC;EAC7C;EAEA,MAAaK,OAAOA,CAAA,EAAsB;IACtC,OAAO,MAAM,IAAAC,uBAAY,EAAI;MACzBC,KAAK,EAAE,IAAI,CAACd,MAAM,CAACc,KAAiB;MACpCC,KAAK,EAAE,IAAI,CAAClB;IAChB,CAAC,CAAC;EACN;AACJ;AAACmB,OAAA,CAAApB,eAAA,GAAAA,eAAA;AAEM,MAAMqB,qBAAqB,GAAIlB,MAA8B,IAAuB;EACvF,OAAO,IAAIH,eAAe,CAACG,MAAM,CAAC;AACtC,CAAC;AAACiB,OAAA,CAAAC,qBAAA,GAAAA,qBAAA","ignoreList":[]}

package/utils/entity/EntityReadBatchBuilder.d.ts

@@ -0,0 +1,10 @@
+import type { Entity as ToolboxEntity } from "../../toolbox";
+import type { IEntityReadBatchBuilder, IEntityReadBatchBuilderGetResponse, IEntityReadBatchKey } from "./types";
+import { Entity } from "./Entity";
+import type { EntityOption } from "./getEntity";
+export declare class EntityReadBatchBuilder implements IEntityReadBatchBuilder {
+    private readonly entity;
+    constructor(entity: EntityOption);
+    get(item: IEntityReadBatchKey): IEntityReadBatchBuilderGetResponse;
+}
+export declare const createEntityReadBatchBuilder: (entity: ToolboxEntity | Entity) => IEntityReadBatchBuilder;

package/utils/entity/EntityReadBatchBuilder.js

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createEntityReadBatchBuilder = exports.EntityReadBatchBuilder = void 0;
+var _error = require("@webiny/error");
+var _getEntity = require("./getEntity");
+class EntityReadBatchBuilder {
+  constructor(entity) {
+    this.entity = (0, _getEntity.getEntity)(entity);
+  }
+  get(item) {
+    const result = this.entity.getBatch(item);
+    if (!result.Table) {
+      throw new _error.WebinyError(`No table provided for entity ${this.entity.name}.`);
+    } else if (!result.Key) {
+      throw new _error.WebinyError(`No key provided for entity ${this.entity.name}.`);
+    }
+    return result;
+  }
+}
+exports.EntityReadBatchBuilder = EntityReadBatchBuilder;
+const createEntityReadBatchBuilder = entity => {
+  return new EntityReadBatchBuilder(entity);
+};
+exports.createEntityReadBatchBuilder = createEntityReadBatchBuilder;
+
+//# sourceMappingURL=EntityReadBatchBuilder.js.map

package/utils/entity/EntityReadBatchBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["_error","require","_getEntity","EntityReadBatchBuilder","constructor","entity","getEntity","get","item","result","getBatch","Table","WebinyError","name","Key","exports","createEntityReadBatchBuilder"],"sources":["EntityReadBatchBuilder.ts"],"sourcesContent":["import type { Entity as ToolboxEntity } from \"~/toolbox\";\nimport type {\n    IEntityReadBatchBuilder,\n    IEntityReadBatchBuilderGetResponse,\n    IEntityReadBatchKey\n} from \"./types\";\nimport { WebinyError } from \"@webiny/error\";\nimport { Entity } from \"./Entity\";\nimport type { EntityOption } from \"./getEntity\";\nimport { getEntity } from \"./getEntity\";\n\nexport class EntityReadBatchBuilder implements IEntityReadBatchBuilder {\n    private readonly entity: ToolboxEntity;\n\n    public constructor(entity: EntityOption) {\n        this.entity = getEntity(entity);\n    }\n\n    public get(item: IEntityReadBatchKey): IEntityReadBatchBuilderGetResponse {\n        const result = this.entity.getBatch(item);\n        if (!result.Table) {\n            throw new WebinyError(`No table provided for entity ${this.entity.name}.`);\n        } else if (!result.Key) {\n            throw new WebinyError(`No key provided for entity ${this.entity.name}.`);\n        }\n        return result as IEntityReadBatchBuilderGetResponse;\n    }\n}\n\nexport const createEntityReadBatchBuilder = (\n    entity: ToolboxEntity | Entity\n): IEntityReadBatchBuilder => {\n    return new EntityReadBatchBuilder(entity);\n};\n"],"mappings":";;;;;;AAMA,IAAAA,MAAA,GAAAC,OAAA;AAGA,IAAAC,UAAA,GAAAD,OAAA;AAEO,MAAME,sBAAsB,CAAoC;EAG5DC,WAAWA,CAACC,MAAoB,EAAE;IACrC,IAAI,CAACA,MAAM,GAAG,IAAAC,oBAAS,EAACD,MAAM,CAAC;EACnC;EAEOE,GAAGA,CAACC,IAAyB,EAAsC;IACtE,MAAMC,MAAM,GAAG,IAAI,CAACJ,MAAM,CAACK,QAAQ,CAACF,IAAI,CAAC;IACzC,IAAI,CAACC,MAAM,CAACE,KAAK,EAAE;MACf,MAAM,IAAIC,kBAAW,CAAE,gCAA+B,IAAI,CAACP,MAAM,CAACQ,IAAK,GAAE,CAAC;IAC9E,CAAC,MAAM,IAAI,CAACJ,MAAM,CAACK,GAAG,EAAE;MACpB,MAAM,IAAIF,kBAAW,CAAE,8BAA6B,IAAI,CAACP,MAAM,CAACQ,IAAK,GAAE,CAAC;IAC5E;IACA,OAAOJ,MAAM;EACjB;AACJ;AAACM,OAAA,CAAAZ,sBAAA,GAAAA,sBAAA;AAEM,MAAMa,4BAA4B,GACrCX,MAA8B,IACJ;EAC1B,OAAO,IAAIF,sBAAsB,CAACE,MAAM,CAAC;AAC7C,CAAC;AAACU,OAAA,CAAAC,4BAAA,GAAAA,4BAAA","ignoreList":[]}

package/utils/entity/EntityWriteBatch.d.ts

@@ -0,0 +1,22 @@
+import type { BatchWriteItem, BatchWriteResult, IDeleteBatchItem, IPutBatchItem } from "../batch/types";
+import type { IEntityWriteBatch } from "./types";
+import type { ITableWriteBatch } from "../table/types";
+import type { EntityOption } from "./getEntity";
+export interface IEntityWriteBatchParams {
+    entity: EntityOption;
+    put?: IPutBatchItem[];
+    delete?: IDeleteBatchItem[];
+}
+export declare class EntityWriteBatch implements IEntityWriteBatch {
+    private readonly entity;
+    private readonly _items;
+    private readonly builder;
+    get total(): number;
+    get items(): BatchWriteItem[];
+    constructor(params: IEntityWriteBatchParams);
+    put<T extends Record<string, any>>(item: IPutBatchItem<T>): void;
+    delete(item: IDeleteBatchItem): void;
+    combine(items: BatchWriteItem[]): ITableWriteBatch;
+    execute(): Promise<BatchWriteResult>;
+}
+export declare const createEntityWriteBatch: (params: IEntityWriteBatchParams) => IEntityWriteBatch;