dynoquery 0.1.4 → 0.1.6

package/README.md

@@ -12,7 +12,6 @@ npm install dynoquery
 
 - Basic CRUD operations (create, get, update, delete)
 - Optimized for **Single-Table Design**
-- Model-based approach for easy data management
 - Query and Scan support
 - Batch operations (batchGet, batchWrite)
 - TypeScript support
@@ -31,9 +30,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
   }
 });
@@ -66,14 +66,23 @@ async function example() {
   console.log(userMetadata);
 
   // Create an item through partition
-  const profileModel = await john.create('PROFILE', { name: 'John Doe', email: 'john@example.com' });
+  await john.create('PROFILE', { name: 'John Doe', email: 'john@example.com' });
   
-  // Update the model (updates both DB and partition cache)
-  await profileModel.update({ theme: 'dark' });
+  // 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');
+  await john.create('PROFILE', { 
+    name: 'John Doe', 
+    email: 'john@example.com', 
+    GSI1PK: cat.getPkValue(), 
+    GSI1SK: 'john@example.com' 
+  });
+
+  // Update the item (updates both DB and partition cache)
+  await john.update('PROFILE', { theme: 'dark' });
 
-  // If you need the Model instance for save/delete without immediate create:
-  const metaModel = john.model('METADATA');
-  await metaModel.save({ lastLogin: new Date().toISOString() });
+  // Delete an item
+  await john.delete('METADATA');
 
   // Advanced Partition usage (Subclassing)
   class UserPartition extends Partition {
@@ -88,6 +97,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
@@ -101,25 +152,27 @@ The main client for interacting with DynamoDB.
 - `batchGet(params)`: Batch get items.
 - `batchWrite(params)`: Batch write items.
 
-### Model
-A model-based abstraction for a specific data type.
-- `find(id?)`: Find an item by ID (PK suffix).
-- `save(data, id?)`: Save an item.
-- `update(data, id?)`: Update an existing item (partial update).
-- `remove(id?)`: Delete an item.
-
 ### Partition
-A way to manage models and data within a specific partition.
+A way to manage 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.
+- `create(sk, data)`: Creates an item in the partition.
+- `update(sk, data)`: Updates an existing item (partial update).
+- `delete(sk)`: Deletes an item.
+- `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;
@@ -71,6 +77,5 @@ export declare class DynoQuery {
         pkPrefix: string;
     }>;
 }
-export * from "./model";
 export * from "./partition";
 export * from "./index-query";

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);
         });
@@ -185,6 +237,5 @@ class DynoQuery {
     }
 }
 exports.DynoQuery = DynoQuery;
-__exportStar(require("./model"), exports);
 __exportStar(require("./partition"), exports);
 __exportStar(require("./index-query"), exports);

package/dist/partition.d.ts

@@ -1,5 +1,4 @@
 import { DynoQuery } from "./index";
-import { Model } from "./model";
 export interface PartitionConfig {
     tableName?: string;
     pk?: string;
@@ -8,7 +7,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>;
@@ -20,20 +19,40 @@ export declare class Partition {
      */
     getAll<T = any>(): Promise<T[]>;
     /**
-     * Get a model instance for a specific SK within this partition.
+     * Create an item in this partition.
      */
-    model<T = any>(sk: string): Model<T>;
-    getPK(): string;
+    create<T = any>(sk: string, data: T): Promise<void>;
     /**
-     * Create an item in this partition and return the model.
+     * Update an existing item in this partition.
      */
-    create<T = any>(sk: string, data: T): Promise<Model<T>>;
+    update<T = any>(sk: string, data: Partial<T>): Promise<void>;
+    /**
+     * Delete an item by its SK within this partition.
+     */
+    delete(sk: string): Promise<void>;
     /**
      * Get data for a specific SK within this partition.
      * If the partition is loaded, it returns from cache.
      * Otherwise, it fetches the data immediately.
      */
     get<T = any>(sk: string): Promise<T | null>;
+    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[];
     /**
      * Delete all data in this partition.
      */

package/dist/partition.js

@@ -10,7 +10,6 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Partition = void 0;
-const model_1 = require("./model");
 class Partition {
     constructor(db, config, id) {
         this.cache = {};
@@ -20,7 +19,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 +40,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 +63,7 @@ class Partition {
                     "#pk": this.pkName,
                 },
                 ExpressionAttributeValues: {
-                    ":pk": this.pk,
+                    ":pk": this.pkValue,
                 },
             });
             const items = (response.Items || []);
@@ -78,35 +77,41 @@ class Partition {
         });
     }
     /**
-     * Get a model instance for a specific SK within this partition.
+     * Create an item in this partition.
      */
-    model(sk) {
-        const config = {
-            tableName: this.tableName,
-            pkPrefix: this.pk, // In this context, pk is fixed, so prefix is the full PK
-            skValue: sk,
-            onUpdate: (updatedSk, data) => {
-                if (data === null) {
-                    delete this.cache[updatedSk];
-                }
-                else {
-                    this.cache[updatedSk] = data;
-                }
-            }
-        };
-        return new model_1.Model(this.db, config);
+    create(sk, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const item = Object.assign({ [this.pkName]: this.pkValue, [this.skName]: sk }, data);
+            yield this.db.create({
+                TableName: this.tableName,
+                Item: item,
+            });
+            this.cache[sk] = item;
+        });
     }
-    getPK() {
-        return this.pk;
+    /**
+     * Update an existing item in this partition.
+     */
+    update(sk, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const current = (yield this.get(sk)) || {};
+            const updated = Object.assign(Object.assign({}, current), data);
+            yield this.create(sk, updated);
+        });
     }
     /**
-     * Create an item in this partition and return the model.
+     * Delete an item by its SK within this partition.
      */
-    create(sk, data) {
+    delete(sk) {
         return __awaiter(this, void 0, void 0, function* () {
-            const m = this.model(sk);
-            yield m.save(data);
-            return m;
+            yield this.db.delete({
+                TableName: this.tableName,
+                Key: {
+                    [this.pkName]: this.pkValue,
+                    [this.skName]: sk,
+                },
+            });
+            delete this.cache[sk];
         });
     }
     /**
@@ -122,14 +127,70 @@ class Partition {
             if (this.isLoaded) {
                 return null;
             }
-            const model = this.model(sk);
-            const data = yield model.find();
+            const response = yield this.db.get({
+                TableName: this.tableName,
+                Key: {
+                    [this.pkName]: this.pkValue,
+                    [this.skName]: sk,
+                },
+            });
+            const data = response.Item || null;
             if (data) {
                 this.cache[sk] = data;
             }
             return data;
         });
     }
+    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
+                }
+            }
+        }));
+    }
     /**
      * Delete all data in this partition.
      */
@@ -142,7 +203,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.6",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/devspikejs/dynoquery.git"

package/dist/model.js

@@ -1,102 +0,0 @@
-"use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Model = void 0;
-class Model {
-    constructor(db, config) {
-        this.db = db;
-        this.tableName = config.tableName || db.getTableName();
-        this.pkPrefix = config.pkPrefix;
-        this.skValue = config.skValue;
-        this.pkName = db.getPkName();
-        this.skName = db.getSkName();
-        this.onUpdate = config.onUpdate;
-        if (!this.tableName) {
-            throw new Error("TableName must be provided in ModelConfig or DynoQueryConfig");
-        }
-    }
-    getTableName() {
-        return this.tableName;
-    }
-    getPK(id = "") {
-        return `${this.pkPrefix}${id}`;
-    }
-    /**
-     * Find an item by its identifier (part of the PK).
-     * Assumes the SK is fixed as defined in ModelConfig.
-     */
-    find() {
-        return __awaiter(this, arguments, void 0, function* (id = "") {
-            const response = yield this.db.get({
-                TableName: this.getTableName(),
-                Key: {
-                    [this.pkName]: this.getPK(id),
-                    [this.skName]: this.skValue,
-                },
-            });
-            return response.Item || null;
-        });
-    }
-    /**
-     * Save an item.
-     */
-    save(data_1) {
-        return __awaiter(this, arguments, void 0, function* (data, id = "") {
-            const item = Object.assign({ [this.pkName]: this.getPK(id), [this.skName]: this.skValue }, data);
-            yield this.db.create({
-                TableName: this.getTableName(),
-                Item: item,
-            });
-            if (this.onUpdate) {
-                this.onUpdate(this.skValue, item);
-            }
-        });
-    }
-    /**
-     * Update an existing item.
-     */
-    update(data_1) {
-        return __awaiter(this, arguments, void 0, function* (data, id = "") {
-            // For simplicity in this wrapper, we use create (PutItem) to update the whole item
-            // but the user might expect a partial update if we use UpdateCommand.
-            // However, for single table and this kind of wrapper, often we just put the whole item.
-            // If we want to support partial updates in the cache, we need the current item.
-            const response = yield this.db.get({
-                TableName: this.getTableName(),
-                Key: {
-                    [this.pkName]: this.getPK(id),
-                    [this.skName]: this.skValue,
-                },
-            });
-            const current = response.Item || {};
-            const updated = Object.assign(Object.assign({}, current), data);
-            yield this.save(updated, id);
-        });
-    }
-    /**
-     * Delete an item by its identifier.
-     */
-    remove() {
-        return __awaiter(this, arguments, void 0, function* (id = "") {
-            yield this.db.delete({
-                TableName: this.getTableName(),
-                Key: {
-                    [this.pkName]: this.getPK(id),
-                    [this.skName]: this.skValue,
-                },
-            });
-            if (this.onUpdate) {
-                this.onUpdate(this.skValue, null);
-            }
-        });
-    }
-}
-exports.Model = Model;