wirejs-deploy-amplify-basic 0.0.60 → 0.0.61-table-resource

package/amplify-backend-assets/backend.ts

@@ -4,9 +4,16 @@ import {
 import { RemovalPolicy } from "aws-cdk-lib";
 import { FunctionUrlAuthType } from 'aws-cdk-lib/aws-lambda';
 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';
 
+const APP_ID = process.env.AWS_APP_ID ?? process.env.PWD?.replace(/[^a-zA-Z0-9-_]/g, '_');
+const BRANCH_ID = process.env.AWS_BRANCH ?? process.env.USER ?? 'anonymous';
+const TABLE_NAME_PREFIX = `${APP_ID}-${BRANCH_ID}-`;
+
+// @ts-ignore
+import generated from './generated-resources';
 
 /**
  * Amplify resources
@@ -16,7 +23,6 @@ const backend = defineBackend({
   api,
 });
 
-
 /**
  * Amplify resource augmentations
  */
@@ -46,6 +52,41 @@ const bucket = new Bucket(backend.stack, 'data', {
 });
 bucket.grantReadWrite(backend.api.resources.lambda);
 
+/**
+ * DDB Tables
+ */
+function isDistributedTable(resource: any): resource is {
+  type: 'DistributedTable';
+  options: {
+    absoluteId: string;
+    partitionKey: string;
+    sortKey: string[];
+  }
+} {
+  return resource.type === 'DistributedTable';
+}
+
+// TODO: Need to get AttributeType from customer definition.
+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,
+        type: AttributeType.STRING,
+      },
+      sortKey: resource.options.sortKey ? {
+        name: resource.options.sortKey[0],
+        type: AttributeType.STRING,
+      } : undefined,
+      removalPolicy: RemovalPolicy.RETAIN,
+      tableName: `${TABLE_NAME_PREFIX}${sanitizedId}`,
+      billingMode: BillingMode.PAY_PER_REQUEST,
+    });
+    table.grantReadWriteData(backend.api.resources.lambda);
+  }
+}
+
 
 /**
  * Lambda environment vars
@@ -56,6 +97,9 @@ backend.api.addEnvironment(
 backend.api.addEnvironment(
   'COGNITO_CLIENT_ID', backend.auth.resources.userPoolClient.userPoolClientId
 );
+backend.api.addEnvironment(
+  'TABLE_NAME_PREFIX', TABLE_NAME_PREFIX
+);
 
 
 /**

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

package/build.js

@@ -95,29 +95,29 @@ async function buildApiBundle() {
 	// on the original `wirejs-resources` into the intermediate bundle. doing this
 	// allows us to completely override (alias) `wirejs-resources` in the final build
 	// without creating a circular alias.
-	console.log("creating intermediate wirejs-resources overrides");
-	await esbuild.build({
-		entryPoints: [path.join(SELF_DIR, 'wirejs-resources-overrides', 'index.js')],
-		bundle: true,
-		outfile: RESOURCE_OVERRIDES_BUILD,
-		platform: 'node',
-		format: 'esm',
-		external: ['@aws-sdk/client-s3']
-	});
+	// console.log("creating intermediate wirejs-resources overrides");
+	// await esbuild.build({
+	// 	entryPoints: [path.join(SELF_DIR, 'wirejs-resources-overrides', 'index.js')],
+	// 	bundle: true,
+	// 	outfile: RESOURCE_OVERRIDES_BUILD,
+	// 	platform: 'node',
+	// 	format: 'esm',
+	// 	external: ['@aws-sdk/client-s3']
+	// });
 
 	// exploratory build. builds using our overrides, which will emit a manifest of
 	// resources required by the API when imported.
 	console.log("creating api bundle using platform overrides");
 	await esbuild.build({
-		entryPoints: [path.join('.', 'api', 'index.js')],
-		bundle: true,
+		entryPoints: [path.join('.', 'api', 'index.ts')],
+		bundle: false,
 		outfile: outputPath,
 		platform: 'node',
 		format: 'esm',
-		alias: {
-			'wirejs-resources': RESOURCE_OVERRIDES_BUILD
-		},
-		external: ['@aws-sdk/client-s3']
+		// alias: {
+		// 	'wirejs-resources': RESOURCE_OVERRIDES_BUILD
+		// },
+		// external: ['@aws-sdk/client-s3']
 	});
 
 	// exploratory import. not strictly necessary until we're actually using the manifest
@@ -125,6 +125,10 @@ async function buildApiBundle() {
 	// confirmational that we're building things properly.
 	await import(outputPath);
 	console.log('discovered resources', globalThis.wirejsResources);
+	await fs.promises.writeFile(
+		path.join(BACKEND_DIR, 'generated-resources.ts'),
+		`export default ${JSON.stringify(globalThis.wirejsResources, null, 2)}`
+	);
 
 	return outputPath;
 }
@@ -159,7 +163,7 @@ if (action === 'prebuild') {
 	console.log("starting prebuild");
 	await createSkeleton();
 	await installDeps();
-	// await buildApiBundle();
+	await buildApiBundle();
 
 	console.log("prebuild done");
 } else if (action === 'inject-backend') {

package/dist/index.d.ts

@@ -1,15 +1,4 @@
-import { Resource } from 'wirejs-resources';
 export * from 'wirejs-resources';
+export { FileService } from './services/file.js';
 export { AuthenticationService } from './services/authentication.js';
-export declare class FileService extends Resource {
-    constructor(scope: Resource | string, id: string);
-    read(filename: string, encoding?: BufferEncoding): Promise<string>;
-    write(filename: string, data: string, { onlyIfNotExists }?: {
-        onlyIfNotExists?: boolean | undefined;
-    }): Promise<void>;
-    delete(filename: string): Promise<void>;
-    list({ prefix }?: {
-        prefix?: string | undefined;
-    }): AsyncGenerator<string, void, unknown>;
-    isAlreadyExistsError(error: any): boolean;
-}
+export { DistributedTable } from './resources/distributed-table.js';

package/dist/index.js

@@ -1,71 +1,14 @@
-import { env } from 'process';
-import { S3Client, ListObjectsCommand, PutObjectCommand, GetObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
-import { overrides, Resource, } from 'wirejs-resources';
+import { overrides } from 'wirejs-resources';
 // let's try exporting all the things and overwriting the specific things we
 // want to re-implement.
 export * from 'wirejs-resources';
-import { addResource } from './resource-collector.js';
+import { FileService } from './services/file.js';
+export { FileService } from './services/file.js';
 import { AuthenticationService } from './services/authentication.js';
 export { AuthenticationService } from './services/authentication.js';
-const Bucket = env['BUCKET'];
-const s3 = new S3Client();
-export class FileService extends Resource {
-    constructor(scope, id) {
-        super(scope, id);
-        addResource('FileService', { absoluteId: this.absoluteId });
-    }
-    async read(filename, encoding = 'utf8') {
-        const Key = `${this.absoluteId}/${filename}`;
-        const command = new GetObjectCommand({ Bucket, Key });
-        const result = await s3.send(command);
-        return result.Body.transformToString(encoding);
-    }
-    async write(filename, data, { onlyIfNotExists = false } = {}) {
-        const Key = `${this.absoluteId}/${filename}`;
-        const Body = data;
-        const commandDetails = {
-            Bucket, Key, Body
-        };
-        if (onlyIfNotExists) {
-            commandDetails['IfNoneMatch'] = '*';
-        }
-        const command = new PutObjectCommand(commandDetails);
-        await s3.send(command);
-    }
-    async delete(filename) {
-        const Key = `${this.absoluteId}/${filename}`;
-        const command = new DeleteObjectCommand({
-            Bucket,
-            Key
-        });
-        await s3.send(command);
-    }
-    async *list({ prefix = '' } = {}) {
-        const Prefix = `${this.absoluteId}/${prefix}`;
-        let Marker = undefined;
-        while (true) {
-            const command = new ListObjectsCommand({
-                Bucket,
-                Prefix,
-                MaxKeys: 1000,
-                Marker
-            });
-            const result = await s3.send(command);
-            Marker = result.Marker;
-            for (const o of result.Contents || []) {
-                if (o.Key) {
-                    yield o.Key.slice(`${this.absoluteId}/`.length);
-                }
-            }
-            if (!Marker)
-                break;
-        }
-    }
-    isAlreadyExistsError(error) {
-        // https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html
-        return error?.$metadata?.httpStatusCode === 412;
-    }
-}
+import { DistributedTable } from './resources/distributed-table.js';
+export { DistributedTable } from './resources/distributed-table.js';
 // expose resources to other resources that might depend on it.
-overrides.FileService = FileService;
 overrides.AuthenticationService = AuthenticationService;
+overrides.DistributedTable = DistributedTable;
+overrides.FileService = FileService;

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

@@ -0,0 +1,40 @@
+import { DynamoDBClient } from '@aws-sdk/client-dynamodb';
+import { Filter, Parser, RecordKey, Resource } from 'wirejs-resources';
+export declare function PassThruParser<T>(record: Record<string, any>): T;
+/**
+ * A table of records that favors very high *overall* scalability at the expense of
+ * scalability *between* partitions. Providers will distribute your data across many
+ * servers based on the partition key as the table and/or traffic increases.
+ *
+ * ### Do NOT change partition keys. (In Production.)
+ *
+ * Changing it will cause some providers to drop and recreate your table.
+ *
+ * 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 keyof T & string, const SK extends (keyof T & string)[] | undefined> extends Resource {
+    #private;
+    parse: P;
+    partitionKey: PK;
+    sort: SK | undefined;
+    ddbClient: DynamoDBClient;
+    table: string;
+    constructor(scope: Resource | string, id: string, options: {
+        parse: P;
+        key: {
+            partition: PK;
+            sort?: SK;
+        };
+    });
+    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>;
+    scan(options?: {
+        filter?: Filter<T>;
+    }): AsyncGenerator<T>;
+    query(partition: Pick<T, PK>, options?: {
+        filter?: Filter<T>;
+    }): AsyncGenerator<T>;
+}

package/dist/resources/distributed-table.js

@@ -0,0 +1,202 @@
+import { env } from 'process';
+import { DynamoDBClient, PutItemCommand, DeleteItemCommand, GetItemCommand, ScanCommand, QueryCommand, } from '@aws-sdk/client-dynamodb';
+import { Resource, } from 'wirejs-resources';
+import { addResource } from '../resource-collector.js';
+function isFieldComparison(filter) {
+    return !['and', 'or', 'not'].some(key => key in filter);
+}
+function buildFilterExpression(filter) {
+    if (filter.and) {
+        return `(${filter.and.map(buildFilterExpression).join(' AND ')})`;
+    }
+    if (filter.or) {
+        return `(${filter.or.map(buildFilterExpression).join(' OR ')})`;
+    }
+    if (filter.not) {
+        return `(NOT ${buildFilterExpression(filter.not)})`;
+    }
+    if (!isFieldComparison(filter)) {
+        throw new Error(`Unsupported filter: ${JSON.stringify(filter)}`);
+    }
+    const [field] = Object.keys(filter);
+    const condition = filter[field];
+    if ('eq' in condition)
+        return `${field} = :${field}`;
+    if ('ne' in condition)
+        return `${field} <> :${field}`;
+    if ('gt' in condition)
+        return `${field} > :${field}`;
+    if ('ge' in condition)
+        return `${field} >= :${field}`;
+    if ('lt' in condition)
+        return `${field} < :${field}`;
+    if ('le' in condition)
+        return `${field} <= :${field}`;
+    if ('between' in condition)
+        return `${field} BETWEEN :${field}Low AND :${field}High`;
+    if ('beginsWith' in condition)
+        return `begins_with(${field}, :${field})`;
+    throw new Error(`Unsupported filter condition: ${JSON.stringify(condition)}`);
+}
+function buildExpressionAttributeValues(filter) {
+    const values = {};
+    if (filter.and || filter.or || filter.not) {
+        const subFilters = filter.and ?? filter.or ?? [filter.not];
+        for (const subFilter of subFilters) {
+            if (!subFilter)
+                continue;
+            Object.assign(values, buildExpressionAttributeValues(subFilter));
+        }
+    }
+    else if (isFieldComparison(filter)) {
+        const field = Object.keys(filter)[0];
+        const condition = filter[field];
+        if ('eq' in condition)
+            values[`:${field}`] = { S: condition.eq };
+        if ('ne' in condition)
+            values[`:${field}`] = { S: condition.ne };
+        if ('gt' in condition)
+            values[`:${field}`] = { S: condition.gt };
+        if ('ge' in condition)
+            values[`:${field}`] = { S: condition.ge };
+        if ('lt' in condition)
+            values[`:${field}`] = { S: condition.lt };
+        if ('le' in condition)
+            values[`:${field}`] = { S: condition.le };
+        if ('between' in condition) {
+            values[`:${field}Low`] = { S: condition.between[0] };
+            values[`:${field}High`] = { S: condition.between[1] };
+        }
+        if ('beginsWith' in condition)
+            values[`:${field}`] = { S: condition.beginsWith };
+    }
+    else {
+        throw new Error(`Unsupported filter: ${JSON.stringify(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
+ * servers based on the partition key as the table and/or traffic increases.
+ *
+ * ### Do NOT change partition keys. (In Production.)
+ *
+ * Changing it will cause some providers to drop and recreate your table.
+ *
+ * High cardinality, non-sequential partition keys allow for the best overall scaling.
+ */
+export class DistributedTable extends Resource {
+    parse;
+    partitionKey;
+    sort;
+    ddbClient;
+    table;
+    constructor(scope, id, options) {
+        super(scope, id);
+        this.parse = options.parse;
+        this.partitionKey = options.key.partition;
+        this.sort = options.key.sort;
+        this.ddbClient = new DynamoDBClient();
+        this.table = env['TABLE_NAME_PREFIX'] + this.absoluteId.replace(/[^a-zA-Z0-9-_]/g, '_');
+        addResource('DistributedTable', {
+            absoluteId: this.absoluteId,
+            partitionKey: this.partitionKey,
+            sortKey: this.sort,
+        });
+    }
+    #getDDBKey(key) {
+        const ddbKey = {
+            [this.partitionKey]: { S: key[this.partitionKey] }
+        };
+        if (this.sort) {
+            for (const sk of this.sort) {
+                ddbKey[sk] = { S: key[sk] };
+            }
+        }
+        return ddbKey;
+    }
+    async save(item) {
+        const key = this.#getDDBKey(item);
+        const itemToSave = {
+            ...key,
+            ...item,
+        };
+        await this.ddbClient.send(new PutItemCommand({
+            TableName: this.table,
+            Item: itemToSave,
+        }));
+    }
+    async saveMany(items) {
+        const promises = items.map(item => this.save(item));
+        await Promise.all(promises);
+    }
+    async delete(item) {
+        const key = this.#getDDBKey(item);
+        await this.ddbClient.send(new DeleteItemCommand({
+            TableName: this.table,
+            Key: key,
+        }));
+    }
+    async deleteMany(items) {
+        const promises = items.map(item => this.delete(item));
+        await Promise.all(promises);
+    }
+    async get(key) {
+        const ddbKey = this.#getDDBKey(key);
+        const result = await this.ddbClient.send(new GetItemCommand({
+            TableName: this.table,
+            Key: ddbKey,
+        }));
+        if (!result.Item)
+            return undefined;
+        return this.parse(result.Item);
+    }
+    async *scan(options = {}) {
+        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,
+                ExpressionAttributeValues: expressionAttributeValues,
+                ExclusiveStartKey: lastEvaluatedKey,
+            }));
+            for (const item of result.Items || []) {
+                if (!item)
+                    continue;
+                const record = this.parse(item);
+                yield record;
+            }
+            lastEvaluatedKey = result.LastEvaluatedKey;
+        } while (lastEvaluatedKey);
+    }
+    async *query(partition, options = {}) {
+        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.partitionKey} = :partitionKey`,
+                ExpressionAttributeValues: {
+                    ':partitionKey': ddbKey[this.partitionKey],
+                    ...expressionAttributeValues
+                },
+                FilterExpression: filterExpression,
+                ExclusiveStartKey: lastEvaluatedKey,
+            }));
+            for (const item of result.Items || []) {
+                if (!item)
+                    continue;
+                yield this.parse(item);
+            }
+            lastEvaluatedKey = result.LastEvaluatedKey;
+        } while (lastEvaluatedKey);
+    }
+}

package/dist/services/file.d.ts

@@ -0,0 +1,13 @@
+import { Resource } from 'wirejs-resources';
+export declare class FileService extends Resource {
+    constructor(scope: Resource | string, id: string);
+    read(filename: string, encoding?: BufferEncoding): Promise<string>;
+    write(filename: string, data: string, { onlyIfNotExists }?: {
+        onlyIfNotExists?: boolean | undefined;
+    }): Promise<void>;
+    delete(filename: string): Promise<void>;
+    list({ prefix }?: {
+        prefix?: string | undefined;
+    }): AsyncGenerator<string, void, unknown>;
+    isAlreadyExistsError(error: any): boolean;
+}

package/dist/services/file.js

@@ -0,0 +1,63 @@
+import { env } from 'process';
+import { S3Client, ListObjectsCommand, PutObjectCommand, GetObjectCommand, DeleteObjectCommand } from '@aws-sdk/client-s3';
+import { Resource, } from 'wirejs-resources';
+import { addResource } from '../resource-collector.js';
+const Bucket = env['BUCKET'];
+const s3 = new S3Client();
+export class FileService extends Resource {
+    constructor(scope, id) {
+        super(scope, id);
+        addResource('FileService', { absoluteId: this.absoluteId });
+    }
+    async read(filename, encoding = 'utf8') {
+        const Key = `${this.absoluteId}/${filename}`;
+        const command = new GetObjectCommand({ Bucket, Key });
+        const result = await s3.send(command);
+        return result.Body.transformToString(encoding);
+    }
+    async write(filename, data, { onlyIfNotExists = false } = {}) {
+        const Key = `${this.absoluteId}/${filename}`;
+        const Body = data;
+        const commandDetails = {
+            Bucket, Key, Body
+        };
+        if (onlyIfNotExists) {
+            commandDetails['IfNoneMatch'] = '*';
+        }
+        const command = new PutObjectCommand(commandDetails);
+        await s3.send(command);
+    }
+    async delete(filename) {
+        const Key = `${this.absoluteId}/${filename}`;
+        const command = new DeleteObjectCommand({
+            Bucket,
+            Key
+        });
+        await s3.send(command);
+    }
+    async *list({ prefix = '' } = {}) {
+        const Prefix = `${this.absoluteId}/${prefix}`;
+        let Marker = undefined;
+        while (true) {
+            const command = new ListObjectsCommand({
+                Bucket,
+                Prefix,
+                MaxKeys: 1000,
+                Marker
+            });
+            const result = await s3.send(command);
+            Marker = result.Marker;
+            for (const o of result.Contents || []) {
+                if (o.Key) {
+                    yield o.Key.slice(`${this.absoluteId}/`.length);
+                }
+            }
+            if (!Marker)
+                break;
+        }
+    }
+    isAlreadyExistsError(error) {
+        // https://docs.aws.amazon.com/AmazonS3/latest/API/API_PutObject.html
+        return error?.$metadata?.httpStatusCode === 412;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "wirejs-deploy-amplify-basic",
-	"version": "0.0.60",
+	"version": "0.0.61-table-resource",
 	"type": "module",
 	"main": "./dist/index.js",
 	"types": "./dist/index.d.ts",
@@ -23,6 +23,7 @@
 	},
 	"dependencies": {
 		"@aws-sdk/client-cognito-identity-provider": "^3.741.0",
+		"@aws-sdk/client-dynamodb": "^3.774.0",
 		"@aws-sdk/client-s3": "^3.738.0",
 		"copy": "^0.3.2",
 		"esbuild": "^0.24.2",
@@ -30,7 +31,7 @@
 		"recursive-copy": "^2.0.14",
 		"rimraf": "^6.0.1",
 		"wirejs-dom": "^1.0.38",
-		"wirejs-resources": "^0.1.28"
+		"wirejs-resources": "^0.1.29-table-resource"
 	},
 	"devDependencies": {
 		"@aws-amplify/backend": "^1.14.0",