@travetto/model-dynamodb 2.1.5 → 2.2.2

package/README.md

@@ -10,7 +10,7 @@ npm install @travetto/model-dynamodb
 
 This module provides an [DynamoDB](https://aws.amazon.com/dynamodb/)-based implementation for the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.").  This source allows the [Data Modeling Support](https://github.com/travetto/travetto/tree/main/module/model#readme "Datastore abstraction for core operations.") module to read, write and query against [DynamoDB](https://aws.amazon.com/dynamodb/). The entire document is stored as a single value, so nothing is needed to handle schema updates in real time. Indices on the other hand are more complicated, and will not be retroactively computed for new values.
 
-Supported featrues:
+Supported features:
    
    *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/service/crud.ts#L11)
    *  [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/service/expiry.ts#L11)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@travetto/model-dynamodb",
   "displayName": "DynamoDB Model Support",
-  "version": "2.1.5",
+  "version": "2.2.2",
   "description": "DynamoDB backing for the travetto model module.",
   "keywords": [
     "typescript",
@@ -27,8 +27,8 @@
   },
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.131.0",
-    "@travetto/config": "^2.1.5",
-    "@travetto/model": "^2.1.5"
+    "@travetto/config": "^2.2.2",
+    "@travetto/model": "^2.2.2"
   },
   "publishConfig": {
     "access": "public"

package/src/service.ts

@@ -18,7 +18,7 @@ import { DynamoDBModelConfig } from './config';
 
 const EXP_ATTR = 'expires_at__';
 
-function simpleName(idx: string) {
+function simpleName(idx: string): string {
   return idx.replace(/[^A-Za-z0-9]/g, '');
 }
 
@@ -27,6 +27,7 @@ function toValue(val: unknown, forceString?: boolean): dynamodb.AttributeValue |
   if (val === undefined || val === null || val === '') {
     return { NULL: true };
   } else if (typeof val === 'string' || forceString) {
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
     return { S: val as string };
   } else if (typeof val === 'number') {
     return { N: `${val}` };
@@ -60,7 +61,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
 
   constructor(public readonly config: DynamoDBModelConfig) { }
 
-  #resolveTable(cls: Class) {
+  #resolveTable(cls: Class): string {
     let table = ModelRegistry.getStore(cls).toLowerCase().replace(/[^A-Za-z0-9_]+/g, '_');
     if (this.config.namespace) {
       table = `${this.config.namespace}_${table}`;
@@ -68,7 +69,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     return table;
   }
 
-  async #putItem<T extends ModelType>(cls: Class<T>, id: string, item: T, mode: 'create' | 'update' | 'upsert') {
+  async #putItem<T extends ModelType>(cls: Class<T>, id: string, item: T, mode: 'create' | 'update' | 'upsert'): Promise<dynamodb.PutItemCommandOutput> {
     const config = ModelRegistry.get(cls);
     let expiry: number | undefined;
 
@@ -101,7 +102,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
           },
           ReturnValues: 'NONE'
         };
-        console.debug('Querying', { query } as unknown as Record<string, string>);
+        console.debug('Querying', { query });
         return await this.client.putItem(query);
       } else {
         const indices: Record<string, unknown> = {};
@@ -135,7 +136,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
         });
       }
     } catch (err) {
-      if (err.name === 'ConditionalCheckFailedException') {
+      if (err instanceof Error && err.name === 'ConditionalCheckFailedException') {
         if (mode === 'create') {
           throw new ExistsError(cls, id);
         } else if (mode === 'update') {
@@ -146,7 +147,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     }
   }
 
-  #computeIndexConfig<T extends ModelType>(cls: Class<T>) {
+  #computeIndexConfig<T extends ModelType>(cls: Class<T>): { indices?: dynamodb.GlobalSecondaryIndex[], attributes: dynamodb.AttributeDefinition[] } {
     const config = ModelRegistry.get(cls);
     const attributes: dynamodb.AttributeDefinition[] = [];
     const indices: dynamodb.GlobalSecondaryIndex[] = [];
@@ -182,7 +183,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     return { indices: indices.length ? indices : undefined, attributes };
   }
 
-  async postConstruct() {
+  async postConstruct(): Promise<void> {
     this.client = new dynamodb.DynamoDB({ ...this.config.client });
     await ModelStorageUtil.registerModelChangeListener(this);
     ShutdownManager.onShutdown(this.constructor.ᚕid, () => this.client.destroy());
@@ -194,7 +195,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
    * Add a new model
    * @param cls
    */
-  async createModel(cls: Class<ModelType>) {
+  async createModel(cls: Class<ModelType>): Promise<void> {
     const table = this.#resolveTable(cls);
     const idx = this.#computeIndexConfig(cls);
 
@@ -227,7 +228,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
    * Remove a model
    * @param cls
    */
-  async deleteModel(cls: Class<ModelType>) {
+  async deleteModel(cls: Class<ModelType>): Promise<void> {
     const table = this.#resolveTable(cls);
     const { Table: verify } = (await this.client.describeTable({ TableName: table }).catch(err => ({ Table: undefined })));
     if (verify) {
@@ -239,7 +240,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
    * When the model changes
    * @param cls
    */
-  async changeModel(cls: Class<ModelType>) {
+  async changeModel(cls: Class<ModelType>): Promise<void> {
     const table = this.#resolveTable(cls);
     const idx = this.#computeIndexConfig(cls);
     // const existing = await this.cl.describeTable({ TableName: table });
@@ -254,11 +255,11 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     });
   }
 
-  async createStorage() {
+  async createStorage(): Promise<void> {
     // Do nothing
   }
 
-  async deleteStorage() {
+  async deleteStorage(): Promise<void> {
     for (const model of ModelRegistry.getClasses()) {
       await this.client.deleteTable({
         TableName: this.#resolveTable(model)
@@ -271,7 +272,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     return Util.uuid();
   }
 
-  async get<T extends ModelType>(cls: Class<T>, id: string) {
+  async get<T extends ModelType>(cls: Class<T>, id: string): Promise<T> {
     const res = await this.client.getItem({
       TableName: this.#resolveTable(cls),
       Key: { id: toValue(id) }
@@ -283,13 +284,13 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     throw new NotFoundError(cls, id);
   }
 
-  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) {
+  async create<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     const prepped = await ModelCrudUtil.preStore(cls, item, this);
     await this.#putItem(cls, prepped.id, prepped, 'create');
     return prepped;
   }
 
-  async update<T extends ModelType>(cls: Class<T>, item: T) {
+  async update<T extends ModelType>(cls: Class<T>, item: T): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
     item = await ModelCrudUtil.preStore(cls, item, this);
     if (ModelRegistry.get(cls).expiresAt) {
@@ -299,22 +300,24 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     return item;
   }
 
-  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>) {
+  async upsert<T extends ModelType>(cls: Class<T>, item: OptionalId<T>): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
     const prepped = await ModelCrudUtil.preStore(cls, item, this);
     await this.#putItem(cls, prepped.id, prepped, 'upsert');
     return prepped;
   }
 
-  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string) {
+  async updatePartial<T extends ModelType>(cls: Class<T>, item: Partial<T> & { id: string }, view?: string): Promise<T> {
     ModelCrudUtil.ensureNotSubType(cls);
     const id = item.id;
-    item = await ModelCrudUtil.naivePartialUpdate(cls, item, view, () => this.get(cls, id)) as T;
-    await this.#putItem(cls, id, item as T, 'update');
-    return item as T;
+    item = await ModelCrudUtil.naivePartialUpdate(cls, item, view, (): Promise<T> => this.get(cls, id));
+    // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+    const itemAsT = item as T;
+    await this.#putItem(cls, id, itemAsT, 'update');
+    return itemAsT;
   }
 
-  async delete<T extends ModelType>(cls: Class<T>, id: string) {
+  async delete<T extends ModelType>(cls: Class<T>, id: string): Promise<void> {
     ModelCrudUtil.ensureNotSubType(cls);
     const res = await this.client.deleteItem({
       TableName: this.#resolveTable(cls),
@@ -326,7 +329,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     }
   }
 
-  async * list<T extends ModelType>(cls: Class<T>) {
+  async * list<T extends ModelType>(cls: Class<T>): AsyncIterable<T> {
     let done = false;
     let token: Record<string, dynamodb.AttributeValue> | undefined;
     while (!done) {
@@ -339,9 +342,9 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
         for (const el of batch.Items) {
           try {
             yield await loadAndCheckExpiry(cls, el.body.S!);
-          } catch (e) {
-            if (!(e instanceof NotFoundError)) {
-              throw e;
+          } catch (err) {
+            if (!(err instanceof NotFoundError)) {
+              throw err;
             }
           }
         }
@@ -356,12 +359,12 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
   }
 
   // Expiry
-  async deleteExpired<T extends ModelType>(cls: Class<T>) {
+  async deleteExpired<T extends ModelType>(cls: Class<T>): Promise<number> {
     return -1;
   }
 
   // Indexed
-  async #getIdByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>) {
+  async #getIdByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<string> {
     ModelCrudUtil.ensureNotSubType(cls);
 
     const idxCfg = ModelRegistry.getIndex(cls, idx, ['sorted', 'unsorted']);
@@ -394,11 +397,11 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
   }
 
   // Indexed
-  async getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>) {
+  async getByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<T> {
     return this.get(cls, await this.#getIdByIndex(cls, idx, body));
   }
 
-  async deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>) {
+  async deleteByIndex<T extends ModelType>(cls: Class<T>, idx: string, body: DeepPartial<T>): Promise<void> {
     return this.delete(cls, await this.#getIdByIndex(cls, idx, body));
   }
 
@@ -406,7 +409,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     return ModelIndexedUtil.naiveUpsert(this, cls, idx, body);
   }
 
-  async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>) {
+  async * listByIndex<T extends ModelType>(cls: Class<T>, idx: string, body?: DeepPartial<T>): AsyncIterable<T> {
     ModelCrudUtil.ensureNotSubType(cls);
 
     const cfg = ModelRegistry.getIndex(cls, idx, ['sorted', 'unsorted']);
@@ -432,9 +435,9 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
         for (const el of batch.Items) {
           try {
             yield await loadAndCheckExpiry(cls, el.body.S!);
-          } catch (e) {
-            if (!(e instanceof NotFoundError)) {
-              throw e;
+          } catch (err) {
+            if (!(err instanceof NotFoundError)) {
+              throw err;
             }
           }
         }