pathConfig type, RestApiConstructProps restructure, add iteration for each path, and modify test object

Author: bennettsf

packages/rest-api-construct/src/construct.test.ts

@@ -1,26 +1,39 @@
 import { describe, it } from 'node:test';
-import { AmplifyConstruct } from './construct.js';
+import { RestApiConstruct } from './construct.js';
 import { App, Stack } from 'aws-cdk-lib';
 import { Template } from 'aws-cdk-lib/assertions';
+import * as lambda from 'aws-cdk-lib/aws-lambda';
 
-void describe('AmplifyConstruct', () => {
+void describe('RestApiConstruct', () => {
   void it('creates a queue if specified', () => {
     const app = new App();
     const stack = new Stack(app);
-    new AmplifyConstruct(stack, 'test', {
-      includeQueue: true,
+    new RestApiConstruct(stack, 'RestApiTest', {
+      apiName: 'RestApiTest',
+      apiProps: [
+        {
+          path: '/test',
+          routes: ['GET', 'POST'],
+          lambdaEntry: {
+            runtime: lambda.Runtime.NODEJS_18_X,
+            source: {
+              path: './test-lambda',
+            },
+          },
+        },
+        {
+          path: '/blog',
+          routes: ['GET', 'POST', 'PUT'],
+          lambdaEntry: {
+            runtime: lambda.Runtime.NODEJS_18_X,
+            source: {
+              path: './blog-lambda',
+            },
+          },
+        },
+      ],
     });
     const template = Template.fromStack(stack);
-    template.resourceCountIs('AWS::SQS::Queue', 1);
-  });
-
-  void it('does nothing if queue is false', () => {
-    const app = new App();
-    const stack = new Stack(app);
-    new AmplifyConstruct(stack, 'test', {
-      includeQueue: false,
-    });
-    const template = Template.fromStack(stack);
-    template.resourceCountIs('AWS::SQS::Queue', 0);
+    template.resourceCountIs('AWS::AGW::RestApi', 1);
   });
 });

packages/rest-api-construct/src/construct.ts

@@ -1,76 +1,83 @@
 import { Construct } from 'constructs';
 import * as lambda from 'aws-cdk-lib/aws-lambda';
-import * as apigateway from 'aws-cdk-lib/aws-apigateway';
+import * as apiGateway from 'aws-cdk-lib/aws-apigateway';
 import {
   ExistingDirectory,
   ExistingLambda,
   NewFromCode,
-  NewFromTemplate,
+  // NewFromTemplate,
   RestApiConstructProps,
 } from './types.js';
 
 /**
  * Rest API construct for Amplify Backend
  */
 export class RestApiConstruct extends Construct {
-  public readonly api: apigateway.RestApi;
+  public readonly api: apiGateway.RestApi;
   /**
    * Create a new RestApiConstruct
    */
   constructor(scope: Construct, id: string, props: RestApiConstructProps) {
     super(scope, id);
 
-    let code: lambda.AssetCode | lambda.InlineCode = lambda.Code.fromInline('');
-    const src = props.lambdaEntry.source;
-    if ('path' in src) {
-      const lamb = src as ExistingDirectory;
-      code = lambda.Code.fromAsset(lamb.path);
-    } else if ('code' in src) {
-      const lamb = src as NewFromCode;
-      code = lambda.Code.fromInline(lamb.code);
-    } else if ('template' in src) {
-      //TODO: Implement use of templates (which ones to support, and how - cli version is complex). The available templates depend on the runtime
-      const lamb = src as NewFromTemplate;
-      if (lamb.template === 'Hello World') {
-        code = lambda.Code.fromInline(
-          "function handler() {console.log('Hello World!');}",
-        );
-      }
-    }
-
-    let handler: lambda.IFunction;
-    if ('id' in src) {
-      const lamb = src as ExistingLambda;
-      handler = lambda.Function.fromFunctionName(this, lamb.id, lamb.name);
-    } else {
-      handler = new lambda.Function(this, 'handler', {
-        runtime: props.lambdaEntry.runtime,
-        handler: 'index.handler',
-        code: code,
-      });
-    }
-
     // Create a new API Gateway REST API with the specified name
-    this.api = new apigateway.RestApi(this, 'RestApi', {
+    this.api = new apiGateway.RestApi(this, 'RestApi', {
       restApiName: props.apiName,
     });
 
-    // Create a resource for the specified path
-    const resource = this.addNestedResource(this.api.root, props.path);
+    // Iterate over each path configuration
+    for (const [index, pathConfig] of Object.entries(props.apiProps)) {
+      const { path, routes, lambdaEntry } = pathConfig;
+      const source = lambdaEntry.source;
 
-    // Add methods to the resource for each HTTP method specified in props.routes
-    for (const method of props.routes) {
-      resource.addMethod(method, new apigateway.LambdaIntegration(handler));
+      // Determine Lambda code source
+      let code: lambda.AssetCode | lambda.InlineCode =
+        lambda.Code.fromInline('');
+      if ('path' in source) {
+        const src = source as ExistingDirectory;
+        code = lambda.Code.fromAsset(src.path);
+      } else if ('code' in source) {
+        const src = source as NewFromCode;
+        code = lambda.Code.fromInline(src.code);
+      } else if ('template' in source) {
+        // const src = source as NewFromTemplate;
+        // NOTE: You may expand supported templates later
+        code = lambda.Code.fromInline(
+          "exports.handler = () => { console.log('Hello World'); };",
+        );
+      } else {
+        // fallback to dummy if none matched — should never happen if typing is correct
+        code = lambda.Code.fromInline('exports.handler = () => {};');
+      }
+
+      // Create or reference Lambda function
+      let handler: lambda.IFunction;
+      if ('id' in source) {
+        const src = source as ExistingLambda;
+        handler = lambda.Function.fromFunctionName(this, src.id, src.name);
+      } else {
+        handler = new lambda.Function(this, `LambdaHandler-${index}`, {
+          runtime: lambdaEntry.runtime,
+          handler: 'index.handler',
+          code,
+        });
+      }
+
+      // Add resource and methods for this route
+      const resource = this.addNestedResource(this.api.root, path);
+      for (const method of routes) {
+        resource.addMethod(method, new apiGateway.LambdaIntegration(handler));
+      }
     }
   }
 
   /**
    * Adds nested resources to the API based on the provided path.
    */
   private addNestedResource(
-    root: apigateway.IResource,
+    root: apiGateway.IResource,
     path: string,
-  ): apigateway.IResource {
+  ): apiGateway.IResource {
     return path.split('/').reduce((resource, part) => {
       return resource.getResource(part) ?? resource.addResource(part);
     }, root);

packages/rest-api-construct/src/types.ts

@@ -14,6 +14,10 @@ type LambdaSource = {
 
 export type RestApiConstructProps = {
   apiName: string;
+  apiProps: RestApiPathConfig[];
+};
+
+export type RestApiPathConfig = {
   path: string;
   routes: HttpMethod[];
   lambdaEntry: LambdaSource;