@travetto/model-dynamodb 8.0.0-alpha.16 → 8.0.0-alpha.17

package/README.md

@@ -18,7 +18,7 @@ This module provides an [DynamoDB](https://aws.amazon.com/dynamodb/)-based imple
 Supported features:
    *  [CRUD](https://github.com/travetto/travetto/tree/main/module/model/src/types/crud.ts#L11)
    *  [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#L15)
+   *  [Indexed](https://github.com/travetto/travetto/tree/main/module/model-indexed/src/types/service.ts#L16)
 
 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.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@travetto/model-dynamodb",
-  "version": "8.0.0-alpha.16",
+  "version": "8.0.0-alpha.17",
   "type": "module",
   "description": "DynamoDB backing for the travetto model module.",
   "keywords": [
@@ -26,13 +26,13 @@
     "directory": "module/model-dynamodb"
   },
   "dependencies": {
-    "@aws-sdk/client-dynamodb": "^3.1030.0",
-    "@travetto/config": "^8.0.0-alpha.14",
-    "@travetto/model": "^8.0.0-alpha.14",
-    "@travetto/model-indexed": "^8.0.0-alpha.16"
+    "@aws-sdk/client-dynamodb": "^3.1031.0",
+    "@travetto/config": "^8.0.0-alpha.15",
+    "@travetto/model": "^8.0.0-alpha.15",
+    "@travetto/model-indexed": "^8.0.0-alpha.17"
   },
   "peerDependencies": {
-    "@travetto/cli": "^8.0.0-alpha.19"
+    "@travetto/cli": "^8.0.0-alpha.20"
   },
   "peerDependenciesMeta": {
     "@travetto/cli": {

package/src/service.ts

@@ -12,7 +12,7 @@ import {
   isModelIndexedIndex, ModelIndexedUtil, type KeyedIndexBody, type KeyedIndexSelection,
   type ModelPageOptions, type ModelPageResult, type ModelIndexedSupport, type SingleItemIndex,
   type FullKeyedIndexBody, type FullKeyedIndexWithPartialBody, type SortedIndex, type SortedIndexSelection,
-  ModelIndexedComputedIndex
+  ModelIndexedComputedIndex, type ModelIndexedSearchOptions, type SortedIndexSelectionType
 } from '@travetto/model-indexed';
 
 import type { DynamoDBModelConfig } from './config.ts';
@@ -72,30 +72,32 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     } while (startKey && produced < limit && !(options?.abort?.aborted));
   }
 
-  async * #scanIndex<
-    T extends ModelType,
-    K extends KeyedIndexSelection<T>,
-    S extends SortedIndexSelection<T>
-  >(
+  async * #scanIndex<T extends ModelType>(
     cls: Class<T>,
-    idx: SortedIndex<T, K, S>,
-    body: KeyedIndexBody<T, K>,
-    options?: ModelPageOptions<Record<string, AttributeValue>> & ModelListOptions
+    idx: SortedIndex<T>,
+    body: KeyedIndexBody<T>,
+    options?: ModelPageOptions<Record<string, AttributeValue>> & ModelListOptions,
+    transform?: (query: QueryCommandInput) => QueryCommandInput
   ): AsyncIterable<{ items: T[], lastKey?: Record<string, AttributeValue> }> {
     ModelCrudUtil.ensureNotSubType(cls);
     const computed = ModelIndexedComputedIndex.get(idx, body).validate();
-    const safeName = DynamoDBUtil.toSafeName(idx.name);
-    const expression = { [`:${safeName}`]: getKey(computed) };
-
-    yield* this.#scanCollection(cls, (batchSize, lastKey) => this.client.query({
-      TableName: this.#resolveTable(cls),
-      IndexName: safeName,
-      ProjectionExpression: 'body',
-      KeyConditionExpression: `${safeName}__ = :${safeName}`,
-      ExpressionAttributeValues: expression,
-      Limit: batchSize,
-      ExclusiveStartKey: lastKey,
-    }), options);
+    const { keyIndexName, keyIndexAttribute } = DynamoDBUtil.indexNames(idx.name);
+    const expression = { [`:${keyIndexName}`]: getKey(computed) };
+
+    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);
   }
 
   async #getIdByIndex<
@@ -107,24 +109,24 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
 
     const computed = ModelIndexedComputedIndex.get(idx, body).validate({ sort: true });
 
-    const safeName = DynamoDBUtil.toSafeName(idx.name);
+    const { keyIndexName, keyIndexAttribute, sortIndexAttribute, sortIndexName } = DynamoDBUtil.indexNames(idx.name);
     const sorted = idx.type === 'indexed:sorted';
 
     const query: QueryCommandInput = {
       TableName: this.#resolveTable(cls),
-      IndexName: safeName,
+      IndexName: keyIndexName,
       ProjectionExpression: 'id',
       KeyConditionExpression: [
-        ...(sorted ? [`${safeName}_sort__ = :${safeName}_sort`] : []),
-        `${safeName}__ = :${safeName}`
+        ...(sorted ? [`${sortIndexAttribute} = :${sortIndexName}`] : []),
+        `${keyIndexAttribute} = :${keyIndexName}`
       ]
         .join(' and '),
       ...(computed.idPart ? {
         FilterExpression: 'id = :id'
       } : {}),
       ExpressionAttributeValues: {
-        [`:${safeName}`]: getKey(computed),
-        ...(sorted ? { [`:${safeName}_sort`]: getSort(computed) } : {}),
+        [`:${keyIndexName}`]: getKey(computed),
+        ...(sorted ? { [`:${sortIndexName}`]: getSort(computed) } : {}),
         ...(computed.idPart ? { ':id': DynamoDBUtil.toValue(computed.idPart.value) } : {})
       }
     };
@@ -160,13 +162,13 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
         const indices: Record<string, unknown> = {};
         for (const idx of ModelRegistryIndex.getIndices(cls)) {
           if (isModelIndexedIndex(idx)) {
-            const safeName = DynamoDBUtil.toSafeName(idx.name);
+            const { keyIndexAttribute, sortIndexAttribute } = DynamoDBUtil.indexNames(idx.name);
             const computed = ModelIndexedComputedIndex.get(idx, item).validate({ sort: true });
             switch (idx.type) {
-              case 'indexed:keyed': indices[`${safeName}__`] = getKey(computed); break;
+              case 'indexed:keyed': indices[keyIndexAttribute] = getKey(computed); break;
               case 'indexed:sorted': {
-                indices[`${safeName}__`] = getKey(computed);
-                indices[`${safeName}_sort__`] = getSort(computed);
+                indices[keyIndexAttribute] = getKey(computed);
+                indices[sortIndexAttribute] = getSort(computed);
                 break;
               }
             }
@@ -192,19 +194,19 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
 
         for (const idx of ModelRegistryIndex.getIndices(cls)) {
           if (isModelIndexedIndex(idx)) {
-            const safeName = DynamoDBUtil.toSafeName(idx.name);
+            const { keyIndexAttribute, sortIndexAttribute, keyIndexName, sortIndexName } = DynamoDBUtil.indexNames(idx.name);
             const computed = ModelIndexedComputedIndex.get(idx, item).validate({ sort: true });
             switch (idx.type) {
               case 'indexed:keyed': {
-                indices[`:${safeName}`] = getKey(computed);
-                expr.push(`${safeName}__ = :${safeName}`);
+                indices[`:${keyIndexName}`] = getKey(computed);
+                expr.push(`${keyIndexAttribute} = :${keyIndexName}`);
                 break;
               }
               case 'indexed:sorted': {
-                indices[`:${safeName}`] = getKey(computed);
-                indices[`:${safeName}_sort`] = getSort(computed);
-                expr.push(`${safeName}__ = :${safeName}`);
-                expr.push(`${safeName}_sort__ = :${safeName}_sort`);
+                indices[`:${keyIndexName}`] = getKey(computed);
+                indices[`:${sortIndexName}`] = getSort(computed);
+                expr.push(`${keyIndexAttribute} = :${keyIndexName}`);
+                expr.push(`${sortIndexAttribute} = :${sortIndexName}`);
                 break;
               }
             }
@@ -461,10 +463,10 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
     if (output.length) {
       const last: T = output.at(-1)!;
       const computed = ModelIndexedComputedIndex.get(idx, last).validate();
-      const safeName = DynamoDBUtil.toSafeName(idx.name);
+      const { keyIndexAttribute, sortIndexAttribute } = DynamoDBUtil.indexNames(idx.name);
       nextOffset = JSONUtil.toBase64({
-        [`${safeName}__`]: getKey(computed),
-        [`${safeName}_sort__`]: getSort(computed),
+        [keyIndexAttribute]: getKey(computed),
+        [sortIndexAttribute]: getSort(computed),
         id: DynamoDBUtil.toValue(last.id)
       });
     }
@@ -486,4 +488,32 @@ export class DynamoDBModelService implements ModelCrudSupport, ModelExpirySuppor
       yield items;
     }
   }
+
+  async suggestByIndex<
+    T extends ModelType,
+    S extends SortedIndexSelection<T>,
+    K extends KeyedIndexSelection<T>,
+    B extends SortedIndexSelectionType<T, S> & string
+  >(cls: Class<T>, idx: SortedIndex<T, K, S>, body: KeyedIndexBody<T, K>, prefix: B, options?: ModelIndexedSearchOptions): Promise<T[]> {
+    const results: T[] = [];
+
+    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 }
+        }
+      })
+    )) {
+      results.push(...items);
+    }
+
+    return results;
+  }
 }

package/src/util.ts

@@ -3,9 +3,10 @@ import type {
   GlobalSecondaryIndexUpdate, KeySchemaElement
 } from '@aws-sdk/client-dynamodb';
 
-import type { Class } from '@travetto/runtime';
+import { type Class, castTo } from '@travetto/runtime';
 import { ModelCrudUtil, ModelExpiryUtil, ModelRegistryIndex, NotFoundError, type ModelType } from '@travetto/model';
-import { warnIfIndexedUniqueIndex, warnIfNonIndexedIndex } from '@travetto/model-indexed';
+import { isModelIndexedIndex, warnIfIndexedUniqueIndex, warnIfNonIndexedIndex } from '@travetto/model-indexed';
+import { SchemaRegistryIndex } from '@travetto/schema';
 
 /**
  * Configuration for DynamoDB indices
@@ -20,7 +21,15 @@ type DynamoIndexConfig = {
  */
 export class DynamoDBUtil {
 
-  static toSafeName = (name: string): string => name.toLowerCase().replace(/[^A-Za-z0-9]+/g, '_');
+  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,
+      sortIndexName: `${base}_sort`,
+      keyIndexAttribute: `${base}__`,
+      sortIndexAttribute: `${base}_sort__`
+    };
+  };
 
   /**
    * Converts a JavaScript value to a DynamoDB AttributeValue format
@@ -53,29 +62,44 @@ export class DynamoDBUtil {
 
     const filtered = indexes
       .filter(idx => !warnIfIndexedUniqueIndex(this, cls, [idx]))
-      .filter(idx => !warnIfNonIndexedIndex(this, cls, [idx]));
+      .filter(idx => !warnIfNonIndexedIndex(this, cls, [idx]))
+      .filter(isModelIndexedIndex);
 
     for (const idx of filtered) {
       const keys: KeySchemaElement[] = [];
 
-      const safeName = this.toSafeName(idx.name);
+      const { keyIndexName, keyIndexAttribute, sortIndexAttribute } = this.indexNames(idx.name);
 
       switch (idx.type) {
-        case 'indexed:sorted':
-          keys.push({ AttributeName: `${safeName}__`, KeyType: 'HASH' });
-          keys.push({ AttributeName: `${safeName}_sort__`, KeyType: 'RANGE', });
-          attributes.push({ AttributeName: `${safeName}__`, AttributeType: 'S' });
-          attributes.push({ AttributeName: `${safeName}_sort__`, AttributeType: 'N' });
+        case 'indexed:sorted': {
+          const path = idx.sortTemplate[0].path;
+          let fieldType = cls;
+          for (const field of path) {
+            if (SchemaRegistryIndex.has(fieldType)) {
+              const schema = SchemaRegistryIndex.getConfig(fieldType);
+              if (field in schema.fields) {
+                fieldType = schema.fields[field].type;
+              }
+            } else {
+              break;
+            }
+          }
+
+          keys.push({ AttributeName: keyIndexAttribute, KeyType: 'HASH' });
+          keys.push({ AttributeName: sortIndexAttribute, KeyType: 'RANGE', });
+          attributes.push({ AttributeName: keyIndexAttribute, AttributeType: 'S' });
+          attributes.push({ AttributeName: sortIndexAttribute, AttributeType: castTo(fieldType) === String ? 'S' : 'N' });
           break;
+        }
         case 'indexed:keyed': {
-          keys.push({ AttributeName: `${safeName}__`, KeyType: 'HASH' });
-          attributes.push({ AttributeName: `${safeName}__`, AttributeType: 'S' });
+          keys.push({ AttributeName: keyIndexAttribute, KeyType: 'HASH' });
+          attributes.push({ AttributeName: keyIndexAttribute, AttributeType: 'S' });
           break;
         }
       }
 
       toCreate.push({
-        IndexName: safeName,
+        IndexName: keyIndexName,
         // ProvisionedThroughput: '',
         Projection: {
           ProjectionType: 'INCLUDE',