dynoquery 0.1.4 → 0.1.5

package/README.md

@@ -31,9 +31,10 @@ const db = new DynoQuery({
   // optional endpoint for local development
   // endpoint: 'http://localhost:8000'
   partitions: {
-    User: { pkPrefix: 'USER#' },
+    User: { pkPrefix: 'USER#' }, // TENANT#A#USER#
   },
   indexes: {
+    //  TENANT#A#CAT#
     ByCategory: { indexName: 'GSI1', pkPrefix: 'CAT#' } // pkName defaults to GSI1PK, skName defaults to GSI1SK
   }
 });
@@ -68,6 +69,16 @@ async function example() {
   // Create an item through partition
   const profileModel = await john.create('PROFILE', { name: 'John Doe', email: 'john@example.com' });
   
+  // You can also use getPkValue() to get the generated PK for the partition or index
+  // This is useful when you need to store it in another attribute (e.g., GSI)
+  const cat = db.ByCategory('USER');
+  const profileWithGSI = await john.create('PROFILE', { 
+    name: 'John Doe', 
+    email: 'john@example.com', 
+    GSI1PK: cat.getPkValue(), 
+    GSI1SK: 'john@example.com' 
+  });
+
   // Update the model (updates both DB and partition cache)
   await profileModel.update({ theme: 'dark' });
 
@@ -88,6 +99,48 @@ async function example() {
 }
 ```
 
+### Batch Operations
+
+If you have a `tableName` configured in `DynoQuery`, you can use the `Items` property in `batchGet` and `batchWrite` to automatically target that table.
+
+You can also generate items for `batchGet` using the `batchGetInput` method from partitions and indexes:
+
+```typescript
+const john = db.User('john@example.com');
+const jack = db.User('jack@example.com');
+const cat = db.ByCategory('1');
+
+const batchItem1 = john.batchGetInput('METADATA');
+const batchOthers = cat.batchGetInput('METADATA', 'DATA', 'PROFILE');
+const batchCat = cat.batchGetInput(); // No sk defined, so will get partition key only
+
+await db.batchGet(batchItem1, batchOthers, batchCat);
+```
+
+```typescript
+// batchGet with explicit Items
+await db.batchGet({
+  Items: [
+    { PK: 'USER#1', SK: 'METADATA' },
+    { PK: 'USER#2', SK: 'METADATA' }
+  ]
+});
+
+// batchWrite with simplified Items (automatically wrapped in PutRequest)
+await db.batchWrite({
+  Items: [
+    { PK: 'USER#3', SK: 'METADATA', name: 'Alice' },
+    {
+      DeleteRequest: {
+        Key: { PK: 'USER#1', SK: 'SESSION#123' }
+      }
+    }
+  ]
+});
+```
+
+You can still use the standard AWS SDK `RequestItems` if you need to target multiple tables or if you prefer the original syntax.
+
 ## API Reference
 
 ### DynoQuery
@@ -110,16 +163,24 @@ A model-based abstraction for a specific data type.
 
 ### Partition
 A way to manage models and data within a specific partition.
+- `getPkValue()`: Returns the generated partition key value.
 - `get(sk)`: Fetches data for a specific sort key (returns a Promise).
 - `getAll()`: Fetches all items in the partition and caches them. Returns the items.
 - `create(sk, data)`: Creates an item in the partition and returns its `Model`.
 - `model(sk)`: Get a `Model` instance for a specific sort key.
+- `batchGetInput(...sks)`: Generates items for batch query.
+- `batchWriteInput(...items)`: Generates items for batch write.
+- `batchDeleteInput(...sks)`: Generates items for batch delete.
 - `deleteAll()`: Deletes all items in the partition.
 
 ### IndexQuery
 A way to query Global Secondary Indexes.
+- `getPkValue()`: Returns the generated partition key value for this index.
 - `get(skValue | options)`: Query items in the index. Supports `skValue` (string) for `begins_with` search, or an options object with `skValue`, `limit`, and `scanIndexForward`.
 - `getAll()`: Fetches all items in the index for the given partition key.
+- `batchGetInput(...sks)`: Generates items for batch query.
+- `batchWriteInput(...items)`: Generates items for batch write.
+- `batchDeleteInput(...sks)`: Generates items for batch delete.
 - Automatically identifies models in results using `__model` and provides `getPartition()` helper.
 
 ## License

package/dist/index-query.d.ts

@@ -21,5 +21,18 @@ export declare class IndexQuery {
         scanIndexForward?: boolean;
     }): Promise<T[]>;
     getAll<T = any>(): Promise<T[]>;
+    getPkValue(): string;
+    /**
+     * Generates items for batch query.
+     */
+    batchGetInput(...sks: string[]): any[];
+    /**
+     * Generates items for batch write (put).
+     */
+    batchWriteInput(...items: any[]): any[];
+    /**
+     * Generates items for batch delete.
+     */
+    batchDeleteInput(...sks: string[]): any[];
     private mapItemToModel;
 }

package/dist/index-query.js

@@ -68,6 +68,52 @@ class IndexQuery {
             return this.get();
         });
     }
+    getPkValue() {
+        return this.pkValue;
+    }
+    /**
+     * Generates items for batch query.
+     */
+    batchGetInput(...sks) {
+        if (sks.length === 0) {
+            return [{
+                    TableName: this.tableName,
+                    Key: { [this.pkName]: this.pkValue }
+                }];
+        }
+        return sks.map(sk => ({
+            TableName: this.tableName,
+            Key: {
+                [this.pkName]: this.pkValue,
+                [this.skName]: sk
+            }
+        }));
+    }
+    /**
+     * Generates items for batch write (put).
+     */
+    batchWriteInput(...items) {
+        return items.map(item => ({
+            TableName: this.tableName,
+            PutRequest: {
+                Item: Object.assign({ [this.pkName]: this.pkValue }, item)
+            }
+        }));
+    }
+    /**
+     * Generates items for batch delete.
+     */
+    batchDeleteInput(...sks) {
+        return sks.map(sk => ({
+            TableName: this.tableName,
+            DeleteRequest: {
+                Key: {
+                    [this.pkName]: this.pkValue,
+                    [this.skName]: sk
+                }
+            }
+        }));
+    }
     mapItemToModel(item) {
         const pkName = this.db.getPkName();
         const pkValue = item[pkName];

package/dist/index.d.ts

@@ -21,6 +21,12 @@ export interface DynoQueryConfig {
         pkPrefix?: string;
     }>;
 }
+export type BatchGetInput = BatchGetCommandInput & {
+    Items?: any[];
+};
+export type BatchWriteInput = BatchWriteCommandInput & {
+    Items?: any[];
+};
 export declare class DynoQuery {
     private client;
     private docClient;
@@ -58,11 +64,11 @@ export declare class DynoQuery {
     /**
      * Get multiple items by their primary keys.
      */
-    batchGet(params: BatchGetCommandInput): Promise<import("@aws-sdk/lib-dynamodb").BatchGetCommandOutput>;
+    batchGet(params: BatchGetInput | any, ...additionalItems: any[][]): Promise<import("@aws-sdk/lib-dynamodb").BatchGetCommandOutput>;
     /**
      * Put or delete multiple items in one or more tables.
      */
-    batchWrite(params: BatchWriteCommandInput): Promise<import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
+    batchWrite(params: BatchWriteInput): Promise<import("@aws-sdk/lib-dynamodb").BatchWriteCommandOutput>;
     getTableName(): string | undefined;
     getPkPrefix(): string;
     getPkName(): string;

package/dist/index.js

@@ -22,6 +22,17 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
         step((generator = generator.apply(thisArg, _arguments || [])).next());
     });
 };
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DynoQuery = void 0;
 const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
@@ -30,35 +41,28 @@ const partition_1 = require("./partition");
 class DynoQuery {
     constructor(config = {}) {
         this.registeredPartitions = {};
-        const clientConfig = Object.assign({}, config);
-        // Remove properties that are not part of DynamoDBClientConfig
-        delete clientConfig.tableName;
-        delete clientConfig.pkPrefix;
-        delete clientConfig.partitions;
-        delete clientConfig.indexes;
-        delete clientConfig.pkName;
-        delete clientConfig.skName;
+        const { tableName, pkName, skName, pkPrefix, partitions, indexes } = config, clientConfig = __rest(config, ["tableName", "pkName", "skName", "pkPrefix", "partitions", "indexes"]);
         this.client = new client_dynamodb_1.DynamoDBClient(clientConfig);
         this.docClient = lib_dynamodb_1.DynamoDBDocumentClient.from(this.client, {
             marshallOptions: {
                 removeUndefinedValues: true,
             }
         });
-        this.defaultTableName = config.tableName;
-        this.globalPkPrefix = config.pkPrefix || "";
-        this.pkName = config.pkName || "PK";
-        this.skName = config.skName || "SK";
-        if (config.partitions) {
-            this.registeredPartitions = config.partitions;
-            Object.entries(config.partitions).forEach(([name, def]) => {
+        this.defaultTableName = tableName;
+        this.globalPkPrefix = pkPrefix || "";
+        this.pkName = pkName || "PK";
+        this.skName = skName || "SK";
+        if (partitions) {
+            this.registeredPartitions = partitions;
+            Object.entries(partitions).forEach(([name, def]) => {
                 this[name] = (id) => {
                     return new partition_1.Partition(this, { pkPrefix: this.globalPkPrefix + def.pkPrefix }, id);
                 };
             });
         }
-        if (config.indexes) {
+        if (indexes) {
             const { IndexQuery } = require("./index-query");
-            Object.entries(config.indexes).forEach(([name, def]) => {
+            Object.entries(indexes).forEach(([name, def]) => {
                 this[name] = (id) => {
                     return new IndexQuery(this, {
                         indexName: def.indexName,
@@ -146,16 +150,46 @@ class DynoQuery {
     /**
      * Get multiple items by their primary keys.
      */
-    batchGet(params) {
+    batchGet(params, ...additionalItems) {
         return __awaiter(this, void 0, void 0, function* () {
-            if (this.defaultTableName && params.RequestItems) {
-                // Note: Batch operations are a bit trickier because TableName is a key in RequestItems
-                // This wrapper doesn't automatically add it to RequestItems yet,
-                // but let's see if we should handle it.
-                // For now, let's keep it as is or add it if RequestItems is empty?
-                // Usually BatchGetCommandInput is complex.
+            let finalParams;
+            if (params && !params.RequestItems && !params.Items && (Array.isArray(params) || additionalItems.length > 0)) {
+                // Handle the case where arguments are multiple arrays of items
+                const allItems = Array.isArray(params) ? [...params] : [];
+                additionalItems.forEach(chunk => {
+                    if (Array.isArray(chunk)) {
+                        allItems.push(...chunk);
+                    }
+                    else {
+                        allItems.push(chunk);
+                    }
+                });
+                finalParams = {
+                    Items: allItems
+                };
+            }
+            else {
+                finalParams = params;
             }
-            const command = new lib_dynamodb_1.BatchGetCommand(params);
+            if (!finalParams.RequestItems && finalParams.Items) {
+                finalParams.RequestItems = {};
+                finalParams.Items.forEach((item) => {
+                    const tableName = item.TableName || this.defaultTableName;
+                    if (!tableName) {
+                        throw new Error("TableName must be provided for batch operations if no default tableName is set");
+                    }
+                    if (!finalParams.RequestItems[tableName]) {
+                        finalParams.RequestItems[tableName] = { Keys: [] };
+                    }
+                    const key = item.Key || item;
+                    finalParams.RequestItems[tableName].Keys.push(key);
+                });
+                delete finalParams.Items;
+            }
+            else if (!finalParams.RequestItems && this.defaultTableName) {
+                finalParams.RequestItems = {};
+            }
+            const command = new lib_dynamodb_1.BatchGetCommand(finalParams);
             return yield this.docClient.send(command);
         });
     }
@@ -164,6 +198,24 @@ class DynoQuery {
      */
     batchWrite(params) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!params.RequestItems && params.Items) {
+                params.RequestItems = {};
+                params.Items.forEach((item) => {
+                    const tableName = item.TableName || this.defaultTableName;
+                    if (!tableName) {
+                        throw new Error("TableName must be provided for batch operations if no default tableName is set");
+                    }
+                    if (!params.RequestItems[tableName]) {
+                        params.RequestItems[tableName] = [];
+                    }
+                    const request = item.PutRequest || item.DeleteRequest ? item : { PutRequest: { Item: item } };
+                    params.RequestItems[tableName].push(request);
+                });
+                delete params.Items;
+            }
+            else if (!params.RequestItems && this.defaultTableName) {
+                params.RequestItems = {};
+            }
             const command = new lib_dynamodb_1.BatchWriteCommand(params);
             return yield this.docClient.send(command);
         });

package/dist/partition.d.ts

@@ -8,7 +8,7 @@ export interface PartitionConfig {
 export declare class Partition {
     protected db: DynoQuery;
     protected tableName?: string;
-    protected pk: string;
+    protected pkValue: string;
     protected pkName: string;
     protected skName: string;
     protected cache: Record<string, any>;
@@ -23,7 +23,23 @@ export declare class Partition {
      * Get a model instance for a specific SK within this partition.
      */
     model<T = any>(sk: string): Model<T>;
-    getPK(): string;
+    getPkValue(): string;
+    /**
+     * Generates items for batch query.
+     * If no SKs are provided, it might not be very useful for batchGet (which requires full keys),
+     * but the requirement says "will get all by pkValue" if no sk defined.
+     * Actually, BatchGetItem requires both PK and SK if the table has both.
+     * If it's for IndexQuery, it might be different.
+     */
+    batchGetInput(...sks: string[]): any[];
+    /**
+     * Generates items for batch write (put).
+     */
+    batchWriteInput(...items: any[]): any[];
+    /**
+     * Generates items for batch delete.
+     */
+    batchDeleteInput(...sks: string[]): any[];
     /**
      * Create an item in this partition and return the model.
      */

package/dist/partition.js

@@ -20,7 +20,7 @@ class Partition {
         this.pkName = db.getPkName();
         this.skName = db.getSkName();
         if (config.pk) {
-            this.pk = config.pk;
+            this.pkValue = config.pk;
         }
         else {
             const globalPrefix = db.getPkPrefix();
@@ -41,10 +41,10 @@ class Partition {
                 if (globalPrefix && !partitionPrefix.startsWith(globalPrefix)) {
                     finalPrefix = globalPrefix + partitionPrefix;
                 }
-                this.pk = `${finalPrefix}${id || ""}`;
+                this.pkValue = `${finalPrefix}${id || ""}`;
             }
             else {
-                throw new Error("Either pk or pkPrefix must be provided in PartitionConfig");
+                throw new Error("Either pkValue or pkPrefix must be provided in PartitionConfig");
             }
         }
         if (!this.tableName) {
@@ -64,7 +64,7 @@ class Partition {
                     "#pk": this.pkName,
                 },
                 ExpressionAttributeValues: {
-                    ":pk": this.pk,
+                    ":pk": this.pkValue,
                 },
             });
             const items = (response.Items || []);
@@ -83,7 +83,7 @@ class Partition {
     model(sk) {
         const config = {
             tableName: this.tableName,
-            pkPrefix: this.pk, // In this context, pk is fixed, so prefix is the full PK
+            pkPrefix: this.pkValue, // In this context, pkValue is fixed, so prefix is the full PK
             skValue: sk,
             onUpdate: (updatedSk, data) => {
                 if (data === null) {
@@ -96,8 +96,55 @@ class Partition {
         };
         return new model_1.Model(this.db, config);
     }
-    getPK() {
-        return this.pk;
+    getPkValue() {
+        return this.pkValue;
+    }
+    /**
+     * Generates items for batch query.
+     * If no SKs are provided, it might not be very useful for batchGet (which requires full keys),
+     * but the requirement says "will get all by pkValue" if no sk defined.
+     * Actually, BatchGetItem requires both PK and SK if the table has both.
+     * If it's for IndexQuery, it might be different.
+     */
+    batchGetInput(...sks) {
+        if (sks.length === 0) {
+            return [{
+                    TableName: this.tableName,
+                    Key: { [this.pkName]: this.pkValue }
+                }];
+        }
+        return sks.map(sk => ({
+            TableName: this.tableName,
+            Key: {
+                [this.pkName]: this.pkValue,
+                [this.skName]: sk
+            }
+        }));
+    }
+    /**
+     * Generates items for batch write (put).
+     */
+    batchWriteInput(...items) {
+        return items.map(item => ({
+            TableName: this.tableName,
+            PutRequest: {
+                Item: Object.assign({ [this.pkName]: this.pkValue }, item)
+            }
+        }));
+    }
+    /**
+     * Generates items for batch delete.
+     */
+    batchDeleteInput(...sks) {
+        return sks.map(sk => ({
+            TableName: this.tableName,
+            DeleteRequest: {
+                Key: {
+                    [this.pkName]: this.pkValue,
+                    [this.skName]: sk
+                }
+            }
+        }));
     }
     /**
      * Create an item in this partition and return the model.
@@ -142,7 +189,7 @@ class Partition {
                     "#pk": this.pkName,
                 },
                 ExpressionAttributeValues: {
-                    ":pk": this.pk,
+                    ":pk": this.pkValue,
                 },
             });
             if (response.Items && response.Items.length > 0) {

package/package.json

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