Start query implementation

Author: mikebroberts

packages/dynamodb-entity-store-testutils/src/conditionExpressionEvaluator.ts

@@ -1,4 +1,5 @@
 import { NativeAttributeValue } from '@aws-sdk/lib-dynamodb'
+import { resolveAttributeName, resolveAttributeValue } from './expressionEvaluatorUtils.js'
 
 // TODO - WARNING! THIS CODE IS FOR TESTS ONLY! DON'T USE THIS IN PRODUCTION
 //   I haven't fully validated this implementation, and so I can't guarantee it is correct
@@ -189,7 +190,7 @@ function splitByOperator(expression: string, operator: string): { left: string;
  * Evaluates a function call.
  */
 function evaluateFunction(functionName: string, arg: string, context: EvaluationContext): boolean {
-  const resolvedPath = resolveAttributeName(arg, context)
+  const resolvedPath = resolveAttributeName(arg, context.expressionAttributeNames)
   const value = getValueAtPath(resolvedPath, context.item)
 
   switch (functionName.toLowerCase()) {
@@ -232,41 +233,14 @@ function resolveValue(expression: string, context: EvaluationContext): NativeAtt
 
   // Check if it's an expression attribute value
   if (trimmed.startsWith(':')) {
-    if (!context.expressionAttributeValues) {
-      throw new Error(`Expression attribute value ${trimmed} used but no ExpressionAttributeValues provided`)
-    }
-    const value = context.expressionAttributeValues[trimmed]
-    if (value === undefined) {
-      throw new Error(`Expression attribute value ${trimmed} not found in ExpressionAttributeValues`)
-    }
-    return value
+    return resolveAttributeValue(trimmed, context.expressionAttributeValues)
   }
 
   // Otherwise, it's an attribute path
-  const resolvedPath = resolveAttributeName(trimmed, context)
+  const resolvedPath = resolveAttributeName(trimmed, context.expressionAttributeNames)
   return getValueAtPath(resolvedPath, context.item)
 }
 
-/**
- * Resolves an attribute name (handles #placeholder syntax).
- */
-function resolveAttributeName(name: string, context: EvaluationContext): string {
-  const trimmed = name.trim()
-
-  if (trimmed.startsWith('#')) {
-    if (!context.expressionAttributeNames) {
-      throw new Error(`Expression attribute name ${trimmed} used but no ExpressionAttributeNames provided`)
-    }
-    const resolved = context.expressionAttributeNames[trimmed]
-    if (resolved === undefined) {
-      throw new Error(`Expression attribute name ${trimmed} not found in ExpressionAttributeNames`)
-    }
-    return resolved
-  }
-
-  return trimmed
-}
-
 /**
  * Gets a value at a given path in the item.
  */

packages/dynamodb-entity-store-testutils/src/expressionEvaluatorUtils.ts

@@ -0,0 +1,60 @@
+import { NativeAttributeValue } from '@aws-sdk/lib-dynamodb'
+
+/**
+ * Shared utilities for DynamoDB expression evaluation.
+ * Used by both condition expression and key condition expression evaluators.
+ */
+
+/**
+ * Resolves an attribute name (handles #placeholder syntax).
+ */
+export function resolveAttributeName(
+  name: string,
+  expressionAttributeNames?: Record<string, string>
+): string {
+  const trimmed = name.trim()
+
+  if (trimmed.startsWith('#')) {
+    if (!expressionAttributeNames) {
+      throw new Error(
+        `Expression attribute name ${trimmed} used but no ExpressionAttributeNames provided`
+      )
+    }
+    const resolved = expressionAttributeNames[trimmed]
+    if (resolved === undefined) {
+      throw new Error(`Expression attribute name ${trimmed} not found in ExpressionAttributeNames`)
+    }
+    return resolved
+  }
+
+  return trimmed
+}
+
+/**
+ * Resolves an attribute value (handles :placeholder syntax).
+ */
+export function resolveAttributeValue(
+  placeholder: string,
+  expressionAttributeValues?: Record<string, NativeAttributeValue>
+): NativeAttributeValue {
+  const trimmed = placeholder.trim()
+
+  if (!trimmed.startsWith(':')) {
+    throw new Error(`Expected value placeholder starting with ':', got: ${trimmed}`)
+  }
+
+  if (!expressionAttributeValues) {
+    throw new Error(
+      `Expression attribute value ${trimmed} used but no ExpressionAttributeValues provided`
+    )
+  }
+
+  const value = expressionAttributeValues[trimmed]
+  if (value === undefined) {
+    throw new Error(
+      `Expression attribute value ${trimmed} not found in ExpressionAttributeValues`
+    )
+  }
+
+  return value
+}

packages/dynamodb-entity-store-testutils/src/fakeDynamoDBInterface.ts

@@ -21,6 +21,10 @@ import {
 } from '@aws-sdk/lib-dynamodb'
 import { DynamoDBInterface } from '@symphoniacloud/dynamodb-entity-store'
 import { evaluateConditionExpression } from './conditionExpressionEvaluator.js'
+import {
+  parseKeyConditionExpression,
+  matchesKeyCondition
+} from './keyConditionExpressionEvaluator.js'
 
 export const METADATA = { $metadata: {} }
 
@@ -36,13 +40,36 @@ const supportedParamKeysByFunction = {
   delete: ['TableName', 'Key'],
   batchWrite: ['RequestItems'],
   transactionWrite: ['TransactItems'],
+  queryOnePage: [
+    'TableName',
+    'KeyConditionExpression',
+    'ExpressionAttributeNames',
+    'ExpressionAttributeValues',
+    'Limit',
+    'ExclusiveStartKey'
+  ],
+  queryAllPages: [
+    'TableName',
+    'KeyConditionExpression',
+    'ExpressionAttributeNames',
+    'ExpressionAttributeValues'
+  ],
   scanOnePage: ['TableName'],
   scanAllPages: ['TableName']
 }
 
 function checkSupportedParams(
   params: object,
-  functionName: 'put' | 'get' | 'delete' | 'batchWrite' | 'transactionWrite' | 'scanOnePage' | 'scanAllPages'
+  functionName:
+    | 'put'
+    | 'get'
+    | 'delete'
+    | 'batchWrite'
+    | 'transactionWrite'
+    | 'queryOnePage'
+    | 'queryAllPages'
+    | 'scanOnePage'
+    | 'scanAllPages'
 ) {
   const unsupportedKeys = Object.keys(params).filter(
     (key) => !supportedParamKeysByFunction[functionName].includes(key)
@@ -152,20 +179,52 @@ export class FakeDynamoDBInterface implements DynamoDBInterface {
     throw new Error('Not yet implemented')
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async queryOnePage(params: QueryCommandInput): Promise<QueryCommandOutput> {
-    throw new Error('Not yet implemented')
+    checkSupportedParams(params, 'queryOnePage')
+    const items = this.executeQuery(params)
+
+    // Apply limit if specified
+    const limitedItems = params.Limit ? items.slice(0, params.Limit) : items
+
+    return {
+      Items: limitedItems,
+      ...METADATA
+    }
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   async queryAllPages(params: QueryCommandInput): Promise<QueryCommandOutput[]> {
-    throw new Error('Not yet implemented')
+    checkSupportedParams(params, 'queryAllPages')
+    const items = this.executeQuery(params)
+
+    return [
+      {
+        Items: items,
+        ...METADATA
+      }
+    ]
+  }
+
+  private executeQuery(params: QueryCommandInput): Record<string, NativeAttributeValue>[] {
+    if (!params.KeyConditionExpression) {
+      throw new Error('KeyConditionExpression is required for query')
+    }
+
+    // Parse the key condition
+    const keyCondition = parseKeyConditionExpression(
+      params.KeyConditionExpression,
+      params.ExpressionAttributeNames,
+      params.ExpressionAttributeValues
+    )
+
+    // Get all items and filter by key condition
+    const allItems = this.getTableFrom(params).allItems()
+    return allItems.filter((item) => matchesKeyCondition(item, keyCondition))
   }
 
   async scanOnePage(params: ScanCommandInput): Promise<ScanCommandOutput> {
     checkSupportedParams(params, 'scanOnePage')
     return {
-      Items: this.getTableFrom(params).allItems(),
+      Items: this.executeScan(params),
       ...METADATA
     }
   }
@@ -174,12 +233,16 @@ export class FakeDynamoDBInterface implements DynamoDBInterface {
     checkSupportedParams(params, 'scanAllPages')
     return [
       {
-        Items: this.getTableFrom(params).allItems(),
+        Items: this.executeScan(params),
         ...METADATA
       }
     ]
   }
 
+  private executeScan(params: ScanCommandInput): Record<string, NativeAttributeValue>[] {
+    return this.getTableFrom(params).allItems()
+  }
+
   private getTableFrom(withTableName: { TableName: string | undefined }) {
     return this.getTable(withTableName.TableName)
   }

packages/dynamodb-entity-store-testutils/src/index.ts

@@ -4,3 +4,10 @@ export {
   UnsupportedConditionExpressionError,
   ConditionalCheckFailedException
 } from './conditionExpressionEvaluator.js'
+export {
+  parseKeyConditionExpression,
+  matchesKeyCondition,
+  UnsupportedKeyConditionExpressionError,
+  type KeyCondition
+} from './keyConditionExpressionEvaluator.js'
+export { resolveAttributeName, resolveAttributeValue } from './expressionEvaluatorUtils.js'