@travetto/model-dynamodb 8.0.0-alpha.23 → 8.0.0-alpha.25

package/README.md

@@ -13,20 +13,19 @@ npm install @travetto/model-dynamodb
 yarn add @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. 
+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 features:
-   *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L11)
+   *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L10)
    *  [Expiry](https://github.com/travetto/travetto/tree/main/module/model/src/types/expiry.ts#L10)
-   *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L16)
+   *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L21)
 
 Out of the box, by installing the module, everything should be wired up by default.If you need to customize any aspect of the source or config, you can override and register it with the [Dependency Injection](https://github.com/travetto/travetto/tree/main/module/di#readme "Dependency registration/management and injection support.") module.
 
 **Code: Wiring up a custom Model Source**
 ```typescript
 import { InjectableFactory } from '@travetto/di';
-
-import { DynamoDBModelService, type DynamoDBModelConfig } from '@travetto/model-dynamodb';
+import { type DynamoDBModelConfig, DynamoDBModelService } from '@travetto/model-dynamodb';
 
 export class Init {
   @InjectableFactory({ primary: true })

package/__index__.ts

@@ -1,3 +1,3 @@
+export * from './src/config.ts';
 export * from './src/service.ts';
 export * from './src/util.ts';
-export * from './src/config.ts';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-dynamodb",
-  "version": "8.0.0-alpha.23",
+  "version": "8.0.0-alpha.25",
   "type": "module",
   "description": "DynamoDB backing for the travetto model module.",
   "keywords": [
@@ -27,12 +27,12 @@
   },
   "dependencies": {
     "@aws-sdk/client-dynamodb": "^3.1081.0",
-    "@travetto/config": "^8.0.0-alpha.20",
-    "@travetto/model": "^8.0.0-alpha.21",
-    "@travetto/model-indexed": "^8.0.0-alpha.23"
+    "@travetto/config": "^8.0.0-alpha.22",
+    "@travetto/model": "^8.0.0-alpha.23",
+    "@travetto/model-indexed": "^8.0.0-alpha.25"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.26"
+    "@travetto/cli": "^8.0.0-alpha.28"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/config.ts

@@ -18,4 +18,4 @@ export class DynamoDBModelConfig {
       this.client.endpoint ??= 'http://localhost:8000'; // From docker
     }
   }
-}
+}

package/src/service.ts

@@ -1,26 +1,53 @@
-import { type AttributeValue, DynamoDB, type PutItemCommandInput, type PutItemCommandOutput, type QueryCommandInput, type QueryCommandOutput } from '@aws-sdk/client-dynamodb';
+import {
+  type AttributeValue,
+  DynamoDB,
+  type PutItemCommandInput,
+  type PutItemCommandOutput,
+  type QueryCommandInput,
+  type QueryCommandOutput
+} from '@aws-sdk/client-dynamodb';
 
-import { castTo, JSONUtil, ShutdownManager, TimeUtil, type Class } from '@travetto/runtime';
 import { Injectable, PostConstruct } from '@travetto/di';
 import {
-  type ModelCrudSupport, type ModelExpirySupport, ModelRegistryIndex, type ModelStorageSupport,
-  type ModelType, NotFoundError, ExistsError, type OptionalId, ModelCrudUtil,
-  ModelExpiryUtil, ModelStorageUtil,
+  ExistsError,
+  type ModelCrudSupport,
+  ModelCrudUtil,
+  type ModelExpirySupport,
+  ModelExpiryUtil,
   type ModelListOptions,
+  ModelRegistryIndex,
+  type ModelStorageSupport,
+  ModelStorageUtil,
+  type ModelType,
+  NotFoundError,
+  type OptionalId
 } from '@travetto/model';
 import {
-  isModelIndexedIndex, ModelIndexedUtil, type KeyedIndexBody, type KeyedIndexSelection,
-  type ModelPageOptions, type ModelPageResult, type ModelIndexedSupport, type SingleItemIndex,
-  type FullKeyedIndexBody, type FullKeyedIndexWithPartialBody, type SortedIndex, type SortedIndexSelection,
-  ModelIndexedComputedIndex, type ModelIndexedSearchOptions, type SortedIndexSelectionType
+  type FullKeyedIndexBody,
+  type FullKeyedIndexWithPartialBody,
+  isModelIndexedIndex,
+  type KeyedIndexBody,
+  type KeyedIndexSelection,
+  ModelIndexedComputedIndex,
+  type ModelIndexedSearchOptions,
+  type ModelIndexedSupport,
+  ModelIndexedUtil,
+  type ModelPageOptions,
+  type ModelPageResult,
+  type SingleItemIndex,
+  type SortedIndex,
+  type SortedIndexSelection,
+  type SortedIndexSelectionType
 } from '@travetto/model-indexed';
+import { type Class, castTo, JSONUtil, ShutdownManager, TimeUtil } from '@travetto/runtime';
 
 import type { DynamoDBModelConfig } from './config.ts';
 import { DynamoDBUtil } from './util.ts';
 
 const EXPIRES_ATTRIBUTE = 'expires_at__';
 
-const getKey = <T extends ModelType>(computed: ModelIndexedComputedIndex<T>): AttributeValue => DynamoDBUtil.toValue(computed.getKey() || 'NULL');
+const getKey = <T extends ModelType>(computed: ModelIndexedComputedIndex<T>): AttributeValue =>
+  DynamoDBUtil.toValue(computed.getKey() || 'NULL');
 const getSort = <T extends ModelType>(computed: ModelIndexedComputedIndex<T>): AttributeValue => DynamoDBUtil.toValue(computed.getSort());
 
 /**
@@ -28,12 +55,13 @@ const getSort = <T extends ModelType>(computed: ModelIndexedComputedIndex<T>): A
  */
 @Injectable()
 export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySupport, ModelStorageSupport, ModelIndexedSupport {
-
   idSource = ModelCrudUtil.uuidSource();
   client: DynamoDB;
   config: DynamoDBModelConfig;
 
-  constructor(config: DynamoDBModelConfig) { this.config = config; }
+  constructor(config: DynamoDBModelConfig) {
+    this.config = config;
+  }
 
   #resolveTable(cls: Class): string {
     let table = ModelRegistryIndex.getStoreName(cls);
@@ -43,11 +71,11 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     return table;
   }
 
-  async * #scanCollection<T extends ModelType>(
+  async *#scanCollection<T extends ModelType>(
     cls: Class<T>,
     query: (batchSize: number, lastKey: Record<string, AttributeValue> | undefined) => Promise<QueryCommandOutput>,
-    options?: ModelListOptions & ModelPageOptions<Record<string, AttributeValue>>,
-  ): AsyncIterable<{ items: T[], lastKey?: Record<string, AttributeValue> }> {
+    options?: ModelListOptions & ModelPageOptions<Record<string, AttributeValue>>
+  ): AsyncIterable<{ items: T[]; lastKey?: Record<string, AttributeValue> }> {
     const batchSize = options?.batchSizeHint ?? 100;
     const limit = options?.limit ?? Number.MAX_SAFE_INTEGER;
     let startKey = options?.offset ?? undefined;
@@ -59,26 +87,25 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
       if (batch.Count && batch.Items) {
         produced += batch.Count;
 
-        const items = (produced > limit) ? batch.Items.slice(0, remaining) : batch.Items;
+        const items = produced > limit ? batch.Items.slice(0, remaining) : batch.Items;
         startKey = batch.LastEvaluatedKey;
         yield {
-          items: await ModelCrudUtil.filterOutNotFound(
-            items.map(item => DynamoDBUtil.loadAndCheckExpiry(cls, item.body.S!))),
+          items: await ModelCrudUtil.filterOutNotFound(items.map(item => DynamoDBUtil.loadAndCheckExpiry(cls, item.body.S!))),
           lastKey: startKey
         };
       } else {
         startKey = undefined;
       }
-    } while (startKey && produced < limit && !(options?.abort?.aborted));
+    } while (startKey && produced < limit && !options?.abort?.aborted);
   }
 
-  async * #scanIndex<T extends ModelType>(
+  async *#scanIndex<T extends ModelType>(
     cls: Class<T>,
     idx: SortedIndex<T>,
     body: KeyedIndexBody<T>,
     options?: ModelPageOptions<Record<string, AttributeValue>> & ModelListOptions,
     transform?: (query: QueryCommandInput) => QueryCommandInput
-  ): AsyncIterable<{ items: T[], lastKey?: Record<string, AttributeValue> }> {
+  ): AsyncIterable<{ items: T[]; lastKey?: Record<string, AttributeValue> }> {
     ModelCrudUtil.ensureNotSubType(cls);
     const computed = ModelIndexedComputedIndex.get(idx, body).validate();
     const { keyIndexName, keyIndexAttribute } = DynamoDBUtil.indexNames(idx.name);
@@ -86,25 +113,29 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
 
     const finalTransform = transform ?? ((query): QueryCommandInput => query);
 
-    yield* this.#scanCollection(cls, (batchSize, lastKey) => {
-      const finalized = finalTransform({
-        TableName: this.#resolveTable(cls),
-        IndexName: keyIndexName,
-        ProjectionExpression: 'body',
-        KeyConditionExpression: `${keyIndexAttribute} = :${keyIndexName}`,
-        ExpressionAttributeValues: expression,
-        Limit: batchSize,
-        ExclusiveStartKey: lastKey,
-      });
-      return this.client.query(finalized);
-    }, options);
+    yield* this.#scanCollection(
+      cls,
+      (batchSize, lastKey) => {
+        const finalized = finalTransform({
+          TableName: this.#resolveTable(cls),
+          IndexName: keyIndexName,
+          ProjectionExpression: 'body',
+          KeyConditionExpression: `${keyIndexAttribute} = :${keyIndexName}`,
+          ExpressionAttributeValues: expression,
+          Limit: batchSize,
+          ExclusiveStartKey: lastKey
+        });
+        return this.client.query(finalized);
+      },
+      options
+    );
   }
 
-  async #getIdByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): Promise<string> {
+  async #getIdByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: FullKeyedIndexBody<T, K, S>
+  ): Promise<string> {
     ModelCrudUtil.ensureNotSubType(cls);
 
     const computed = ModelIndexedComputedIndex.get(idx, body).validate({ sort: true });
@@ -119,11 +150,12 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
       KeyConditionExpression: [
         ...(sorted ? [`${sortIndexAttribute} = :${sortIndexName}`] : []),
         `${keyIndexAttribute} = :${keyIndexName}`
-      ]
-        .join(' and '),
-      ...(computed.idPart ? {
-        FilterExpression: 'id = :id'
-      } : {}),
+      ].join(' and '),
+      ...(computed.idPart
+        ? {
+            FilterExpression: 'id = :id'
+          }
+        : {}),
       ExpressionAttributeValues: {
         [`:${keyIndexName}`]: getKey(computed),
         ...(sorted ? { [`:${sortIndexName}`]: getSort(computed) } : {}),
@@ -134,7 +166,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     try {
       const result = await this.client.query(query);
 
-      if (result.Count && result.Items && result.Items[0]) {
+      if (result.Count && result.Items?.[0]) {
         return result.Items[0].id.S!;
       }
       throw new NotFoundError(`${cls.name} Index=${idx}`, computed.getKey({ sort: true }));
@@ -146,7 +178,12 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     }
   }
 
-  async #putItem<T extends ModelType>(cls: Class<T>, id: string, item: T, mode: 'create' | 'update' | 'upsert'): Promise<PutItemCommandOutput> {
+  async #putItem<T extends ModelType>(
+    cls: Class<T>,
+    id: string,
+    item: T,
+    mode: 'create' | 'update' | 'upsert'
+  ): Promise<PutItemCommandOutput> {
     const config = ModelRegistryIndex.getConfig(cls);
     let expiry: number | undefined;
 
@@ -165,7 +202,9 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
             const { keyIndexAttribute, sortIndexAttribute } = DynamoDBUtil.indexNames(idx.name);
             const computed = ModelIndexedComputedIndex.get(idx, item).validate({ sort: true });
             switch (idx.type) {
-              case 'indexed:keyed': indices[keyIndexAttribute] = getKey(computed); break;
+              case 'indexed:keyed':
+                indices[keyIndexAttribute] = getKey(computed);
+                break;
               case 'indexed:sorted': {
                 indices[keyIndexAttribute] = getKey(computed);
                 indices[sortIndexAttribute] = getSort(computed);
@@ -219,11 +258,9 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
           TableName: this.#resolveTable(cls),
           ConditionExpression: mode === 'update' ? 'attribute_exists(body)' : undefined,
           Key: { id: { S: id } },
-          UpdateExpression: `SET ${[
-            'body=:body',
-            expiry !== undefined ? `${EXPIRES_ATTRIBUTE}=:expr` : undefined,
-            ...expr
-          ].filter(part => !!part).join(', ')}`,
+          UpdateExpression: `SET ${['body=:body', expiry !== undefined ? `${EXPIRES_ATTRIBUTE}=:expr` : undefined, ...expr]
+            .filter(part => !!part)
+            .join(', ')}`,
           ExpressionAttributeValues: {
             ':body': DynamoDBUtil.toValue(JSONUtil.toUTF8(item)),
             ...(expiry !== undefined ? { ':expr': DynamoDBUtil.toValue(expiry) } : {}),
@@ -272,10 +309,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
         TableName: table,
         KeySchema: [{ KeyType: 'HASH', AttributeName: 'id' }],
         BillingMode: 'PAY_PER_REQUEST',
-        AttributeDefinitions: [
-          { AttributeName: 'id', AttributeType: 'S' },
-          ...idx.attributes
-        ],
+        AttributeDefinitions: [{ AttributeName: 'id', AttributeType: 'S' }, ...idx.attributes],
         GlobalSecondaryIndexes: idx.indices
       });
     } else {
@@ -287,10 +321,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
       if (changedAttributes.length || indexUpdates?.length) {
         await this.client.updateTable({
           TableName: table,
-          AttributeDefinitions: [
-            { AttributeName: 'id', AttributeType: 'S' },
-            ...idx.attributes
-          ],
+          AttributeDefinitions: [{ AttributeName: 'id', AttributeType: 'S' }, ...idx.attributes],
           GlobalSecondaryIndexUpdates: indexUpdates
         });
       }
@@ -312,7 +343,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
    */
   async deleteModel(cls: Class<ModelType>): Promise<void> {
     const table = this.#resolveTable(cls);
-    const { Table: verify } = (await this.client.describeTable({ TableName: table }).catch(() => ({ Table: undefined })));
+    const { Table: verify } = await this.client.describeTable({ TableName: table }).catch(() => ({ Table: undefined }));
     if (verify) {
       await this.client.deleteTable({ TableName: table });
     }
@@ -324,9 +355,11 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
 
   async deleteStorage(): Promise<void> {
     for (const model of ModelRegistryIndex.getClasses()) {
-      await this.client.deleteTable({
-        TableName: this.#resolveTable(model)
-      }).catch(() => { });
+      await this.client
+        .deleteTable({
+          TableName: this.#resolveTable(model)
+        })
+        .catch(() => {});
     }
   }
 
@@ -337,7 +370,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
       Key: { id: DynamoDBUtil.toValue(id) }
     });
 
-    if (result && result.Item && result.Item.body) {
+    if (result?.Item?.body) {
       return DynamoDBUtil.loadAndCheckExpiry(cls, result.Item.body.S!);
     }
     throw new NotFoundError(cls, id);
@@ -386,12 +419,17 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     }
   }
 
-  async * list<T extends ModelType>(cls: Class<T>, options?: ModelListOptions): AsyncIterable<T[]> {
-    for await (const { items } of this.#scanCollection(cls, (batchSize, lastKey) => this.client.scan({
-      TableName: this.#resolveTable(cls),
-      ExclusiveStartKey: lastKey,
-      Limit: batchSize
-    }), options)) {
+  async *list<T extends ModelType>(cls: Class<T>, options?: ModelListOptions): AsyncIterable<T[]> {
+    for await (const { items } of this.#scanCollection(
+      cls,
+      (batchSize, lastKey) =>
+        this.client.scan({
+          TableName: this.#resolveTable(cls),
+          ExclusiveStartKey: lastKey,
+          Limit: batchSize
+        }),
+      options
+    )) {
       yield items;
     }
   }
@@ -402,56 +440,52 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
   }
 
   // Indexed
-  async getByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): Promise<T> {
+  async getByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: FullKeyedIndexBody<T, K, S>
+  ): Promise<T> {
     return this.get(cls, await this.#getIdByIndex(cls, idx, body));
   }
 
-  async deleteByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexBody<T, K, S>): Promise<void> {
+  async deleteByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: FullKeyedIndexBody<T, K, S>
+  ): Promise<void> {
     return this.delete(cls, await this.#getIdByIndex(cls, idx, body));
   }
 
-  upsertByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: OptionalId<T>): Promise<T> {
+  upsertByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: OptionalId<T>
+  ): Promise<T> {
     return ModelIndexedUtil.naiveUpsert(this, cls, idx, body);
   }
 
-  async updateByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: T): Promise<T> {
+  async updateByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: T
+  ): Promise<T> {
     return ModelIndexedUtil.naiveUpdate(this, cls, idx, body);
   }
 
-  async updatePartialByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(cls: Class<T>, idx: SingleItemIndex<T, K, S>, body: FullKeyedIndexWithPartialBody<T, K, S>): Promise<T> {
+  async updatePartialByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
+    cls: Class<T>,
+    idx: SingleItemIndex<T, K, S>,
+    body: FullKeyedIndexWithPartialBody<T, K, S>
+  ): Promise<T> {
     const item = await ModelCrudUtil.naivePartialUpdate(cls, () => this.getByIndex(cls, idx, castTo(body)), castTo(body));
     return this.update(cls, item);
   }
 
-  async pageByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(
+  async pageByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
     cls: Class<T>,
     idx: SortedIndex<T, K, S>,
     body: KeyedIndexBody<T, K>,
-    options?: ModelPageOptions,
+    options?: ModelPageOptions
   ): Promise<ModelPageResult<T>> {
     const output: T[] = [];
     const offset = options?.offset ? JSONUtil.fromBase64<Record<string, AttributeValue>>(options.offset) : undefined;
@@ -459,7 +493,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
       output.push(...items);
     }
 
-    let nextOffset;
+    let nextOffset: string | undefined;
     if (output.length) {
       const last: T = output.at(-1)!;
       const computed = ModelIndexedComputedIndex.get(idx, last).validate();
@@ -474,11 +508,7 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     return { items: output, nextOffset };
   }
 
-  async * listByIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(
+  async *listByIndex<T extends ModelType, K extends KeyedIndexSelection<T>, S extends SortedIndexSelection<T>>(
     cls: Class<T>,
     idx: SortedIndex<T, K, S>,
     body: KeyedIndexBody<T, K>,
@@ -499,21 +529,17 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
 
     const { sortIndexAttribute } = DynamoDBUtil.indexNames(idx.name);
 
-    for await (const { items } of this.#scanIndex(cls, idx, body, { limit: 10, ...options },
-      (query) => ({
-        ...query,
-        KeyConditionExpression: [query.KeyConditionExpression, `begins_with(${sortIndexAttribute}, :prefix)`]
-          .filter(Boolean)
-          .join(' AND '),
-        ExpressionAttributeValues: {
-          ...query.ExpressionAttributeValues,
-          ':prefix': { S: prefix }
-        }
-      })
-    )) {
+    for await (const { items } of this.#scanIndex(cls, idx, body, { limit: 10, ...options }, query => ({
+      ...query,
+      KeyConditionExpression: [query.KeyConditionExpression, `begins_with(${sortIndexAttribute}, :prefix)`].filter(Boolean).join(' AND '),
+      ExpressionAttributeValues: {
+        ...query.ExpressionAttributeValues,
+        ':prefix': { S: prefix }
+      }
+    }))) {
       results.push(...items);
     }
 
     return results;
   }
-}
+}

package/src/util.ts

@@ -1,11 +1,15 @@
 import type {
-  AttributeDefinition, AttributeValue, GlobalSecondaryIndex, GlobalSecondaryIndexDescription,
-  GlobalSecondaryIndexUpdate, KeySchemaElement
+  AttributeDefinition,
+  AttributeValue,
+  GlobalSecondaryIndex,
+  GlobalSecondaryIndexDescription,
+  GlobalSecondaryIndexUpdate,
+  KeySchemaElement
 } from '@aws-sdk/client-dynamodb';
 
-import { type Class, castTo } from '@travetto/runtime';
-import { ModelCrudUtil, ModelExpiryUtil, ModelRegistryIndex, NotFoundError, type ModelType } from '@travetto/model';
+import { ModelCrudUtil, ModelExpiryUtil, ModelRegistryIndex, type ModelType, NotFoundError } from '@travetto/model';
 import { isModelIndexedIndex, warnIfIndexedUniqueIndex, warnIfNonIndexedIndex } from '@travetto/model-indexed';
+import { type Class, castTo } from '@travetto/runtime';
 import { SchemaRegistryIndex } from '@travetto/schema';
 
 /**
@@ -20,8 +24,9 @@ type DynamoIndexConfig = {
  * Utility class for DynamoDB operations and transformations.
  */
 export class DynamoDBUtil {
-
-  static indexNames = (name: string): { keyIndexName: string, sortIndexName: string, keyIndexAttribute: string, sortIndexAttribute: string } => {
+  static indexNames = (
+    name: string
+  ): { keyIndexName: string; sortIndexName: string; keyIndexAttribute: string; sortIndexAttribute: string } => {
     const base = name.toLowerCase().replace(/[^A-Za-z0-9]+/g, '_');
     return {
       keyIndexName: base,
@@ -86,7 +91,7 @@ export class DynamoDBUtil {
           }
 
           keys.push({ AttributeName: keyIndexAttribute, KeyType: 'HASH' });
-          keys.push({ AttributeName: sortIndexAttribute, KeyType: 'RANGE', });
+          keys.push({ AttributeName: sortIndexAttribute, KeyType: 'RANGE' });
           attributes.push({ AttributeName: keyIndexAttribute, AttributeType: 'S' });
           attributes.push({ AttributeName: sortIndexAttribute, AttributeType: castTo(fieldType) === String ? 'S' : 'N' });
           break;
@@ -116,7 +121,10 @@ export class DynamoDBUtil {
    * Identifies attribute definitions that have changed between current and requested configurations.
    * Compares attribute names and types to determine additions, removals, or modifications.
    */
-  static findChangedAttributes(current: AttributeDefinition[] | undefined, requested: AttributeDefinition[] | undefined): AttributeDefinition[] {
+  static findChangedAttributes(
+    current: AttributeDefinition[] | undefined,
+    requested: AttributeDefinition[] | undefined
+  ): AttributeDefinition[] {
     const currentMap = Object.fromEntries((current ?? []).map(attr => [attr.AttributeName, attr]));
     const pendingMap = Object.fromEntries((requested ?? []).map(attr => [attr.AttributeName, attr]));
 
@@ -145,7 +153,10 @@ export class DynamoDBUtil {
    * Identifies global secondary indices that have changed between current and requested configurations.
    * Generates update operations for creating new indices or deleting removed indices.
    */
-  static findChangedGlobalIndexes(current: GlobalSecondaryIndexDescription[] | undefined, requested: GlobalSecondaryIndex[] | undefined): GlobalSecondaryIndexUpdate[] {
+  static findChangedGlobalIndexes(
+    current: GlobalSecondaryIndexDescription[] | undefined,
+    requested: GlobalSecondaryIndex[] | undefined
+  ): GlobalSecondaryIndexUpdate[] {
     const existingMap = Object.fromEntries((current ?? []).map(index => [index.IndexName, index]));
     const pendingMap = Object.fromEntries((requested ?? []).map(index => [index.IndexName, index]));
 

package/support/service.dynamodb.ts

@@ -7,4 +7,4 @@ export const service: ServiceDescriptor = {
   version,
   port: 8000,
   image: `amazon/dynamodb-local:${version}`
-};
+};