feat: evaluate service reference value

Signed-off-by: seven <zilisheng1996@gmail.com>

Author: Blankll

src/common/actionContext.ts

@@ -24,7 +24,10 @@ export const constructActionContext = (config?: {
       const projectRoot = path.resolve(process.cwd());
       return config?.location
         ? path.resolve(projectRoot, config?.location)
-        : path.resolve(projectRoot, 'serverless-insight.yml');
+        : path.resolve(projectRoot, 'serverlessinsight.yml') ||
+            path.resolve(projectRoot, 'serverlessInsight.yml') ||
+            path.resolve(projectRoot, 'ServerlessInsight.yml') ||
+            path.resolve(projectRoot, 'serverless-insight.yml');
     })(),
     parameters: Object.entries(config?.parameters ?? {}).map(([key, value]) => ({ key, value })),
   };

src/common/iacHelper.ts

@@ -1,6 +1,7 @@
 import path from 'node:path';
 import fs from 'node:fs';
 import * as ros from '@alicloud/ros-cdk-core';
+import { ServerlessIac } from '../types';
 
 export const resolveCode = (location: string): string => {
   const filePath = path.resolve(process.cwd(), location);
@@ -53,3 +54,9 @@ export const replaceReference = <T>(value: T, stage: string): T => {
 
   return value;
 };
+
+export const evalRefValue = (value: string, iac: ServerlessIac, stage: string): string => {
+  const containsStage = value.match(/\$\{stage}/);
+
+  return containsStage ? value.replace(/\$\{stage}/g, stage) : value;
+};

src/common/rosClient.ts

@@ -64,7 +64,7 @@ const updateStack = async (stackId: string, templateBody: unknown, context: Acti
   });
   try {
     const response = await client.updateStack(updateStackRequest);
-    logger.info(`更新中，资源栈ID:${response.body?.stackId}`);
+    logger.info(`更新中，资源栈ID: ${response.body?.stackId}`);
     // wait for stack update complete
     return await getStackActionResult(response.body?.stackId || '', context.region);
   } catch (err) {

src/stack/iacStack.ts

@@ -4,34 +4,41 @@ import { ActionContext, EventTypes, ServerlessIac } from '../types';
 import * as fc from '@alicloud/ros-cdk-fc3';
 import * as ram from '@alicloud/ros-cdk-ram';
 import * as agw from '@alicloud/ros-cdk-apigateway';
-import { replaceReference, resolveCode } from '../common';
+import { evalRefValue, replaceReference, resolveCode } from '../common';
 
 export class IacStack extends ros.Stack {
+  private service: string;
+
   constructor(scope: ros.Construct, iac: ServerlessIac, context: ActionContext) {
-    super(scope, iac.service, {
+    super(scope, evalRefValue(iac.service, iac, context.stage), {
       stackName: context.stackName,
-      tags: iac.tags.reduce((acc: { [key: string]: string }, tag) => {
+      tags: iac.tags?.reduce((acc: { [key: string]: string }, tag) => {
         acc[tag.key] = replaceReference(tag.value, context.stage);
         return acc;
       }, {}),
     });
+    this.service = evalRefValue(iac.service, iac, context.stage);
 
     // Define Parameters
-    Object.entries(iac.vars).map(
-      ([key, value]) =>
-        new ros.RosParameter(this, key, {
-          type: RosParameterType.STRING,
-          defaultValue: value,
-        }),
-    );
+    if (iac.vars) {
+      Object.entries(iac.vars).map(
+        ([key, value]) =>
+          new ros.RosParameter(this, key, {
+            type: RosParameterType.STRING,
+            defaultValue: value,
+          }),
+      );
+    }
 
     // Define Mappings
-    new ros.RosMapping(this, 'stages', { mapping: replaceReference(iac.stages, context.stage) });
+    if (iac.stages) {
+      new ros.RosMapping(this, 'stages', { mapping: replaceReference(iac.stages, context.stage) });
+    }
 
     new ros.RosInfo(
       this,
       ros.RosInfo.description,
-      replaceReference(`${iac.service} stack`, context.stage),
+      replaceReference(`${this.service} stack`, context.stage),
     );
 
     iac.functions.forEach((fnc) => {
@@ -57,10 +64,10 @@ export class IacStack extends ros.Stack {
     if (apiGateway?.length) {
       const gatewayAccessRole = new ram.RosRole(
         this,
-        replaceReference(`${iac.service}_role`, context.stage),
+        replaceReference(`${this.service}_role`, context.stage),
         {
-          roleName: replaceReference(`${iac.service}-gateway-access-role`, context.stage),
-          description: replaceReference(`${iac.service} role`, context.stage),
+          roleName: replaceReference(`${this.service}-gateway-access-role`, context.stage),
+          description: replaceReference(`${this.service} role`, context.stage),
           assumeRolePolicyDocument: {
             version: '1',
             statement: [
@@ -75,7 +82,7 @@ export class IacStack extends ros.Stack {
           },
           policies: [
             {
-              policyName: replaceReference(`${iac.service}-policy`, context.stage),
+              policyName: replaceReference(`${this.service}-policy`, context.stage),
               policyDocument: {
                 version: '1',
                 statement: [
@@ -95,9 +102,9 @@ export class IacStack extends ros.Stack {
 
       const apiGatewayGroup = new agw.RosGroup(
         this,
-        replaceReference(`${iac.service}_apigroup`, context.stage),
+        replaceReference(`${this.service}_apigroup`, context.stage),
         {
-          groupName: replaceReference(`${iac.service}_apigroup`, context.stage),
+          groupName: replaceReference(`${this.service}_apigroup`, context.stage),
           tags: replaceReference(iac.tags, context.stage),
         },
         true,
@@ -137,7 +144,7 @@ export class IacStack extends ros.Stack {
                 serviceProtocol: 'FunctionCompute',
                 functionComputeConfig: {
                   fcRegionId: context.region,
-                  functionName: replaceReference(trigger.backend, trigger.backend),
+                  functionName: replaceReference(trigger.backend, context.stage),
                   roleArn: gatewayAccessRole.attrArn,
                   fcVersion: '3.0',
                 },

src/types.ts

@@ -60,10 +60,10 @@ export type RawServerlessIac = {
 export type ServerlessIac = {
   version: string;
   provider: string;
-  vars: Vars;
-  stages: Stages;
   service: string;
-  tags: Array<{ key: string; value: string }>;
+  vars?: Vars;
+  stages?: Stages;
+  tags?: Array<{ key: string; value: string }>;
   functions: Array<IacFunction>;
   events?: Array<Event>;
 };

tests/fixtures/deployFixture.ts

@@ -1,4 +1,5 @@
 import { ServerlessIac } from '../../src/types';
+import { cloneDeep, set } from 'lodash';
 
 export const oneFcOneGatewayIac = {
   service: 'my-demo-service',
@@ -139,6 +140,134 @@ export const oneFcOneGatewayRos = {
     },
   },
 };
+export const referredServiceIac = set(
+  cloneDeep(oneFcOneGatewayIac),
+  'service',
+  'my-demo-service-${stage}',
+);
+
+export const referredServiceRos = {
+  Description: 'my-demo-service-dev stack',
+  Mappings: {
+    stages: {
+      dev: {
+        account_id: { Ref: 'account_id' },
+        region: { Ref: 'region' },
+      },
+    },
+  },
+  Metadata: { 'ALIYUN::ROS::Interface': { TemplateTags: ['Create by ROS CDK'] } },
+  Parameters: {
+    account_id: { Default: 1234567890, Type: 'String' },
+    region: { Default: 'cn-hangzhou', Type: 'String' },
+  },
+  ROSTemplateFormatVersion: '2015-09-01',
+  Resources: {
+    gateway_event_api_get__api_hello: {
+      Properties: {
+        ApiName: 'gateway_event_api_get__api_hello',
+        GroupId: { 'Fn::GetAtt': ['my-demo-service-dev_apigroup', 'GroupId'] },
+        RequestConfig: {
+          RequestHttpMethod: 'GET',
+          RequestMode: 'PASSTHROUGH',
+          RequestPath: '/api/hello',
+          RequestProtocol: 'HTTP',
+        },
+        ResultSample: 'ServerlessInsight resultSample',
+        ResultType: 'JSON',
+        ServiceConfig: {
+          FunctionComputeConfig: {
+            FunctionName: { 'Fn::GetAtt': ['hello_fn', 'FunctionName'] },
+            RoleArn: { 'Fn::GetAtt': ['my-demo-service-dev_role', 'Arn'] },
+            FcVersion: '3.0',
+          },
+          ServiceProtocol: 'FunctionCompute',
+        },
+        Tags: [{ Key: 'owner', Value: 'geek-fun' }],
+        Visibility: 'PRIVATE',
+      },
+      Type: 'ALIYUN::ApiGateway::Api',
+    },
+    hello_fn: {
+      Properties: {
+        Code: { ZipFile: 'resolved-code' },
+        EnvironmentVariables: { NODE_ENV: 'production' },
+        FunctionName: 'hello_fn',
+        Handler: 'index.handler',
+        MemorySize: 128,
+        Runtime: 'nodejs18',
+        Timeout: 10,
+      },
+      Type: 'ALIYUN::FC3::Function',
+    },
+    'my-demo-service-dev_apigroup': {
+      Properties: {
+        GroupName: 'my-demo-service-dev_apigroup',
+        Tags: [{ Key: 'owner', Value: 'geek-fun' }],
+      },
+      Type: 'ALIYUN::ApiGateway::Group',
+    },
+    'my-demo-service-dev_role': {
+      Properties: {
+        AssumeRolePolicyDocument: {
+          Statement: [
+            {
+              Action: 'sts:AssumeRole',
+              Effect: 'Allow',
+              Principal: { Service: ['apigateway.aliyuncs.com'] },
+            },
+          ],
+          Version: '1',
+        },
+        Description: 'my-demo-service-dev role',
+        Policies: [
+          {
+            PolicyDocument: {
+              Statement: [{ Action: ['fc:InvokeFunction'], Effect: 'Allow', Resource: ['*'] }],
+              Version: '1',
+            },
+            PolicyName: 'my-demo-service-dev-policy',
+          },
+        ],
+        RoleName: 'my-demo-service-dev-gateway-access-role',
+      },
+      Type: 'ALIYUN::RAM::Role',
+    },
+  },
+};
+
+export const minimumIac = {
+  service: 'my-demo-minimum-service',
+  version: '0.0.1',
+  provider: 'aliyun',
+
+  functions: [
+    {
+      key: 'hello_fn',
+      name: 'hello_fn',
+      runtime: 'nodejs18',
+      handler: 'index.handler',
+      code: 'artifact.zip',
+    },
+  ],
+} as ServerlessIac;
+
+export const minimumRos = {
+  Description: 'my-demo-minimum-service stack',
+  Metadata: { 'ALIYUN::ROS::Interface': { TemplateTags: ['Create by ROS CDK'] } },
+  ROSTemplateFormatVersion: '2015-09-01',
+  Resources: {
+    hello_fn: {
+      Properties: {
+        Code: { ZipFile: 'resolved-code' },
+        FunctionName: 'hello_fn',
+        Handler: 'index.handler',
+        Runtime: 'nodejs18',
+      },
+      Type: 'ALIYUN::FC3::Function',
+    },
+  },
+};
 
 export const oneFcIac = {
   service: 'my-demo-service',

tests/stack/deploy.test.ts

@@ -1,12 +1,16 @@
 import { deployStack } from '../../src/stack';
 import { ActionContext } from '../../src/types';
 import {
+  minimumIac,
+  minimumRos,
   oneFcIac,
   oneFcIacWithStage,
   oneFcOneGatewayIac,
   oneFcOneGatewayRos,
   oneFcRos,
   oneFcWithStageRos,
+  referredServiceIac,
+  referredServiceRos,
 } from '../fixtures/deployFixture';
 import { cloneDeep, set } from 'lodash';
 
@@ -34,6 +38,16 @@ describe('Unit tests for stack deployment', () => {
     expect(mockedRosStackDeploy).toHaveBeenCalledWith(stackName, oneFcOneGatewayRos, { stackName });
   });
 
+  it('should deploy generated stack when minimum fields provided', async () => {
+    const stackName = 'my-demo-minimum-stack';
+    mockedRosStackDeploy.mockResolvedValueOnce(stackName);
+
+    await deployStack(stackName, minimumIac, { stackName } as ActionContext);
+
+    expect(mockedRosStackDeploy).toHaveBeenCalledTimes(1);
+    expect(mockedRosStackDeploy).toHaveBeenCalledWith(stackName, minimumRos, { stackName });
+  });
+
   it('should deploy generated stack when only one FC specified', async () => {
     const stackName = 'my-demo-stack-fc-only';
     mockedRosStackDeploy.mockResolvedValueOnce(stackName);
@@ -75,4 +89,17 @@ describe('Unit tests for stack deployment', () => {
       options,
     );
   });
+  it('should evaluate service name as pure string when it reference ${stage}', async () => {
+    const options = { stackName: 'my-demo-stack-fc-with-stage-1', stage: 'dev' };
+    mockedRosStackDeploy.mockResolvedValueOnce(options.stackName);
+
+    await deployStack(options.stackName, referredServiceIac, options as ActionContext);
+
+    expect(mockedRosStackDeploy).toHaveBeenCalledTimes(1);
+    expect(mockedRosStackDeploy).toHaveBeenCalledWith(
+      options.stackName,
+      referredServiceRos,
+      options,
+    );
+  });
 });