dynoquery 0.1.0

package/README.md

@@ -0,0 +1,100 @@
+# DynoQuery
+
+A lightweight wrapper for Amazon DynamoDB using the AWS SDK v3.
+
+## Installation
+
+```bash
+npm install dynoquery
+```
+
+## Features
+
+- Basic CRUD operations (create, get, update, delete)
+- Model-based approach for easy data management
+- Query and Scan support
+- Batch operations (batchGet, batchWrite)
+- TypeScript support
+
+## Usage
+
+```typescript
+import { DynoQuery } from 'dynoquery';
+
+const db = new DynoQuery({
+  region: 'us-east-1',
+  tableName: 'MyTable', // Define default table for single-table structure
+  pkPrefix: 'TENANT#A#', // Optional: Global prefix for all partitions (useful for multitenancy)
+  // optional endpoint for local development
+  // endpoint: 'http://localhost:8000'
+  partitions: {
+    User: { pkPrefix: 'USER#' },
+  }
+});
+
+async function example() {
+  // Use registered partition
+  // Resulting PK: TENANT#A#USER#john@example.com
+  const john = db.User('john@example.com');
+  
+  // Load all data for this partition (optional, but good for multiple reads)
+  await john.loadAll();
+  
+  // john.get() loads data immediately (using cache if loaded)
+  const userMetadata = await john.get('METADATA');
+  console.log(userMetadata);
+
+  // Create an item through partition
+  const profileModel = 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' });
+
+  // If you need the Model instance for save/delete without immediate create:
+  const metaModel = john.model('METADATA');
+  await metaModel.save({ lastLogin: new Date().toISOString() });
+
+  // Advanced Partition usage (Subclassing)
+  class UserPartition extends Partition {
+    constructor(db: DynoQuery, email: string) {
+      super(db, { pkPrefix: 'USER#' }, email);
+    }
+  }
+
+  const user2 = new UserPartition(db, 'jane@example.com');
+  const data2 = await user2.get('METADATA');
+  console.log(data2);
+}
+```
+
+## API Reference
+
+### DynoQuery
+The main client for interacting with DynamoDB.
+- `create(params)`: Put an item.
+- `get(params)`: Get an item.
+- `update(params)`: Update an item.
+- `delete(params)`: Delete an item.
+- `query(params)`: Query items.
+- `scan(params)`: Scan items.
+- `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.
+- `get(sk)`: Fetches data for a specific sort key (returns a Promise).
+- `loadAll()`: Fetches all items in the partition and caches them.
+- `create(sk, data)`: Creates an item in the partition and returns its `Model`.
+- `model(sk)`: Get a `Model` instance for a specific sort key.
+- `deleteAll()`: Deletes all items in the partition.
+
+## License
+
+MIT

package/dist/__tests__/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/index.test.js

@@ -0,0 +1,97 @@
+"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 });
+const index_1 = require("../index");
+const lib_dynamodb_1 = require("@aws-sdk/lib-dynamodb");
+// Mock the AWS SDK
+jest.mock('@aws-sdk/client-dynamodb');
+jest.mock('@aws-sdk/lib-dynamodb', () => {
+    const actual = jest.requireActual('@aws-sdk/lib-dynamodb');
+    return Object.assign(Object.assign({}, actual), { DynamoDBDocumentClient: {
+            from: jest.fn().mockReturnValue({
+                send: jest.fn(),
+            }),
+        } });
+});
+describe('DynoQuery', () => {
+    let dynoQuery;
+    let mockDocClient;
+    beforeEach(() => {
+        dynoQuery = new index_1.DynoQuery({ region: 'us-east-1' });
+        mockDocClient = lib_dynamodb_1.DynamoDBDocumentClient.from.mock.results[0].value;
+    });
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
+    test('create should call PutCommand', () => __awaiter(void 0, void 0, void 0, function* () {
+        const params = { TableName: 'TestTable', Item: { id: '1', name: 'Test' } };
+        yield dynoQuery.create(params);
+        expect(mockDocClient.send).toHaveBeenCalled();
+    }));
+    test('get should call GetCommand', () => __awaiter(void 0, void 0, void 0, function* () {
+        const params = { TableName: 'TestTable', Key: { id: '1' } };
+        yield dynoQuery.get(params);
+        expect(mockDocClient.send).toHaveBeenCalled();
+    }));
+    test('update should call UpdateCommand', () => __awaiter(void 0, void 0, void 0, function* () {
+        const params = {
+            TableName: 'TestTable',
+            Key: { id: '1' },
+            UpdateExpression: 'set #n = :n',
+            ExpressionAttributeNames: { '#n': 'name' },
+            ExpressionAttributeValues: { ':n': 'Updated' },
+        };
+        yield dynoQuery.update(params);
+        expect(mockDocClient.send).toHaveBeenCalled();
+    }));
+    test('delete should call DeleteCommand', () => __awaiter(void 0, void 0, void 0, function* () {
+        const params = { TableName: 'TestTable', Key: { id: '1' } };
+        yield dynoQuery.delete(params);
+        expect(mockDocClient.send).toHaveBeenCalled();
+    }));
+    test('query should call QueryCommand', () => __awaiter(void 0, void 0, void 0, function* () {
+        const params = {
+            TableName: 'TestTable',
+            KeyConditionExpression: 'id = :id',
+            ExpressionAttributeValues: { ':id': '1' },
+        };
+        yield dynoQuery.query(params);
+        expect(mockDocClient.send).toHaveBeenCalled();
+    }));
+    test('scan should call ScanCommand', () => __awaiter(void 0, void 0, void 0, function* () {
+        const params = { TableName: 'TestTable' };
+        yield dynoQuery.scan(params);
+        expect(mockDocClient.send).toHaveBeenCalled();
+    }));
+    test('batchGet should call BatchGetCommand', () => __awaiter(void 0, void 0, void 0, function* () {
+        const params = {
+            RequestItems: {
+                TestTable: {
+                    Keys: [{ id: '1' }, { id: '2' }],
+                },
+            },
+        };
+        yield dynoQuery.batchGet(params);
+        expect(mockDocClient.send).toHaveBeenCalled();
+    }));
+    test('batchWrite should call BatchWriteCommand', () => __awaiter(void 0, void 0, void 0, function* () {
+        const params = {
+            RequestItems: {
+                TestTable: [
+                    { PutRequest: { Item: { id: '1', name: 'Test1' } } },
+                    { PutRequest: { Item: { id: '2', name: 'Test2' } } },
+                ],
+            },
+        };
+        yield dynoQuery.batchWrite(params);
+        expect(mockDocClient.send).toHaveBeenCalled();
+    }));
+});

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { PutCommandInput, GetCommandInput, UpdateCommandInput, DeleteCommandInput, QueryCommandInput, ScanCommandInput, BatchGetCommandInput, BatchWriteCommandInput } from "@aws-sdk/lib-dynamodb";
+export interface DynoQueryConfig {
+    tableName?: string;
+    region?: string;
+    endpoint?: string;
+    pkPrefix?: string;
+    credentials?: {
+        accessKeyId: string;
+        secretAccessKey: string;
+        sessionToken?: string;
+    };
+    partitions?: Record<string, {
+        pkPrefix: string;
+    }>;
+}
+export declare class DynoQuery {
+    private client;
+    private docClient;
+    private defaultTableName?;
+    private globalPkPrefix;
+    [key: string]: any;
+    constructor(config?: DynoQueryConfig);
+    /**
+     * Create or replace an item in the table.
+     */
+    create(params: PutCommandInput): Promise<import("@aws-sdk/lib-dynamodb").PutCommandOutput>;
+    /**
+     * Get an item by its primary key.
+     */
+    get(params: GetCommandInput): Promise<import("@aws-sdk/lib-dynamodb").GetCommandOutput>;
+    /**
+     * Update an existing item.
+     */
+    update(params: UpdateCommandInput): Promise<import("@aws-sdk/lib-dynamodb").UpdateCommandOutput>;
+    /**
+     * Delete an item by its primary key.
+     */
+    delete(params: DeleteCommandInput): Promise<import("@aws-sdk/lib-dynamodb").DeleteCommandOutput>;
+    /**
+     * Query items based on primary key and sort key conditions.
+     */
+    query(params: QueryCommandInput): Promise<import("@aws-sdk/lib-dynamodb").QueryCommandOutput>;
+    /**
+     * Scan the table or index for items.
+     */
+    scan(params: ScanCommandInput): Promise<import("@aws-sdk/lib-dynamodb").ScanCommandOutput>;
+    /**
+     * Get multiple items by their primary keys.
+     */
+    batchGet(params: BatchGetCommandInput): 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>;
+    getTableName(): string | undefined;
+    getPkPrefix(): string;
+}
+export * from "./model";
+export * from "./partition";

package/dist/index.js

@@ -0,0 +1,159 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+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.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");
+class DynoQuery {
+    constructor(config = {}) {
+        const clientConfig = Object.assign({}, config);
+        // Remove properties that are not part of DynamoDBClientConfig
+        delete clientConfig.tableName;
+        delete clientConfig.pkPrefix;
+        delete clientConfig.partitions;
+        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 || "";
+        if (config.partitions) {
+            Object.entries(config.partitions).forEach(([name, def]) => {
+                this[name] = (id) => {
+                    return new partition_1.Partition(this, { pkPrefix: this.globalPkPrefix + def.pkPrefix }, id);
+                };
+            });
+        }
+    }
+    /**
+     * Create or replace an item in the table.
+     */
+    create(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!params.TableName && this.defaultTableName) {
+                params.TableName = this.defaultTableName;
+            }
+            const command = new lib_dynamodb_1.PutCommand(params);
+            return yield this.docClient.send(command);
+        });
+    }
+    /**
+     * Get an item by its primary key.
+     */
+    get(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!params.TableName && this.defaultTableName) {
+                params.TableName = this.defaultTableName;
+            }
+            const command = new lib_dynamodb_1.GetCommand(params);
+            return yield this.docClient.send(command);
+        });
+    }
+    /**
+     * Update an existing item.
+     */
+    update(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!params.TableName && this.defaultTableName) {
+                params.TableName = this.defaultTableName;
+            }
+            const command = new lib_dynamodb_1.UpdateCommand(params);
+            return yield this.docClient.send(command);
+        });
+    }
+    /**
+     * Delete an item by its primary key.
+     */
+    delete(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!params.TableName && this.defaultTableName) {
+                params.TableName = this.defaultTableName;
+            }
+            const command = new lib_dynamodb_1.DeleteCommand(params);
+            return yield this.docClient.send(command);
+        });
+    }
+    /**
+     * Query items based on primary key and sort key conditions.
+     */
+    query(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!params.TableName && this.defaultTableName) {
+                params.TableName = this.defaultTableName;
+            }
+            const command = new lib_dynamodb_1.QueryCommand(params);
+            return yield this.docClient.send(command);
+        });
+    }
+    /**
+     * Scan the table or index for items.
+     */
+    scan(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!params.TableName && this.defaultTableName) {
+                params.TableName = this.defaultTableName;
+            }
+            const command = new lib_dynamodb_1.ScanCommand(params);
+            return yield this.docClient.send(command);
+        });
+    }
+    /**
+     * Get multiple items by their primary keys.
+     */
+    batchGet(params) {
+        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.
+            }
+            const command = new lib_dynamodb_1.BatchGetCommand(params);
+            return yield this.docClient.send(command);
+        });
+    }
+    /**
+     * Put or delete multiple items in one or more tables.
+     */
+    batchWrite(params) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const command = new lib_dynamodb_1.BatchWriteCommand(params);
+            return yield this.docClient.send(command);
+        });
+    }
+    getTableName() {
+        return this.defaultTableName;
+    }
+    getPkPrefix() {
+        return this.globalPkPrefix;
+    }
+}
+exports.DynoQuery = DynoQuery;
+__exportStar(require("./model"), exports);
+__exportStar(require("./partition"), exports);

package/dist/model.d.ts

@@ -0,0 +1,34 @@
+import { DynoQuery } from "./index";
+export interface ModelConfig<T = any> {
+    tableName?: string;
+    pkPrefix: string;
+    skValue: string;
+    onUpdate?: (sk: any, data: any) => void;
+}
+export declare class Model<T = any> {
+    protected db: DynoQuery;
+    protected tableName?: string;
+    protected pkPrefix: string;
+    protected skValue: string;
+    protected onUpdate?: (sk: any, data: any) => void;
+    constructor(db: DynoQuery, config: ModelConfig<T>);
+    protected getTableName(): string;
+    getPK(id?: string): string;
+    /**
+     * Find an item by its identifier (part of the PK).
+     * Assumes the SK is fixed as defined in ModelConfig.
+     */
+    find(id?: string): Promise<T | null>;
+    /**
+     * Save an item.
+     */
+    save(data: T, id?: string): Promise<void>;
+    /**
+     * Update an existing item.
+     */
+    update(data: Partial<T>, id?: string): Promise<void>;
+    /**
+     * Delete an item by its identifier.
+     */
+    remove(id?: string): Promise<void>;
+}

package/dist/model.js

@@ -0,0 +1,100 @@
+"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.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: {
+                    PK: this.getPK(id),
+                    SK: 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({ PK: this.getPK(id), SK: 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: {
+                    PK: this.getPK(id),
+                    SK: 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: {
+                    PK: this.getPK(id),
+                    SK: this.skValue,
+                },
+            });
+            if (this.onUpdate) {
+                this.onUpdate(this.skValue, null);
+            }
+        });
+    }
+}
+exports.Model = Model;

package/dist/partition.d.ts

@@ -0,0 +1,38 @@
+import { DynoQuery } from "./index";
+import { Model } from "./model";
+export interface PartitionConfig {
+    tableName?: string;
+    pk?: string;
+    pkPrefix?: string;
+}
+export declare class Partition {
+    protected db: DynoQuery;
+    protected tableName?: string;
+    protected pk: string;
+    protected cache: Record<string, any>;
+    protected isLoaded: boolean;
+    constructor(db: DynoQuery, config: PartitionConfig, id?: string);
+    /**
+     * Load all data for this partition key.
+     */
+    loadAll(): Promise<this>;
+    /**
+     * Get a model instance for a specific SK within this partition.
+     */
+    model<T = any>(sk: string): Model<T>;
+    getPK(): string;
+    /**
+     * Create an item in this partition and return the model.
+     */
+    create<T = any>(sk: string, data: T): Promise<Model<T>>;
+    /**
+     * 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>;
+    /**
+     * Delete all data in this partition.
+     */
+    deleteAll(): Promise<void>;
+}

package/dist/partition.js

@@ -0,0 +1,168 @@
+"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.Partition = void 0;
+const model_1 = require("./model");
+class Partition {
+    constructor(db, config, id) {
+        this.cache = {};
+        this.isLoaded = false;
+        this.db = db;
+        this.tableName = config.tableName || db.getTableName();
+        if (config.pk) {
+            this.pk = config.pk;
+        }
+        else {
+            const globalPrefix = db.getPkPrefix();
+            const partitionPrefix = config.pkPrefix || "";
+            if (!config.pkPrefix && !id && !globalPrefix) {
+                // This check might be too strict if we allow empty prefixes,
+                // but Partition expects some way to form a PK.
+                // If config.pkPrefix is missing, we use id.
+            }
+            if (config.pkPrefix || id || globalPrefix) {
+                // If it's a Partition registered in DynoQuery, config.pkPrefix will already
+                // include the global prefix because of how we register it.
+                // But for manual instantiation (new Partition), we should probably add the global prefix too.
+                let finalPrefix = partitionPrefix;
+                // If it's NOT already starting with globalPrefix and globalPrefix exists, prepend it.
+                // Actually, better to just trust the caller OR standardise.
+                // Let's look at how we want to handle manual instantiation.
+                if (globalPrefix && !partitionPrefix.startsWith(globalPrefix)) {
+                    finalPrefix = globalPrefix + partitionPrefix;
+                }
+                this.pk = `${finalPrefix}${id || ""}`;
+            }
+            else {
+                throw new Error("Either pk or pkPrefix must be provided in PartitionConfig");
+            }
+        }
+        if (!this.tableName) {
+            throw new Error("TableName must be provided in PartitionConfig or DynoQueryConfig");
+        }
+    }
+    /**
+     * Load all data for this partition key.
+     */
+    loadAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.db.query({
+                TableName: this.tableName,
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: {
+                    ":pk": this.pk,
+                },
+            });
+            if (response.Items) {
+                response.Items.forEach((item) => {
+                    if (item.SK) {
+                        this.cache[item.SK] = item;
+                    }
+                });
+            }
+            this.isLoaded = true;
+            return this;
+        });
+    }
+    /**
+     * Get a model instance for a specific SK within 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);
+    }
+    getPK() {
+        return this.pk;
+    }
+    /**
+     * Create an item in this partition and return the model.
+     */
+    create(sk, data) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const m = this.model(sk);
+            yield m.save(data);
+            return m;
+        });
+    }
+    /**
+     * 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(sk) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.cache[sk] !== undefined) {
+                return this.cache[sk] || null;
+            }
+            if (this.isLoaded) {
+                return null;
+            }
+            const model = this.model(sk);
+            const data = yield model.find();
+            if (data) {
+                this.cache[sk] = data;
+            }
+            return data;
+        });
+    }
+    /**
+     * Delete all data in this partition.
+     */
+    deleteAll() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.db.query({
+                TableName: this.tableName,
+                KeyConditionExpression: "PK = :pk",
+                ExpressionAttributeValues: {
+                    ":pk": this.pk,
+                },
+            });
+            if (response.Items && response.Items.length > 0) {
+                // DynamoDB BatchWriteItem supports up to 25 requests at once
+                const items = response.Items;
+                const chunks = [];
+                for (let i = 0; i < items.length; i += 25) {
+                    chunks.push(items.slice(i, i + 25));
+                }
+                for (const chunk of chunks) {
+                    const deleteRequests = chunk.map((item) => ({
+                        DeleteRequest: {
+                            Key: {
+                                PK: item.PK,
+                                SK: item.SK,
+                            },
+                        },
+                    }));
+                    yield this.db.batchWrite({
+                        RequestItems: {
+                            [this.tableName]: deleteRequests,
+                        },
+                    });
+                }
+            }
+            this.cache = {};
+            this.isLoaded = false;
+        });
+    }
+}
+exports.Partition = Partition;

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "dynoquery",
+  "version": "0.1.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/devspikejs/dynoquery.git"
+  },
+  "description": "A lightweight wrapper for Amazon DynamoDB using the AWS SDK v3",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "jest src",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "dynamodb",
+    "aws",
+    "wrapper",
+    "query",
+    "sdk-v3"
+  ],
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@aws-sdk/client-dynamodb": "^3.980.0",
+    "@aws-sdk/lib-dynamodb": "^3.980.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
+    "typescript": "^5.5.3"
+  }
+}