dynoquery 0.1.18 → 0.1.19

package/README.md

@@ -182,6 +182,35 @@ mouse.price = 50;
 await mouse.save();
 ```
 
+### 4. Batch Operations
+
+DynoQuery provides `batchWrite` and `batchRead` for processing multiple items across partitions.
+
+```typescript
+// 1. Batch Write (Create/Replace multiple items)
+const user1 = db.User('john', 'METADATA');
+user1.name = 'John Doe';
+
+const user2 = db.User('jane', 'METADATA');
+user2.name = 'Jane Doe';
+
+await db.batchWrite([user1, user2]);
+
+// 2. Batch Read (Fetch multiple items or index queries)
+const userDraft = db.User('john', 'METADATA');
+const categoryQuery = db.findByCategory('ELECTRONICS', 'p123');
+
+const results = await db.batchRead([userDraft, categoryQuery]);
+
+results.forEach(item => {
+  console.log(item.__model); // Automatically mapped to models
+  if (item.__model === 'User') {
+    item.status = 'active';
+    item.save(); // Second-level methods are available
+  }
+});
+```
+
 ## Optional Configuration Parameters
 
 | Parameter | Type | Default | Description |
@@ -235,6 +264,8 @@ if (token) {
 - `delete(params)`: Low-level DeleteCommand wrapper.
 - `query(params)`: Low-level QueryCommand wrapper.
 - `scan(params)`: Low-level ScanCommand wrapper.
+- `batchWrite(items)`: Batch persists multiple `Item` objects.
+- `batchRead(items)`: Batch fetches multiple `Item` or `IndexQuery` objects.
 - `[ModelName](id, skValue?)`: Returns a `Partition` instance for the given ID. If `skValue` is provided, returns an `Item` object directly.
 - `findBy[IndexName](id, skValue?)`: Returns an `IndexQuery` instance.
 

package/dist/index-query.d.ts

@@ -33,5 +33,4 @@ export declare class IndexQuery {
     getSkName(): string;
     getSkValue(): string | undefined;
     getLastEvaluatedKey(): any;
-    private mapItemToModelItem;
 }

package/dist/index-query.js

@@ -10,8 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.IndexQuery = void 0;
-const partition_1 = require("./partition");
-const partition_2 = require("./partition");
 class IndexQuery {
     constructor(db, config) {
         this.lastEvaluatedKey = null;
@@ -55,7 +53,7 @@ class IndexQuery {
                 ExclusiveStartKey: options === null || options === void 0 ? void 0 : options.exclusiveStartKey,
             });
             const items = (response.Items || []);
-            const mappedItems = items.map(item => this.mapItemToModelItem(item));
+            const mappedItems = items.map(item => this.db.mapItemToModelItem(item));
             this.lastEvaluatedKey = response.LastEvaluatedKey || null;
             return mappedItems;
         });
@@ -81,37 +79,5 @@ class IndexQuery {
     getLastEvaluatedKey() {
         return this.lastEvaluatedKey;
     }
-    mapItemToModelItem(item) {
-        const pkName = this.db.getPkName();
-        const pkValue = item[pkName];
-        if (!pkValue)
-            return item;
-        const registeredModels = this.db.getRegisteredModels();
-        const globalPrefix = this.db.getPkPrefix();
-        for (const [name, def] of Object.entries(registeredModels)) {
-            const fullPrefix = globalPrefix + def.pkPrefix;
-            if (pkValue.startsWith(fullPrefix)) {
-                // Find the ID by removing the prefix
-                const id = pkValue.substring(fullPrefix.length);
-                // Return a Partition instance and attach the data to its cache.
-                const partition = new partition_1.Partition(this.db, { pkPrefix: fullPrefix }, id);
-                // Pre-fill the cache if we have the SK
-                const skName = this.db.getSkName();
-                const skValue = item[skName];
-                if (skValue) {
-                    partition["cache"][skValue] = item;
-                }
-                // Add a property __model to the item if it matches.
-                item.__model = name;
-                // Also provide a way to get the partition instance from the item
-                item.getPartition = () => partition;
-                if (skValue) {
-                    return new partition_2.Item(partition, skValue, item);
-                }
-                return item;
-            }
-        }
-        return item;
-    }
 }
 exports.IndexQuery = IndexQuery;

package/dist/index.d.ts

@@ -1,4 +1,6 @@
 import { PutCommandInput, GetCommandInput, UpdateCommandInput, DeleteCommandInput, QueryCommandInput, ScanCommandInput } from "@aws-sdk/lib-dynamodb";
+import { Item } from "./partition";
+import { IndexQuery } from "./index-query";
 export interface DynoQueryConfig {
     tableName?: string;
     pkName?: string;
@@ -55,6 +57,18 @@ export declare class DynoQuery {
      * Scan the table or index for items.
      */
     scan(params: ScanCommandInput): Promise<import("@aws-sdk/lib-dynamodb").ScanCommandOutput>;
+    /**
+     * Batch write items to the table.
+     */
+    batchWrite(items: Item[]): Promise<Item[]>;
+    /**
+     * Batch get items from the table.
+     */
+    batchRead(items: (Item | IndexQuery)[]): Promise<any[]>;
+    /**
+     * Maps a raw DynamoDB item to a Model Item if it matches a registered model.
+     */
+    mapItemToModelItem(item: any): any;
     getTableName(): string | undefined;
     getPkPrefix(): string;
     getPkName(): string;

package/dist/index.js

@@ -38,6 +38,7 @@ exports.Item = exports.DynoQuery = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
 const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
 const partition_1 = require("./partition");
+const index_query_1 = require("./index-query");
 class DynoQuery {
     constructor(config = {}) {
         this.registeredModels = {};
@@ -153,6 +154,137 @@ class DynoQuery {
             return yield this.docClient.send(command);
         });
     }
+    /**
+     * Batch write items to the table.
+     */
+    batchWrite(items) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tableGroups = {};
+            items.forEach((item) => {
+                const partition = item.getPartition();
+                const tableName = partition.getTableName();
+                const skValue = item.getSkValue();
+                if (!tableGroups[tableName]) {
+                    tableGroups[tableName] = [];
+                }
+                const dataToSave = {};
+                for (const key in item) {
+                    if (Object.prototype.hasOwnProperty.call(item, key) &&
+                        !["_indices", "_partition", "_skValue"].includes(key) &&
+                        typeof item[key] !== "function") {
+                        dataToSave[key] = item[key];
+                    }
+                }
+                // Ensure PK and SK are in the data
+                dataToSave[this.pkName] = partition.getPkValue();
+                dataToSave[this.skName] = skValue;
+                tableGroups[tableName].push({
+                    PutRequest: {
+                        Item: dataToSave,
+                    },
+                });
+            });
+            const results = [];
+            const tableNames = Object.keys(tableGroups);
+            for (const tableName of tableNames) {
+                const requests = tableGroups[tableName];
+                // Chunk requests into 25
+                for (let i = 0; i < requests.length; i += 25) {
+                    const chunk = requests.slice(i, i + 25);
+                    yield this.docClient.send(new lib_dynamodb_1.BatchWriteCommand({
+                        RequestItems: {
+                            [tableName]: chunk,
+                        },
+                    }));
+                }
+            }
+            return items;
+        });
+    }
+    /**
+     * Batch get items from the table.
+     */
+    batchRead(items) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const tableGroups = {};
+            const requestMap = {};
+            items.forEach((item) => {
+                let tableName;
+                let pkValue;
+                let skValue;
+                if (item instanceof index_query_1.IndexQuery) {
+                    tableName = item.tableName;
+                    pkValue = item.getPkValue();
+                    skValue = item.getSkValue() || "";
+                }
+                else {
+                    const partition = item.getPartition();
+                    tableName = partition.getTableName();
+                    pkValue = partition.getPkValue();
+                    skValue = item.getSkValue();
+                }
+                if (!tableGroups[tableName]) {
+                    tableGroups[tableName] = [];
+                }
+                const key = {
+                    [this.pkName]: pkValue,
+                    [this.skName]: skValue,
+                };
+                tableGroups[tableName].push(key);
+                const requestKey = `${tableName}|${pkValue}|${skValue}`;
+                requestMap[requestKey] = item;
+            });
+            const allItems = [];
+            const tableNames = Object.keys(tableGroups);
+            for (const tableName of tableNames) {
+                const keys = tableGroups[tableName];
+                for (let i = 0; i < keys.length; i += 100) {
+                    const chunk = keys.slice(i, i + 100);
+                    const response = yield this.docClient.send(new lib_dynamodb_1.BatchGetCommand({
+                        RequestItems: {
+                            [tableName]: {
+                                Keys: chunk,
+                            },
+                        },
+                    }));
+                    if (response.Responses && response.Responses[tableName]) {
+                        const items = response.Responses[tableName];
+                        items.forEach((item) => {
+                            const mappedItem = this.mapItemToModelItem(item);
+                            allItems.push(mappedItem);
+                        });
+                    }
+                }
+            }
+            return allItems;
+        });
+    }
+    /**
+     * Maps a raw DynamoDB item to a Model Item if it matches a registered model.
+     */
+    mapItemToModelItem(item) {
+        const pkValue = item[this.pkName];
+        if (!pkValue)
+            return item;
+        for (const [name, def] of Object.entries(this.registeredModels)) {
+            const fullPrefix = this.globalPkPrefix + def.pkPrefix;
+            if (pkValue.startsWith(fullPrefix)) {
+                const id = pkValue.substring(fullPrefix.length);
+                const partition = new partition_1.Partition(this, { pkPrefix: fullPrefix }, id);
+                const skValue = item[this.skName];
+                if (skValue) {
+                    partition["cache"][skValue] = item;
+                }
+                // Add metadata to the item
+                item.__model = name;
+                item.getPartition = () => partition;
+                if (skValue) {
+                    return new partition_1.Item(partition, skValue, item);
+                }
+            }
+        }
+        return item;
+    }
     getTableName() {
         return this.defaultTableName;
     }

package/dist/partition.d.ts

@@ -8,6 +8,8 @@ export interface PartitionConfig {
 export declare class Item {
     [key: string]: any;
     private _indices;
+    private _partition;
+    private _skValue;
     constructor(partition: Partition, skValue: string, data: any);
 }
 export declare class Partition {
@@ -57,6 +59,7 @@ export declare class Partition {
      * @param data Initial data for the row
      */
     draft<T = any>(skValue: string, data?: any): T;
+    getTableName(): string;
     getPkValue(): string;
     getLastEvaluatedKey(): any;
     /**

package/dist/partition.js

@@ -13,6 +13,8 @@ exports.Partition = exports.Item = void 0;
 class Item {
     constructor(partition, skValue, data) {
         this._indices = [];
+        this._partition = partition;
+        this._skValue = skValue;
         Object.assign(this, data);
         const self = this;
         return new Proxy(this, {
@@ -21,7 +23,9 @@ class Item {
                     return () => {
                         const dataToSave = {};
                         for (const key in target) {
-                            if (Object.prototype.hasOwnProperty.call(target, key) && key !== "_indices" && typeof target[key] !== 'function') {
+                            if (Object.prototype.hasOwnProperty.call(target, key) &&
+                                !["_indices", "_partition", "_skValue"].includes(key) &&
+                                typeof target[key] !== "function") {
                                 dataToSave[key] = target[key];
                             }
                         }
@@ -51,6 +55,12 @@ class Item {
                         return receiver;
                     };
                 }
+                if (prop === "getPartition") {
+                    return () => partition;
+                }
+                if (prop === "getSkValue") {
+                    return () => skValue;
+                }
                 return Reflect.get(target, prop, receiver);
             },
         });
@@ -215,6 +225,9 @@ class Partition {
     draft(skValue, data = {}) {
         return new Item(this, skValue, data);
     }
+    getTableName() {
+        return this.tableName || "";
+    }
     getPkValue() {
         return this.pkValue;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dynoquery",
-  "version": "0.1.18",
+  "version": "0.1.19",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/devspikejs/dynoquery.git"