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

package/amplify-backend-assets/backend.ts

@@ -7,7 +7,7 @@ import { Bucket, BlockPublicAccess } from 'aws-cdk-lib/aws-s3';
 import { Table, AttributeType, BillingMode } from 'aws-cdk-lib/aws-dynamodb';
 import { api } from './functions/api/resource';
 import { auth } from './auth/resource';
-import { KeyFieldDefinition } from 'wirejs-resources';
+import { TableDefinition } from 'wirejs-resources';
 
 // @ts-ignore
 import generated from './generated-resources';
@@ -58,11 +58,7 @@ bucket.grantReadWrite(backend.api.resources.lambda);
  */
 function isDistributedTable(resource: any): resource is {
   type: 'DistributedTable';
-  options: {
-    absoluteId: string;
-    partitionKey: KeyFieldDefinition<any, any, any>;
-    sortKey: KeyFieldDefinition<any, any, any> | undefined;
-  }
+  options: TableDefinition;
 } {
   return resource.type === 'DistributedTable';
 }
@@ -76,6 +72,7 @@ const PKFieldTypes = {
 for (const resource of generated) {
   if (isDistributedTable(resource)) {
     const sanitizedId = resource.options.absoluteId.replace(/[^a-zA-Z0-9-_]/g, '_');
+
     const table = new Table(backend.stack, sanitizedId, {
       partitionKey: {
         name: resource.options.partitionKey.field,
@@ -90,6 +87,22 @@ for (const resource of generated) {
       billingMode: BillingMode.PAY_PER_REQUEST,
       pointInTimeRecovery: true,
     });
+
+    for (const index of resource.options.indexes ?? []) {
+      const gsi = table.addGlobalSecondaryIndex({
+        indexName: `by${index.partition.field}And${index.sort?.field ?? 'None'}`,
+        partitionKey: {
+          name: index.partition.field,
+          type: PKFieldTypes[index.partition.type],
+        },
+        sortKey: index.sort ? {
+          name: index.sort.field,
+          type: PKFieldTypes[index.sort.type],
+        } : undefined,
+      })
+      
+    }
+
     table.grantReadWriteData(backend.api.resources.lambda);
   }
 }

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.36-table-resource"
+		"wirejs-resources": "^0.1.38-table-resource"
 	}
 }

package/dist/resources/distributed-table.d.ts

@@ -1,6 +1,5 @@
 import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
-import { AnyKeyFieldOption, Filter, Parser, RecordKey, Resource } from 'wirejs-resources';
-export declare function PassThruParser<T>(record: Record<string, any>): T;
+import { AllIndexesByName, KeyCondition, IndexFieldNames, Filter, Index, KindaPretty, Parser, RecordKey, Resource, DistributedTable as BaseDistributedTable } from 'wirejs-resources';
 /**
  * A table of records that favors very high *overall* scalability at the expense of
  * scalability *between* partitions. Providers will distribute your data across many
@@ -12,31 +11,31 @@ export declare function PassThruParser<T>(record: Record<string, any>): T;
  *
  * High cardinality, non-sequential partition keys allow for the best overall scaling.
  */
-export declare class DistributedTable<const P extends Parser<any>, const T extends ReturnType<P>, const PK extends AnyKeyFieldOption<T>, const SK extends AnyKeyFieldOption<T> | undefined> extends Resource {
+export declare class DistributedTable<const P extends Parser<any>, const T extends KindaPretty<ReturnType<P>>, const Key extends Index<T>, const Indexes extends Index<T>[] | undefined = undefined> extends Resource implements Omit<BaseDistributedTable<P, T, Key, Indexes>, '#private'> {
     #private;
     parse: P;
-    partitionKey: PK;
-    sort: SK | undefined;
+    key: Key;
+    indexes: Indexes | undefined;
     ddbClient: DynamoDBClient;
-    table: string;
+    private table;
     constructor(scope: Resource | string, id: string, options: {
         parse: P;
-        key: {
-            partition: PK;
-            sort?: SK;
-        };
+        key: Key;
+        indexes?: Indexes;
     });
-    get partitionKeyName(): PK['field'];
-    get sortKeyName(): 'field' extends (keyof SK) ? SK['field'] : undefined;
+    get partitionKeyName(): Key['partition']['field'];
+    get sortKeyName(): 'field' extends keyof Key['sort'] ? (Key['sort']['field'] extends string ? Key['sort']['field'] : undefined) : undefined;
     save(item: T): Promise<void>;
     saveMany(items: T[]): Promise<void>;
-    delete(item: RecordKey<T, PK, SK>): Promise<void>;
-    deleteMany(items: (RecordKey<T, PK, SK>)[]): Promise<void>;
-    get(key: RecordKey<T, PK, SK>): Promise<T | undefined>;
+    delete(item: RecordKey<T, Key>): Promise<void>;
+    deleteMany(items: (RecordKey<T, Key>)[]): Promise<void>;
+    get(key: RecordKey<T, Key>): Promise<T | undefined>;
     scan(options?: {
         filter?: Filter<T>;
     }): AsyncGenerator<T>;
-    query(partition: Pick<T, PK['field']>, options?: {
-        filter?: Filter<T>;
+    query<const GivenPartition extends keyof AllIndexesByName<BaseDistributedTable<P, T, Key, Indexes>> & string>(options: {
+        by: GivenPartition;
+        where: KeyCondition<BaseDistributedTable<P, T, Key, Indexes>, GivenPartition>;
+        filter?: Filter<Omit<T, IndexFieldNames<BaseDistributedTable<P, T, Key, Indexes>, GivenPartition> & string>>;
     }): AsyncGenerator<T>;
 }

package/dist/resources/distributed-table.js

@@ -1,7 +1,7 @@
 import { env } from 'process';
 import { DynamoDBClient, } from '@aws-sdk/client-dynamodb';
 import { PutCommand, GetCommand, QueryCommand, ScanCommand, DeleteCommand, } from '@aws-sdk/lib-dynamodb';
-import { Resource, } from 'wirejs-resources';
+import { Resource, indexName } from 'wirejs-resources';
 import { addResource } from '../resource-collector.js';
 function isFieldComparison(filter) {
     return !['and', 'or', 'not'].some(key => key in filter);
@@ -78,9 +78,6 @@ function buildExpressionAttributeValues(filter) {
     }
     return values;
 }
-export function PassThruParser(record) {
-    return record;
-}
 /**
  * A table of records that favors very high *overall* scalability at the expense of
  * scalability *between* partitions. Providers will distribute your data across many
@@ -94,28 +91,30 @@ export function PassThruParser(record) {
  */
 export class DistributedTable extends Resource {
     parse;
-    partitionKey;
-    sort;
+    key;
+    indexes;
     ddbClient;
     table;
     constructor(scope, id, options) {
         super(scope, id);
         this.parse = options.parse;
-        this.partitionKey = options.key.partition;
-        this.sort = options.key.sort;
+        this.key = options.key;
+        this.indexes = options.indexes;
         this.ddbClient = new DynamoDBClient();
         this.table = env['TABLE_NAME_PREFIX'] + this.absoluteId.replace(/[^a-zA-Z0-9-_]/g, '_');
-        addResource('DistributedTable', {
+        const resourceDefinition = {
             absoluteId: this.absoluteId,
-            partitionKey: this.partitionKey,
-            sortKey: this.sort,
-        });
+            partitionKey: this.key.partition,
+            sortKey: this.key.sort,
+            indexes: this.indexes
+        };
+        addResource('DistributedTable', resourceDefinition);
     }
     get partitionKeyName() {
-        return this.partitionKey.field;
+        return this.key.partition.field;
     }
     get sortKeyName() {
-        return this.sort?.field;
+        return this.key.sort?.field;
     }
     #getDDBKey(key) {
         const ddbKey = {
@@ -167,10 +166,10 @@ export class DistributedTable extends Resource {
     }
     async *scan(options = {}) {
         console.log('Scanning DynamoDB table:', this.table, options);
+        const filterExpression = options.filter ? buildFilterExpression(options.filter) : undefined;
+        const expressionAttributeValues = options.filter ? buildExpressionAttributeValues(options.filter) : undefined;
         let lastEvaluatedKey = undefined;
         do {
-            const filterExpression = options.filter ? buildFilterExpression(options.filter) : undefined;
-            const expressionAttributeValues = options.filter ? buildExpressionAttributeValues(options.filter) : undefined;
             const result = await this.ddbClient.send(new ScanCommand({
                 TableName: this.table,
                 FilterExpression: filterExpression,
@@ -186,27 +185,40 @@ export class DistributedTable extends Resource {
             lastEvaluatedKey = result.LastEvaluatedKey;
         } while (lastEvaluatedKey);
     }
-    async *query(partition, options = {}) {
-        console.log('Querying DynamoDB table:', this.table, partition, options);
+    async *query(options) {
+        console.log('Querying DynamoDB table:', this.table, options);
+        // 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 }))
+        };
+        const keyConditionExpression = buildFilterExpression(whereClauseAsFilter);
+        // Build the filter expression if provided
+        const filterExpression = options.filter ? buildFilterExpression(options.filter) : undefined;
+        // Combine expression attribute values for both key conditions and filters
+        const expressionAttributeValues = {
+            ...buildExpressionAttributeValues(whereClauseAsFilter),
+            ...(options.filter ? buildExpressionAttributeValues(options.filter) : {}),
+        };
+        const isIndexNameTheDefault = options.by === indexName({
+            partition: this.key.partition,
+            sort: this.key.sort
+        });
         let lastEvaluatedKey = undefined;
         do {
-            const ddbKey = this.#getDDBKey(partition);
-            const filterExpression = options.filter ? buildFilterExpression(options.filter) : undefined;
-            const expressionAttributeValues = options.filter ? buildExpressionAttributeValues(options.filter) : undefined;
             const result = await this.ddbClient.send(new QueryCommand({
                 TableName: this.table,
-                KeyConditionExpression: `${this.partitionKeyName} = :partitionKey`,
-                ExpressionAttributeValues: {
-                    ':partitionKey': ddbKey[this.partitionKeyName],
-                    ...expressionAttributeValues
-                },
+                IndexName: isIndexNameTheDefault ? undefined : options.by,
+                KeyConditionExpression: keyConditionExpression,
                 FilterExpression: filterExpression,
+                ExpressionAttributeValues: expressionAttributeValues,
                 ExclusiveStartKey: lastEvaluatedKey,
             }));
             for (const item of result.Items || []) {
                 if (!item)
                     continue;
-                yield this.parse(item);
+                const record = this.parse(item);
+                yield record;
             }
             lastEvaluatedKey = result.LastEvaluatedKey;
         } while (lastEvaluatedKey);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wirejs-deploy-amplify-basic",
-	"version": "0.0.68-table-resource",
+	"version": "0.0.70-table-resource",
 	"type": "module",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -32,7 +32,7 @@
 		"recursive-copy": "^2.0.14",
 		"rimraf": "^6.0.1",
 		"wirejs-dom": "^1.0.38",
-		"wirejs-resources": "^0.1.36-table-resource"
+		"wirejs-resources": "^0.1.38-table-resource"
 	},
 	"devDependencies": {
 		"@aws-amplify/backend": "^1.14.0",