wirejs-deploy-amplify-basic 0.0.70-table-resource → 0.0.72-table-resource

package/amplify-hosting-assets/compute/default/package.json

@@ -3,6 +3,6 @@
 	"dependencies": {
 		"jsdom": "^25.0.1",
 		"wirejs-dom": "^1.0.38",
-		"wirejs-resources": "^0.1.38-table-resource"
+		"wirejs-resources": "^0.1.40-table-resource"
 	}
 }

package/dist/resources/distributed-table.js

@@ -3,7 +3,11 @@ import { DynamoDBClient, } from '@aws-sdk/client-dynamodb';
 import { PutCommand, GetCommand, QueryCommand, ScanCommand, DeleteCommand, } from '@aws-sdk/lib-dynamodb';
 import { Resource, indexName } from 'wirejs-resources';
 import { addResource } from '../resource-collector.js';
+function fieldAlias(name) {
+    return `#a_${name}`;
+}
 function isFieldComparison(filter) {
+    console.log('Checking if filter is a field comparison:', filter);
     return !['and', 'or', 'not'].some(key => key in filter);
 }
 function buildFilterExpression(filter) {
@@ -20,24 +24,25 @@ function buildFilterExpression(filter) {
     if (!isFieldComparison(filter)) {
         throw new Error(`Unsupported filter: ${JSON.stringify(filter)}`);
     }
-    const [field] = Object.keys(filter);
-    const condition = filter[field];
+    const [baseField] = Object.keys(filter);
+    const field = fieldAlias(baseField);
+    const condition = filter[baseField];
     if ('eq' in condition)
-        return `${field} = :${field}`;
+        return `${field} = :${baseField}`;
     if ('ne' in condition)
-        return `${field} <> :${field}`;
+        return `${field} <> :${baseField}`;
     if ('gt' in condition)
-        return `${field} > :${field}`;
+        return `${field} > :${baseField}`;
     if ('ge' in condition)
-        return `${field} >= :${field}`;
+        return `${field} >= :${baseField}`;
     if ('lt' in condition)
-        return `${field} < :${field}`;
+        return `${field} < :${baseField}`;
     if ('le' in condition)
-        return `${field} <= :${field}`;
+        return `${field} <= :${baseField}`;
     if ('between' in condition)
-        return `${field} BETWEEN :${field}Low AND :${field}High`;
+        return `${field} BETWEEN :${baseField}Low AND :${baseField}High`;
     if ('beginsWith' in condition)
-        return `begins_with(${field}, :${field})`;
+        return `begins_with(${field}, :${baseField})`;
     throw new Error(`Unsupported filter condition: ${JSON.stringify(condition)}`);
 }
 function buildExpressionAttributeValues(filter) {
@@ -78,6 +83,27 @@ function buildExpressionAttributeValues(filter) {
     }
     return values;
 }
+function buildFieldAliasMap(filter) {
+    const aliasMap = {};
+    if (filter.and) {
+        for (const subFilter of filter.and) {
+            Object.assign(aliasMap, buildFieldAliasMap(subFilter));
+        }
+    }
+    else if (filter.or) {
+        for (const subFilter of filter.or) {
+            Object.assign(aliasMap, buildFieldAliasMap(subFilter));
+        }
+    }
+    else if (filter.not) {
+        Object.assign(aliasMap, buildFieldAliasMap(filter.not));
+    }
+    else if (isFieldComparison(filter)) {
+        const [field] = Object.keys(filter);
+        aliasMap[fieldAlias(field)] = field;
+    }
+    return aliasMap;
+}
 /**
  * A table of records that favors very high *overall* scalability at the expense of
  * scalability *between* partitions. Providers will distribute your data across many
@@ -168,12 +194,14 @@ export class DistributedTable extends Resource {
         console.log('Scanning DynamoDB table:', this.table, options);
         const filterExpression = options.filter ? buildFilterExpression(options.filter) : undefined;
         const expressionAttributeValues = options.filter ? buildExpressionAttributeValues(options.filter) : undefined;
+        const expressionAttributeNames = options.filter ? buildFieldAliasMap(options.filter) : undefined;
         let lastEvaluatedKey = undefined;
         do {
             const result = await this.ddbClient.send(new ScanCommand({
                 TableName: this.table,
                 FilterExpression: filterExpression,
                 ExpressionAttributeValues: expressionAttributeValues,
+                ExpressionAttributeNames: expressionAttributeNames,
                 ExclusiveStartKey: lastEvaluatedKey,
             }));
             for (const item of result.Items || []) {
@@ -190,7 +218,7 @@ export class DistributedTable extends Resource {
         // Build the key condition expression from the `where` clause
         const whereClauseAsFilter = {
             // decompose each `where` clause property into a separate condition.
-            and: Object.entries(options.where).map(([k, v]) => buildFilterExpression({ [k]: v }))
+            and: Object.entries(options.where).map(([k, v]) => ({ [k]: v }))
         };
         const keyConditionExpression = buildFilterExpression(whereClauseAsFilter);
         // Build the filter expression if provided
@@ -200,10 +228,22 @@ export class DistributedTable extends Resource {
             ...buildExpressionAttributeValues(whereClauseAsFilter),
             ...(options.filter ? buildExpressionAttributeValues(options.filter) : {}),
         };
+        const expressionAttributeNames = {
+            ...(options.filter ? buildFieldAliasMap(options.filter) : {}),
+            ...buildFieldAliasMap(whereClauseAsFilter),
+        };
         const isIndexNameTheDefault = options.by === indexName({
             partition: this.key.partition,
             sort: this.key.sort
         });
+        console.log('DynamoDB query params', {
+            TableName: this.table,
+            IndexName: isIndexNameTheDefault ? undefined : options.by,
+            KeyConditionExpression: keyConditionExpression,
+            FilterExpression: filterExpression,
+            ExpressionAttributeValues: expressionAttributeValues,
+            ExpressionAttributeNames: expressionAttributeNames,
+        });
         let lastEvaluatedKey = undefined;
         do {
             const result = await this.ddbClient.send(new QueryCommand({
@@ -212,6 +252,7 @@ export class DistributedTable extends Resource {
                 KeyConditionExpression: keyConditionExpression,
                 FilterExpression: filterExpression,
                 ExpressionAttributeValues: expressionAttributeValues,
+                ExpressionAttributeNames: expressionAttributeNames,
                 ExclusiveStartKey: lastEvaluatedKey,
             }));
             for (const item of result.Items || []) {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wirejs-deploy-amplify-basic",
-	"version": "0.0.70-table-resource",
+	"version": "0.0.72-table-resource",
 	"type": "module",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -32,14 +32,16 @@
 		"recursive-copy": "^2.0.14",
 		"rimraf": "^6.0.1",
 		"wirejs-dom": "^1.0.38",
-		"wirejs-resources": "^0.1.38-table-resource"
+		"wirejs-resources": "^0.1.40-table-resource"
 	},
 	"devDependencies": {
 		"@aws-amplify/backend": "^1.14.0",
 		"typescript": "^5.7.3"
 	},
 	"scripts": {
-		"build": "tsc"
+		"clean": "rimraf dist",
+		"build": "npm run clean && tsc",
+		"test": "node --import tsx --test test/**/*.test.ts"
 	},
 	"files": [
 		"amplify-backend-assets/*",