@lafken/dynamo 0.12.6 → 0.12.8

package/lib/service/cache/in-memory-cache.d.ts

@@ -0,0 +1,6 @@
+export declare class InMemoryCache {
+    private store;
+    get<T>(key: string): T | undefined;
+    set<T>(key: string, value: T, ttlSeconds: number): void;
+    getOrSet<T>(key: string, fetcher: () => Promise<T>, ttlSeconds: number): Promise<T>;
+}

package/lib/service/cache/in-memory-cache.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InMemoryCache = void 0;
+class InMemoryCache {
+    store = new Map();
+    get(key) {
+        const entry = this.store.get(key);
+        if (!entry)
+            return undefined;
+        if (Date.now() > entry.expiry) {
+            this.store.delete(key);
+            return undefined;
+        }
+        return entry.value;
+    }
+    set(key, value, ttlSeconds) {
+        this.store.set(key, { value, expiry: Date.now() + ttlSeconds * 1000 });
+    }
+    async getOrSet(key, fetcher, ttlSeconds) {
+        const cached = this.get(key);
+        if (cached !== undefined)
+            return cached;
+        const value = await fetcher();
+        if (value !== undefined)
+            this.set(key, value, ttlSeconds);
+        return value;
+    }
+}
+exports.InMemoryCache = InMemoryCache;

package/lib/service/query-builder/batch-get/batch-get.d.ts

@@ -0,0 +1,15 @@
+import { type BatchGetItemCommandInput } from '@aws-sdk/client-dynamodb';
+import type { ClassResource } from '@lafken/common';
+import { QueryBuilderBase } from '../base/base';
+import type { BatchGetBuilderProps } from './batch-get.types';
+export declare class BatchGetBuilder<E extends ClassResource> extends QueryBuilderBase<E> {
+    private queryOptions;
+    private commands;
+    constructor(queryOptions: BatchGetBuilderProps<E>);
+    getCommand(): BatchGetItemCommandInput[];
+    then<T>(resolve: (value: InstanceType<E>[]) => T, reject: (reason: any) => T): Promise<T>;
+    private exec;
+    private execAndRetry;
+    protected prepare(): void;
+    private chunkKeys;
+}

package/lib/service/query-builder/batch-get/batch-get.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchGetBuilder = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const base_1 = require("../base/base");
+class BatchGetBuilder extends base_1.QueryBuilderBase {
+    queryOptions;
+    commands = [];
+    constructor(queryOptions) {
+        super(queryOptions);
+        this.queryOptions = queryOptions;
+        this.prepare();
+    }
+    getCommand() {
+        return this.commands;
+    }
+    then(resolve, reject) {
+        return this.exec().then(resolve, reject);
+    }
+    async exec() {
+        const results = await Promise.all(this.commands.map((command) => this.execAndRetry(command)));
+        return results.flat();
+    }
+    async execAndRetry(inputCommand, items = [], attempt = 0) {
+        const command = new client_dynamodb_1.BatchGetItemCommand(inputCommand);
+        const { Responses = {}, UnprocessedKeys = {} } = await this.queryOptions.client.send(command);
+        const batchItems = (Responses[this.queryOptions.modelProps.name] ?? []).map((item) => (0, util_dynamodb_1.unmarshall)(item));
+        const allItems = items.concat(batchItems);
+        if (Object.keys(UnprocessedKeys).length > 0) {
+            if (attempt === (this.queryOptions.options?.maxAttempt ?? 5)) {
+                throw new Error('Failed to process all keys after maximum retries');
+            }
+            return this.execAndRetry({ RequestItems: UnprocessedKeys }, allItems, attempt + 1);
+        }
+        return allItems;
+    }
+    prepare() {
+        const { consistentRead, projection } = this.queryOptions.options ?? {};
+        const projectionExpression = projection && projection !== 'ALL' ? projection.join(', ') : undefined;
+        const chunkedKeys = this.chunkKeys(this.queryOptions.keys, 100);
+        for (const keys of chunkedKeys) {
+            this.commands.push({
+                RequestItems: {
+                    [this.queryOptions.modelProps.name]: {
+                        Keys: keys.map((key) => (0, util_dynamodb_1.marshall)(key, { removeUndefinedValues: true })),
+                        ConsistentRead: consistentRead,
+                        ProjectionExpression: projectionExpression,
+                    },
+                },
+            });
+        }
+    }
+    chunkKeys(keys, size) {
+        const result = [];
+        for (let i = 0; i < keys.length; i += size) {
+            result.push(keys.slice(i, i + size));
+        }
+        return result;
+    }
+}
+exports.BatchGetBuilder = BatchGetBuilder;

package/lib/service/query-builder/batch-get/batch-get.types.d.ts

@@ -0,0 +1,13 @@
+import type { ClassResource } from '@lafken/common';
+import type { TablePartition } from '../../../main/table';
+import type { QueryBuilderProps } from '../base/base.types';
+import type { Item, Projection } from '../query-builder.types';
+export interface BatchGetOptions<E extends ClassResource> {
+    consistentRead?: boolean;
+    projection?: Projection<E>;
+    maxAttempt?: number;
+}
+export interface BatchGetBuilderProps<E extends ClassResource> extends QueryBuilderProps<E> {
+    keys: TablePartition<Item<E>>[];
+    options?: BatchGetOptions<E>;
+}

package/lib/service/query-builder/batch-get/batch-get.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/service/query-builder/find-all/find-all.d.ts

@@ -1,10 +1,10 @@
 import type { ClassResource } from '@lafken/common';
 import { FindBuilder } from '../find/find';
-import type { FindBuilderProps } from '../find/find.types';
 import type { QueryResponse } from '../query-builder.types';
+import type { FindAllBuilderProps } from './find-all.types';
 export declare class FindAllBuilder<E extends ClassResource> extends FindBuilder<E> {
-    protected queryOptions: FindBuilderProps<E>;
-    constructor(queryOptions: FindBuilderProps<E>);
+    protected queryOptions: FindAllBuilderProps<E>;
+    constructor(queryOptions: FindAllBuilderProps<E>);
     then<T>(resolve: (value: QueryResponse<E>) => T, reject: (reason: any) => T): Promise<T>;
     private exec;
 }

package/lib/service/query-builder/find-all/find-all.js

@@ -13,7 +13,13 @@ class FindAllBuilder extends find_1.FindBuilder {
         return this.exec().then(resolve, reject);
     }
     async exec() {
-        return this.runQuery(this.command);
+        const { cache, cacheTtl, modelProps, inputProps } = this.queryOptions;
+        const fetch = () => this.runQuery(this.command);
+        if (cache && cacheTtl) {
+            const key = JSON.stringify({ table: modelProps.name, inputProps });
+            return cache.getOrSet(key, fetch, cacheTtl);
+        }
+        return fetch();
     }
 }
 exports.FindAllBuilder = FindAllBuilder;

package/lib/service/query-builder/find-all/find-all.types.d.ts

@@ -0,0 +1,7 @@
+import type { ClassResource } from '@lafken/common';
+import type { InMemoryCache } from '../../cache/in-memory-cache';
+import type { FindBuilderProps } from '../find/find.types';
+export interface FindAllBuilderProps<E extends ClassResource> extends FindBuilderProps<E> {
+    cache?: InMemoryCache;
+    cacheTtl?: number;
+}

package/lib/service/query-builder/find-all/find-all.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/service/query-builder/find-one/find-one.d.ts

@@ -1,9 +1,9 @@
 import type { ClassResource } from '@lafken/common';
 import { FindBuilder } from '../find/find';
-import type { FindBuilderProps } from '../find/find.types';
+import type { FindOneBuilderProps } from './find-one.types';
 export declare class FindOneBuilder<E extends ClassResource> extends FindBuilder<E> {
-    protected queryOptions: FindBuilderProps<E>;
-    constructor(queryOptions: FindBuilderProps<E>);
+    protected queryOptions: FindOneBuilderProps<E>;
+    constructor(queryOptions: FindOneBuilderProps<E>);
     then<T>(resolve: (value: InstanceType<E> | undefined) => T, reject: (reason: any) => T): Promise<T>;
     private exec;
 }

package/lib/service/query-builder/find-one/find-one.js

@@ -13,8 +13,16 @@ class FindOneBuilder extends find_1.FindBuilder {
         return this.exec().then(resolve, reject);
     }
     async exec() {
-        const { data } = await this.runQuery(this.command);
-        return data?.[0];
+        const { cache, cacheTtl, modelProps, inputProps } = this.queryOptions;
+        const fetch = async () => {
+            const { data } = await this.runQuery(this.command);
+            return data?.[0];
+        };
+        if (cache && cacheTtl) {
+            const key = JSON.stringify({ table: modelProps.name, inputProps });
+            return cache.getOrSet(key, fetch, cacheTtl);
+        }
+        return fetch();
     }
 }
 exports.FindOneBuilder = FindOneBuilder;

package/lib/service/query-builder/find-one/find-one.types.d.ts

@@ -0,0 +1,7 @@
+import type { ClassResource } from '@lafken/common';
+import type { InMemoryCache } from '../../cache/in-memory-cache';
+import type { FindBuilderProps } from '../find/find.types';
+export interface FindOneBuilderProps<E extends ClassResource> extends FindBuilderProps<E> {
+    cache?: InMemoryCache;
+    cacheTtl?: number;
+}

package/lib/service/query-builder/find-one/find-one.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/service/query-builder/get-item/get-item.d.ts

@@ -0,0 +1,13 @@
+import { type GetItemCommandInput } from '@aws-sdk/client-dynamodb';
+import type { ClassResource } from '@lafken/common';
+import { QueryBuilderBase } from '../base/base';
+import type { GetItemBuilderProps } from './get-item.types';
+export declare class GetItemBuilder<E extends ClassResource> extends QueryBuilderBase<E> {
+    private queryOptions;
+    protected command: GetItemCommandInput;
+    constructor(queryOptions: GetItemBuilderProps<E>);
+    getCommand(): GetItemCommandInput;
+    then<T>(resolve: (value: InstanceType<E> | undefined) => T, reject: (reason: any) => T): Promise<T>;
+    private exec;
+    protected prepare(): void;
+}

package/lib/service/query-builder/get-item/get-item.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetItemBuilder = void 0;
+const client_dynamodb_1 = require("@aws-sdk/client-dynamodb");
+const util_dynamodb_1 = require("@aws-sdk/util-dynamodb");
+const base_1 = require("../base/base");
+class GetItemBuilder extends base_1.QueryBuilderBase {
+    queryOptions;
+    command;
+    constructor(queryOptions) {
+        super(queryOptions);
+        this.queryOptions = queryOptions;
+        this.prepare();
+    }
+    getCommand() {
+        return this.command;
+    }
+    then(resolve, reject) {
+        return this.exec().then(resolve, reject);
+    }
+    async exec() {
+        const { cache, options, modelProps } = this.queryOptions;
+        const fetch = async () => {
+            const { Item } = await this.queryOptions.client.send(new client_dynamodb_1.GetItemCommand(this.command));
+            return Item ? (0, util_dynamodb_1.unmarshall)(Item) : undefined;
+        };
+        if (cache && options?.cacheTtl) {
+            const key = JSON.stringify({ table: modelProps.name, key: this.queryOptions.key });
+            return cache.getOrSet(key, fetch, options.cacheTtl);
+        }
+        return fetch();
+    }
+    prepare() {
+        const { consistentRead, projection } = this.queryOptions.options ?? {};
+        this.command = {
+            TableName: this.queryOptions.modelProps.name,
+            Key: (0, util_dynamodb_1.marshall)(this.queryOptions.key, {
+                removeUndefinedValues: true,
+            }),
+            ConsistentRead: consistentRead,
+            ProjectionExpression: projection && projection !== 'ALL' ? projection.join(', ') : undefined,
+        };
+    }
+}
+exports.GetItemBuilder = GetItemBuilder;

package/lib/service/query-builder/get-item/get-item.types.d.ts

@@ -0,0 +1,15 @@
+import type { ClassResource } from '@lafken/common';
+import type { TablePartition } from '../../../main/table';
+import type { InMemoryCache } from '../../cache/in-memory-cache';
+import type { QueryBuilderProps } from '../base/base.types';
+import type { Item, Projection } from '../query-builder.types';
+export interface GetItemOptions<E extends ClassResource> {
+    consistentRead?: boolean;
+    projection?: Projection<E>;
+    cacheTtl?: number;
+}
+export interface GetItemBuilderProps<E extends ClassResource> extends QueryBuilderProps<E> {
+    key: TablePartition<Item<E>>;
+    cache?: InMemoryCache;
+    options?: GetItemOptions<E>;
+}

package/lib/service/query-builder/get-item/get-item.types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/lib/service/repository/repository.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createRepository = void 0;
+const in_memory_cache_1 = require("../cache/in-memory-cache");
 const client_1 = require("../client/client");
+const batch_get_1 = require("../query-builder/batch-get/batch-get");
 const bulk_create_1 = require("../query-builder/bulk-create/bulk-create");
 const bulk_delete_1 = require("../query-builder/bulk-delete/bulk-delete");
 const create_1 = require("../query-builder/create/create");
@@ -9,6 +11,7 @@ const delete_1 = require("../query-builder/delete/delete");
 const dynamo_index_1 = require("../query-builder/dynamo-index/dynamo-index");
 const find_all_1 = require("../query-builder/find-all/find-all");
 const find_one_1 = require("../query-builder/find-one/find-one");
+const get_item_1 = require("../query-builder/get-item/get-item");
 const scan_1 = require("../query-builder/scan/scan");
 const update_1 = require("../query-builder/update/update");
 const upsert_1 = require("../query-builder/upsert/upsert");
@@ -23,21 +26,26 @@ const createRepository = (model) => {
         sortKey,
     };
     const indexes = new dynamo_index_1.DynamoIndexes(modelProps.indexes, partitionKey, sortKey);
+    const cache = new in_memory_cache_1.InMemoryCache();
     return {
-        findOne(inputProps) {
+        findOne(inputProps, cacheTtl) {
             return new find_one_1.FindOneBuilder({
                 ...queryBuilderProps,
                 indexes,
+                cache,
+                cacheTtl,
                 inputProps: {
                     ...inputProps,
                     limit: 1,
                 },
             });
         },
-        findAll(inputProps) {
+        findAll(inputProps, cacheTtl) {
             return new find_all_1.FindAllBuilder({
                 ...queryBuilderProps,
                 indexes,
+                cache,
+                cacheTtl,
                 inputProps,
             });
         },
@@ -66,12 +74,27 @@ const createRepository = (model) => {
                 inputProps: inputProps,
             });
         },
+        getItem(key, options) {
+            return new get_item_1.GetItemBuilder({
+                ...queryBuilderProps,
+                key,
+                cache,
+                options,
+            });
+        },
         delete(key) {
             return new delete_1.DeleteBuilder({
                 ...queryBuilderProps,
                 key,
             });
         },
+        batchGet(keys, options) {
+            return new batch_get_1.BatchGetBuilder({
+                ...queryBuilderProps,
+                keys,
+                options,
+            });
+        },
         bulkCreate(items) {
             return new bulk_create_1.BulkCreateBuilder({
                 ...queryBuilderProps,

package/lib/service/repository/repository.types.d.ts

@@ -2,25 +2,31 @@ import type { DynamoDBClient } from '@aws-sdk/client-dynamodb';
 import type { ClassResource } from '@lafken/common';
 import type { TablePartition } from '../../main';
 import type { FindProps, Item, QueryOneProps, QueryProps, ReturnValueOption, UpdateProps, UpsertProps } from '../query-builder';
+import type { BatchGetBuilder } from '../query-builder/batch-get/batch-get';
+import type { BatchGetOptions } from '../query-builder/batch-get/batch-get.types';
 import type { BulkCreateBuilder } from '../query-builder/bulk-create/bulk-create';
 import type { BulkDeleteBuilder } from '../query-builder/bulk-delete/bulk-delete';
 import type { CreateBuilder } from '../query-builder/create/create';
 import type { DeleteBuilder } from '../query-builder/delete/delete';
 import type { FindAllBuilder } from '../query-builder/find-all/find-all';
 import type { FindOneBuilder } from '../query-builder/find-one/find-one';
+import type { GetItemBuilder } from '../query-builder/get-item/get-item';
+import type { GetItemOptions } from '../query-builder/get-item/get-item.types';
 import type { ScanBuilder } from '../query-builder/scan/scan';
 import type { UpdateBuilder } from '../query-builder/update/update';
 import type { UpsertBuilder } from '../query-builder/upsert/upsert';
 export type RepositoryReturn<E extends ClassResource> = {
-    findOne(inputProps: QueryOneProps<E>): FindOneBuilder<E>;
-    findAll(inputProps: QueryProps<E>): FindAllBuilder<E>;
+    findOne(inputProps: QueryOneProps<E>, cacheTtl?: number): FindOneBuilder<E>;
+    findAll(inputProps: QueryProps<E>, cacheTtl?: number): FindAllBuilder<E>;
     scan(inputProps?: FindProps<E>): ScanBuilder<E>;
     upsert(item: Item<E>, inputProps?: UpsertProps<E>): UpsertBuilder<E>;
     create(item: Item<E>): CreateBuilder<E>;
     update<R extends ReturnValueOption | undefined = undefined>(inputProps: Omit<UpdateProps<E>, 'returnValue'> & {
         returnValue?: R;
     }): UpdateBuilder<E, R>;
+    getItem(key: TablePartition<Item<E>>, options?: GetItemOptions<E>): GetItemBuilder<E>;
     delete(key: TablePartition<Item<E>>): DeleteBuilder<E>;
+    batchGet(keys: TablePartition<Item<E>>[], options?: BatchGetOptions<E>): BatchGetBuilder<E>;
     bulkCreate(items: Item<E>[]): BulkCreateBuilder<E>;
     bulkDelete(keys: TablePartition<Item<E>>[]): BulkDeleteBuilder<E>;
     sendRawCommand<T = unknown>(command: Parameters<DynamoDBClient['send']>[0]): Promise<T>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lafken/dynamo",
-  "version": "0.12.6",
+  "version": "0.12.8",
   "private": false,
   "description": "Define DynamoDB tables using TypeScript decorators - type-safe, declarative infrastructure with Lafken",
   "keywords": [
@@ -60,7 +60,7 @@
     "@aws-sdk/util-dynamodb": "^3.996.2",
     "aws-xray-sdk": "^3.12.0",
     "reflect-metadata": "^0.2.2",
-    "@lafken/resolver": "0.12.6"
+    "@lafken/resolver": "0.12.8"
   },
   "devDependencies": {
     "@cdktn/provider-aws": "^24.0.0",
@@ -74,13 +74,13 @@
     "typescript": "6.0.3",
     "unplugin-swc": "^1.5.9",
     "vitest": "^4.1.5",
-    "@lafken/common": "0.12.6"
+    "@lafken/common": "0.12.8"
   },
   "peerDependencies": {
     "@cdktn/provider-aws": ">=23.0.0",
     "cdktn": ">=0.22.0",
     "constructs": "^10.4.5",
-    "@lafken/common": "0.12.6"
+    "@lafken/common": "0.12.8"
   },
   "engines": {
     "node": ">=20.19"