@geek-fun/serverlessinsight 0.3.0 → 0.3.2

package/dist/src/parser/tableParser.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTable = parseTable;
+const lodash_1 = require("lodash");
+function parseTable(tablesRaw) {
+    if ((0, lodash_1.isEmpty)(tablesRaw)) {
+        return undefined;
+    }
+    return Object.entries(tablesRaw)?.map(([key, table]) => {
+        const throughput = (0, lodash_1.omitBy)({
+            reserved: (0, lodash_1.omitBy)({
+                read: table.throughput?.reserved?.read,
+                write: table.throughput?.reserved?.write,
+            }, lodash_1.isNil),
+            onDemand: (0, lodash_1.omitBy)({
+                read: table.throughput?.on_demand?.read,
+                write: table.throughput?.on_demand?.write,
+            }, lodash_1.isNil),
+        }, lodash_1.isEmpty);
+        return {
+            key,
+            collection: table.collection,
+            name: table.name,
+            type: table.type,
+            desc: table.desc,
+            network: {
+                type: table.network?.type ?? 'PRIVATE',
+                ingressRules: table.network?.ingress_rules ?? [],
+            },
+            throughput: !(0, lodash_1.isEmpty)(throughput) ? throughput : undefined,
+            keySchema: table.key_schema?.map((keySchema) => ({
+                name: keySchema.name,
+                type: keySchema.type,
+            })) ?? [],
+            attributes: table.attributes?.map((attribute) => ({
+                name: attribute.name,
+                type: attribute.type,
+            })) ?? [],
+        };
+    });
+}

package/dist/src/stack/deploy.js

@@ -43,7 +43,8 @@ const common_1 = require("../common");
 const rosStack_1 = require("./rosStack");
 const rfsStack_1 = require("./rfsStack");
 const lodash_1 = require("lodash");
-const generateRosStackTemplate = (stackName, iac, context) => {
+const generateRosStackTemplate = (stackName, iac) => {
+    const context = (0, common_1.getContext)();
     const app = new ros.App();
     new rosStack_1.RosStack(app, iac, context);
     const assembly = app.synth();
@@ -57,29 +58,45 @@ const generateRosStackTemplate = (stackName, iac, context) => {
     return { template, assets };
 };
 exports.generateRosStackTemplate = generateRosStackTemplate;
-const generateRfsStackTemplate = (stackName, iac, context) => {
-    const stack = new rfsStack_1.RfsStack(iac, context);
+const generateRfsStackTemplate = (stackName, iac) => {
+    const stack = new rfsStack_1.RfsStack(iac);
     const hcl = stack.toHclTerraform();
     console.log('HCL:', hcl);
     return { template: hcl };
 };
 exports.generateRfsStackTemplate = generateRfsStackTemplate;
-const deployStack = async (stackName, iac, context) => {
-    const { template, assets } = (0, exports.generateRosStackTemplate)(stackName, iac, context);
-    await (0, rosStack_1.prepareBootstrapStack)(context);
+const deployStack = async (stackName, iac) => {
+    const { template, assets } = (0, exports.generateRosStackTemplate)(stackName, iac);
+    await (0, rosStack_1.prepareBootstrapStack)();
     common_1.logger.info(`Deploying stack, publishing assets...`);
-    await (0, common_1.publishAssets)(assets, context);
-    common_1.logger.info(`Assets published! 🎉`);
-    await (0, common_1.rosStackDeploy)(stackName, template, context);
-    common_1.logger.info(`Stack deployed! 🎉`);
+    const constructedAssets = await (0, common_1.constructAssets)(assets);
+    try {
+        await (0, common_1.publishAssets)(constructedAssets);
+        common_1.logger.info(`Assets published! 🎉`);
+        await (0, common_1.rosStackDeploy)(stackName, template);
+    }
+    catch (e) {
+        common_1.logger.error(`Failed to deploy stack: ${e}`);
+        throw e;
+    }
+    finally {
+        try {
+            common_1.logger.info(`Cleaning up temporary Assets...`);
+            await (0, common_1.cleanupAssets)(constructedAssets);
+            common_1.logger.info(`Assets cleaned up!♻️`);
+        }
+        catch (e) {
+            common_1.logger.error(`Failed to cleanup assets, it wont affect the deployment result, but to avoid potential cost, you can delete the temporary bucket : ${constructedAssets?.[0].bucketName}, error details:${e}`);
+        }
+    }
 };
 exports.deployStack = deployStack;
-const generateStackTemplate = (stackName, iac, context) => {
+const generateStackTemplate = (stackName, iac) => {
     if (iac.provider.name === common_1.ProviderEnum.ALIYUN) {
-        return (0, exports.generateRosStackTemplate)(stackName, iac, context);
+        return (0, exports.generateRosStackTemplate)(stackName, iac);
     }
     else if (iac.provider.name === common_1.ProviderEnum.HUAWEI) {
-        return (0, exports.generateRfsStackTemplate)(stackName, iac, context);
+        return (0, exports.generateRfsStackTemplate)(stackName, iac);
     }
     return { template: '' };
 };

package/dist/src/stack/localStack/event.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startEvents = void 0;
+const node_http_1 = __importDefault(require("node:http"));
+const common_1 = require("../../common");
+const types_1 = require("../../types");
+const lodash_1 = require("lodash");
+const startApiGatewayServer = (event) => {
+    const server = node_http_1.default.createServer((req, res) => {
+        const matchedTrigger = event.triggers.find((trigger) => trigger.method === req.method && trigger.path === req.url);
+        if (!matchedTrigger) {
+            res.writeHead(404, { 'Content-Type': 'text/plain; charset=utf-8' });
+            res.end('Not Found\n');
+            common_1.logger.warn(`API Gateway Event - ${req.method} ${req.url} -> Not Found`);
+            return;
+        }
+        res.writeHead(200, { 'Content-Type': 'text/plain; charset=utf-8' });
+        res.end(`Invoked backend: ${matchedTrigger.backend}\n`);
+        common_1.logger.info(`API Gateway Event - ${req.method} ${req.url} -> ${matchedTrigger.backend}`);
+    });
+    const port = 3000 + Math.floor(Math.random() * 1000);
+    server.listen(port, () => {
+        common_1.logger.info(`API Gateway "${event.name}" listening on http://localhost:${port}`);
+    });
+};
+const startEvents = (events) => {
+    const apiGateways = events?.filter((event) => event.type === types_1.EventTypes.API_GATEWAY);
+    if ((0, lodash_1.isEmpty)(apiGateways)) {
+        return;
+    }
+    apiGateways.forEach((gateway) => {
+        startApiGatewayServer(gateway);
+    });
+};
+exports.startEvents = startEvents;

package/dist/src/stack/localStack/index.d.ts

@@ -0,0 +1,2 @@
+export * from './event';
+export declare const startLocalStack: () => Promise<void>;

package/dist/src/stack/localStack/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startLocalStack = void 0;
+__exportStar(require("./event"), exports);
+const startLocalStack = async () => {
+    // Placeholder for starting local stack logic
+    console.log('Local stack started');
+};
+exports.startLocalStack = startLocalStack;

package/dist/src/stack/rfsStack/index.d.ts

@@ -1,9 +1,9 @@
-import { ActionContext, ServerlessIac } from '../../types';
+import { Context, ServerlessIac } from '../../types';
 export declare class RfsStack {
     private readonly iac;
     private readonly context;
     private hcl;
-    constructor(iac: ServerlessIac, context: ActionContext);
+    constructor(iac: ServerlessIac, context?: Context);
     toHclTerraform(): string;
     appendHcl(hcl: string): void;
 }

package/dist/src/stack/rfsStack/index.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RfsStack = void 0;
 const function_1 = require("./function");
+const common_1 = require("../../common");
 const provider = (stack, context) => {
     const hcl = `
 terraform {
@@ -22,7 +23,7 @@ provider "huaweicloud" {
     stack.appendHcl(hcl);
 };
 class RfsStack {
-    constructor(iac, context) {
+    constructor(iac, context = (0, common_1.getContext)()) {
         this.iac = iac;
         this.context = context;
         this.hcl = '';

package/dist/src/stack/rosStack/bootstrap.js

@@ -3,8 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.prepareBootstrapStack = void 0;
 const common_1 = require("../../common");
 const getBootstrapTemplate = async (context) => {
-    const iamInfo = await (0, common_1.getIamInfo)(context);
-    const stackName = `serverlessInsight-bootstrap-${iamInfo?.accountId}-${context.region}`;
+    const stackName = `si-bootstrap-${context.accountId}-${context.region}`;
     const template = {
         Description: 'ServerlessInsight Bootstrap Stack',
         Metadata: {
@@ -14,12 +13,10 @@ const getBootstrapTemplate = async (context) => {
         },
         ROSTemplateFormatVersion: '2015-09-01',
         Resources: {
-            ServerlessInsight_artifacts_bucket: {
+            si_auto_artifacts_bucket: {
                 Type: 'ALIYUN::OSS::Bucket',
                 Properties: {
-                    BucketName: {
-                        'Fn::Sub': 'si-bootstrap-artifacts-${ALIYUN::AccountId}-${ALIYUN::Region}',
-                    },
+                    BucketName: `${common_1.SI_BOOTSTRAP_BUCKET_PREFIX}-${context.accountId}-${context.region}`,
                     AccessControl: 'private',
                     DeletionForce: false,
                     EnableOssHdfsService: false,
@@ -29,12 +26,164 @@ const getBootstrapTemplate = async (context) => {
                     },
                 },
             },
+            si_auto_bootstrap_api_lambda: {
+                Type: 'ALIYUN::FC3::Function',
+                Properties: {
+                    FunctionName: `${common_1.SI_BOOTSTRAP_FC_PREFIX}-${context.accountId}-${context.region}`,
+                    Description: 'ServerlessInsight Bootstrap API',
+                    Handler: 'index.handler',
+                    Runtime: 'nodejs20',
+                    Layers: [
+                        `acs:fc:${context.region}:${context.accountId}:layers/si-bootstrap-sdk/versions/18`,
+                    ],
+                    Code: {
+                        SourceCode: `
+const { bootstrapHandler } = require('@geek-fun/si-bootstrap-sdk');
+
+module.exports.handler = async (rawEvent, context) => {
+  // 处理 Buffer 类型的事件
+  const event = parseEvent(rawEvent);
+
+  const commonResponse = {
+    RequestId: event.requestId,
+    LogicalResourceId: event.logicalResourceId,
+    StackId: event.stackId
+  };
+
+  try {
+    // 处理业务逻辑
+    const result = await bootstrapHandler(event);
+
+    // 构建符合 ROS 要求的响应结构
+    const rosResponse = {
+      ...commonResponse,
+      Status: result.status,
+      Reason: result.reason,
+      PhysicalResourceId: result.physicalResourceId,
+      Data: result.data || {}       // 业务数据
+    };
+
+    // 如果是删除操作，不需要返回数据
+    if (event.requestType === 'Delete') {
+      delete rosResponse.Data;
+    }
+
+    // 发送响应到 ROS 服务（如果提供了 ResponseURL）
+    if (event.responseURL) {
+      await sendResponse(event.responseURL, rosResponse);
+    }
+
+    // 返回成功响应
+    return {
+      statusCode: 200,
+      body: JSON.stringify({
+        message: 'Request processed successfully',
+        rosResponse
+      })
+    };
+  } catch (error) {
+    console.error('Error:', error);
+
+    // 构建错误响应
+    const errorResponse = {
+      ...commonResponse,
+      Status: 'FAILED',
+      Reason: error.message || 'Internal Server Error',
+      PhysicalResourceId: 'error-' + Date.now()
+    };
+
+    // 发送错误响应到 ROS 服务
+    if (event.responseURL) {
+      try {
+        await sendResponse(event.responseURL, errorResponse);
+      } catch (err) {
+        console.error('Failed to send error response:', err);
+      }
+    }
+
+    // 返回错误响应
+    return {
+      statusCode: 500,
+      body: JSON.stringify({
+        error: 'Internal Server Error',
+        details: error.message,
+        rosErrorResponse: errorResponse
+      })
+    };
+  }
+};
+
+// 使用原生 fetch API 发送响应
+async function sendResponse(responseUrl, responseBody) {
+
+  try {
+    const body = JSON.stringify(responseBody);
+
+    const response = await fetch(responseUrl, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body).toString(),
+        'Date': new Date().toUTCString()
+      },
+      body: body
+    });
+
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(\`Failed to send response. Status: \${response.status}, Body: \${errorText}\`);
+    }
+
+    console.log('Response sent successfully');
+  } catch (error) {
+    console.error('Error sending response:', error);
+    throw error;
+  }
+}
+
+
+const parseEvent = (rawEvent) => {
+// 处理 Buffer 类型的事件
+  let event;
+  if (Buffer.isBuffer(rawEvent)) {
+    event = JSON.parse(rawEvent.toString('utf8'));
+  } else if (typeof rawEvent === 'string') {
+    event = JSON.parse(rawEvent);
+  } else {
+    event = rawEvent;
+  }
+
+  const { credentials, ...resourceProperties } = event.ResourceProperties
+  return {
+    stackId: event.StackId,
+    responseURL: event.ResponseURL,
+    resourceOwnerId: event.ResourceOwnerId,
+    callerId: event.CallerId,
+    resourceProperties,
+    eventType: event.ResourceType,
+    requestType: event.RequestType?.toUpperCase(),
+    resourceType: resourceProperties.resource,
+    regionId: event.RegionId,
+    stackName: event.StackName,
+    requestId: event.RequestId,
+    intranetResponseURL: event.IntranetResponseURL,
+    logicalResourceId: event.LogicalResourceId,
+    physicalResourceId: event.PhysicalResourceId,
+    credentials
+  };
+};`,
+                    },
+                    MemorySize: 512,
+                    Timeout: 900, // 15 minutes
+                },
+            },
         },
     };
     return { stackName, template };
 };
-const prepareBootstrapStack = async (context) => {
+const prepareBootstrapStack = async () => {
+    const context = (0, common_1.getContext)();
     const { stackName, template } = await getBootstrapTemplate(context);
-    await (0, common_1.rosStackDeploy)(stackName, template, context);
+    await (0, common_1.rosStackDeploy)(stackName, template);
 };
 exports.prepareBootstrapStack = prepareBootstrapStack;

package/dist/src/stack/rosStack/bucket.js

@@ -78,41 +78,42 @@ const resolveBuckets = (scope, buckets, context) => {
         }, true);
     }
     buckets.forEach((bucket) => {
-        const ossBucket = new oss.Bucket(scope, (0, common_1.replaceReference)(bucket.key, context), {
-            bucketName: (0, common_1.replaceReference)(bucket.name, context),
-            accessControl: aclMap.get((0, common_1.replaceReference)(bucket.security?.acl, context) ?? ''),
+        const ossBucket = new oss.Bucket(scope, bucket.key, {
+            bucketName: (0, common_1.calcRefs)(bucket.name, context),
+            accessControl: aclMap.get((0, common_1.calcRefs)(bucket.security?.acl, context) ?? ''),
+            blockPublicAccess: (0, common_1.calcRefs)(bucket.security?.acl, context) === types_1.BucketAccessEnum.PRIVATE,
             websiteConfigurationV2: bucket.website
                 ? {
                     indexDocument: {
                         type: '0',
-                        suffix: (0, common_1.replaceReference)(bucket.website.index, context),
+                        suffix: (0, common_1.calcRefs)(bucket.website.index, context),
                         supportSubDir: 'true',
                     },
                     errorDocument: {
-                        httpStatus: `${(0, common_1.replaceReference)(bucket.website.error_code, context)}`,
-                        key: (0, common_1.replaceReference)(bucket.website.error_page, context),
+                        httpStatus: `${(0, common_1.calcRefs)(bucket.website.error_code, context)}`,
+                        key: (0, common_1.calcRefs)(bucket.website.error_page, context),
                     },
                 }
                 : undefined,
         });
         if (bucket.website?.code) {
-            const filePath = node_path_1.default.resolve(process.cwd(), (0, common_1.replaceReference)(bucket.website.code, context));
-            new ossDeployment.BucketDeployment(scope, `si_auto_${bucket.key}_bucket_code_deployment`, {
+            const filePath = node_path_1.default.resolve(process.cwd(), (0, common_1.calcValue)(bucket.website.code, context));
+            new ossDeployment.BucketDeployment(scope, (0, common_1.formatRosId)(`si_auto_${bucket.key}_bucket_code_deployment`), {
                 sources: (0, common_1.getAssets)(filePath),
                 destinationBucket: ossBucket.attrName,
                 roleArn: siAutoOssDeploymentBucketRole.attrArn,
-                timeout: 3000,
+                timeout: common_1.OSS_DEPLOYMENT_TIMEOUT,
                 logMonitoring: false,
                 retainOnCreate: false,
             }, true);
         }
         if (bucket.website?.domain) {
             const { rr, domainName } = (0, common_1.splitDomain)(bucket.website.domain);
-            new oss.Domain(scope, `${bucket.key}_custom_domain_${(0, common_1.encodeBase64ForRosId)(bucket.website.domain)}`, {
+            new oss.Domain(scope, (0, common_1.formatRosId)(`${bucket.key}_custom_domain`), {
                 bucketName: ossBucket.attrName,
-                domainName: (0, common_1.replaceReference)(bucket.website.domain, context),
+                domainName: (0, common_1.calcRefs)(bucket.website.domain, context),
             });
-            new dns.DomainRecord(scope, `${bucket.key}_custom_domain_record_${(0, common_1.encodeBase64ForRosId)(bucket.website.domain)}`, {
+            new dns.DomainRecord(scope, (0, common_1.formatRosId)(`${bucket.key}_custom_domain_record`), {
                 domainName: domainName,
                 rr,
                 type: 'CNAME',

package/dist/src/stack/rosStack/database.js

@@ -212,19 +212,18 @@ const resolveDatabases = (scope, databases, context) => {
     databases.forEach((db) => {
         const { engine, version, category, dbInstanceClass, quota, storage } = rdsEngineMap.get(`${db.type}-${db.version}`) ?? {};
         if (["ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */].includes(db.type)) {
-            new esServerless.App(scope, (0, common_1.replaceReference)(db.key, context), {
-                appName: (0, common_1.replaceReference)(db.name, context),
+            new esServerless.App(scope, db.key, {
+                appName: (0, common_1.calcRefs)(db.name, context),
                 appVersion: version,
                 authentication: {
                     basicAuth: [
                         {
-                            password: (0, common_1.replaceReference)(db.security.basicAuth.password, context),
+                            password: (0, common_1.calcRefs)(db.security.basicAuth.password, context),
                         },
                     ],
                 },
                 quotaInfo: {
-                    cu: db.cu.min,
-                    storage: db.storage.min,
+                    minCu: db.cu.min,
                     appType: category,
                 },
                 // network: [
@@ -246,7 +245,7 @@ const resolveDatabases = (scope, databases, context) => {
             "RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */,
             "RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */,
         ].includes(db.type)) {
-            new rds.DBInstance(scope, (0, common_1.replaceReference)(db.key, context), {
+            new rds.DBInstance(scope, db.key, {
                 engine: engine,
                 /**
                  * Serverless 实例
@@ -255,7 +254,7 @@ const resolveDatabases = (scope, databases, context) => {
                  *    PostgreSQL：14.0、15.0、16.0 - PGSQL_HA_14, PGSQL_14 PGSQL_HA_15, PGSQL_15, PGSQL_HA_16,PGSQL_16
                  */
                 engineVersion: version,
-                dbInstanceStorage: (0, common_1.replaceReference)(db.storage.min, context),
+                dbInstanceStorage: (0, common_1.calcRefs)(db.storage.min, context),
                 /** Serverless 实例
                  *     serverless_basic：Serverless 基础系列。（仅适用 MySQL 和 PostgreSQL）
                  *     serverless_standard：Serverless 高可用系列。（仅适用 MySQL 和 PostgreSQL）
@@ -293,18 +292,18 @@ const resolveDatabases = (scope, databases, context) => {
                  */
                 serverlessConfig: {
                     // @TODO db.cu.min should get parameter value when it refer to a parameter
-                    minCapacity: (0, common_1.replaceReference)(db.cu.min === 0 ? quota.minCapacity : db.cu.min + quota.minCapacity, context),
-                    maxCapacity: (0, common_1.replaceReference)(db.cu.max + quota.minCapacity <= quota.maxCapacity
+                    minCapacity: (0, common_1.calcRefs)(db.cu.min === 0 ? quota.minCapacity : db.cu.min + quota.minCapacity, context),
+                    maxCapacity: (0, common_1.calcRefs)(db.cu.max + quota.minCapacity <= quota.maxCapacity
                         ? db.cu.max + quota.minCapacity
                         : quota.maxCapacity, context),
                     autoPause: db.cu.min === 0,
                     switchForce: false,
                 },
-                masterUsername: (0, common_1.replaceReference)(db.security.basicAuth.username, context),
-                masterUserPassword: (0, common_1.replaceReference)(db.security.basicAuth.password, context),
+                masterUsername: (0, common_1.calcRefs)(db.security.basicAuth.username, context),
+                masterUserPassword: (0, common_1.calcRefs)(db.security.basicAuth.password, context),
                 masterUserType: 'Super',
                 multiAz: quota.ha,
-                securityIpList: (0, common_1.replaceReference)(db.network.ingressRules.join(','), context),
+                securityIpList: (0, common_1.calcRefs)(db.network.ingressRules.join(','), context),
                 connectionStringType: db.network.type === 'PRIVATE' ? 'Inner' : 'Public',
                 dbInstanceNetType: db.network.type === 'PRIVATE' ? 'Intranet' : 'Internet',
             }, true);

package/dist/src/stack/rosStack/event.js

@@ -48,9 +48,9 @@ const resolveEvents = (scope, events, tags, context, service) => {
     if (!apiGateway?.length)
         return;
     apiGateway.forEach((event) => {
-        const gatewayAccessRole = new ram.RosRole(scope, (0, common_1.replaceReference)(`${event.key}_role`, context), {
-            roleName: (0, common_1.replaceReference)(`${service}-${event.name}-agw-access-role`, context),
-            description: (0, common_1.replaceReference)(`${service} role`, context),
+        const gatewayAccessRole = new ram.RosRole(scope, (0, common_1.formatRosId)(`${event.key}_agw_role`), {
+            roleName: (0, common_1.calcRefs)(`${event.name}-agw-access-role`, context),
+            description: (0, common_1.calcRefs)(`${service} role`, context),
             assumeRolePolicyDocument: {
                 version: '1',
                 statement: [
@@ -65,7 +65,7 @@ const resolveEvents = (scope, events, tags, context, service) => {
             },
             policies: [
                 {
-                    policyName: (0, common_1.replaceReference)(`${service}-${event.name}-policy`, context),
+                    policyName: (0, common_1.calcRefs)(`${service}-${event.name}-policy`, context),
                     policyDocument: {
                         version: '1',
                         statement: [
@@ -80,62 +80,62 @@ const resolveEvents = (scope, events, tags, context, service) => {
                 },
             ],
         }, true);
-        const apiGatewayGroup = new agw.RosGroup(scope, (0, common_1.replaceReference)(`${service}_apigroup`, context), {
-            groupName: (0, common_1.replaceReference)(`${service}_apigroup`, context),
-            tags: (0, common_1.replaceReference)(tags, context),
+        const apiGatewayGroup = new agw.RosGroup(scope, (0, common_1.formatRosId)(`${event.key}_agw_group`), {
+            groupName: (0, common_1.calcRefs)(`${service}-agw-group`, context),
+            tags: (0, common_1.calcRefs)(tags, context),
             passthroughHeaders: 'host',
         }, true);
         if (event.domain) {
-            const dnsRecordRosId = `${event.key}_custom_domain_record_${(0, common_1.encodeBase64ForRosId)(event.domain.domain_name)}`;
+            const dnsRecordId = (0, common_1.formatRosId)(`${event.key}_agw_custom_domain_record`);
             const { domainName, rr } = (0, common_1.splitDomain)(event.domain?.domain_name);
-            new dns.DomainRecord(scope, dnsRecordRosId, {
+            new dns.DomainRecord(scope, dnsRecordId, {
                 domainName,
                 rr,
                 type: 'CNAME',
                 value: apiGatewayGroup.attrSubDomain,
             });
-            const agwCustomDomain = new agw.RosCustomDomain(scope, `${event.key}_custom_domain_${(0, common_1.encodeBase64ForRosId)(event.domain.domain_name)}`, {
+            const agwCustomDomain = new agw.RosCustomDomain(scope, (0, common_1.formatRosId)(`${event.key}_agw_custom_domain`), {
                 groupId: apiGatewayGroup.attrGroupId,
                 domainName: event.domain.domain_name,
                 certificateName: event.domain.certificate_name,
                 certificateBody: event.domain.certificate_body,
                 certificatePrivateKey: event.domain.certificate_private_key,
             }, true);
-            agwCustomDomain.addRosDependency(dnsRecordRosId);
+            agwCustomDomain.addRosDependency(dnsRecordId);
         }
         event.triggers.forEach((trigger) => {
-            const key = (0, common_1.encodeBase64ForRosId)((0, common_1.replaceReference)(`${trigger.method}_${trigger.path}`, context));
-            const api = new agw.RosApi(scope, `${event.key}_api_${key}`, {
-                apiName: (0, common_1.replaceReference)(`${event.name}_api_${key}`, context),
+            const key = (0, common_1.formatRosId)((0, common_1.calcValue)(`${trigger.method}_${trigger.path}`, context));
+            const api = new agw.RosApi(scope, (0, common_1.formatRosId)(`${event.key}_agw_api_${key}`), {
+                apiName: (0, common_1.calcRefs)(`${event.name}-agw-api-${key.replace(/_/g, '-')}`, context),
                 groupId: apiGatewayGroup.attrGroupId,
                 visibility: 'PRIVATE',
                 authType: 'ANONYMOUS',
                 requestConfig: {
                     requestProtocol: 'HTTP',
-                    requestHttpMethod: (0, common_1.replaceReference)(trigger.method, context),
-                    requestPath: (0, common_1.replaceReference)(trigger.path, context),
+                    requestHttpMethod: (0, common_1.calcRefs)(trigger.method, context),
+                    requestPath: (0, common_1.calcRefs)(trigger.path, context),
                     requestMode: 'PASSTHROUGH',
                 },
                 serviceConfig: {
                     serviceProtocol: 'FunctionCompute',
                     functionComputeConfig: {
                         fcRegionId: context.region,
-                        functionName: (0, common_1.replaceReference)(trigger.backend, context),
+                        functionName: (0, common_1.calcRefs)(trigger.backend, context),
                         roleArn: gatewayAccessRole.attrArn,
                         fcVersion: '3.0',
-                        method: (0, common_1.replaceReference)(trigger.method, context),
+                        method: (0, common_1.calcRefs)(trigger.method, context),
                     },
                 },
                 resultSample: 'ServerlessInsight resultSample',
                 resultType: 'PASSTHROUGH',
-                tags: (0, common_1.replaceReference)(tags, context),
+                tags: (0, common_1.calcRefs)(tags, context),
             }, true);
             api.addDependsOn(apiGatewayGroup);
-            new agw.Deployment(scope, `${service}_deployment`, {
+            new agw.Deployment(scope, (0, common_1.formatRosId)(`${event.key}_agw_api_deployment_${key}`), {
                 apiId: api.attrApiId,
                 groupId: apiGatewayGroup.attrGroupId,
                 stageName: 'RELEASE',
-                description: `${service} Api Gateway deployment`,
+                description: (0, common_1.calcRefs)(`${service} Api Gateway deployment for api: ${trigger.method} ${trigger.path}`, context),
             });
         });
     });