@geek-fun/serverlessinsight 0.0.6 → 0.2.0

package/dist/src/parser/index.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseYaml = void 0;
+const node_fs_1 = require("node:fs");
+const functionParser_1 = require("./functionParser");
+const eventParser_1 = require("./eventParser");
+const databaseParser_1 = require("./databaseParser");
+const tagParser_1 = require("./tagParser");
+const yaml_1 = require("yaml");
+const validator_1 = require("../validator");
+const validateExistence = (path) => {
+    if (!(0, node_fs_1.existsSync)(path)) {
+        throw new Error(`File does not exist at path: ${path}`);
+    }
+};
+const transformYaml = (iacJson) => {
+    return {
+        service: iacJson.service,
+        version: iacJson.version,
+        provider: iacJson.provider,
+        vars: iacJson.vars,
+        stages: iacJson.stages,
+        functions: (0, functionParser_1.parseFunction)(iacJson.functions),
+        events: (0, eventParser_1.parseEvent)(iacJson.events),
+        databases: (0, databaseParser_1.parseDatabase)(iacJson.databases),
+        tags: (0, tagParser_1.parseTag)(iacJson.tags),
+    };
+};
+const parseYaml = (iacLocation) => {
+    validateExistence(iacLocation);
+    const yamlContent = (0, node_fs_1.readFileSync)(iacLocation, 'utf8');
+    const iacJson = (0, yaml_1.parse)(yamlContent);
+    (0, validator_1.validateYaml)(iacJson);
+    return transformYaml(iacJson);
+};
+exports.parseYaml = parseYaml;

package/dist/src/parser/tagParser.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTag = void 0;
+const parseTag = (tags) => {
+    return [
+        { key: 'iac-provider', value: 'ServerlessInsight' },
+        ...Object.entries(tags ?? {}).map(([key, value]) => ({ key, value })),
+    ];
+};
+exports.parseTag = parseTag;

package/dist/src/stack/deploy.js

@@ -15,28 +15,72 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.deployStack = void 0;
+exports.generateStackTemplate = exports.deployStack = exports.generateRfsStackTemplate = exports.generateRosStackTemplate = void 0;
 const ros = __importStar(require("@alicloud/ros-cdk-core"));
+const node_fs_1 = __importDefault(require("node:fs"));
 const common_1 = require("../common");
-const iacStack_1 = require("./iacStack");
-const generateStackTemplate = (stackName, iac, context) => {
+const rosStack_1 = require("./rosStack");
+const rfsStack_1 = require("./rfsStack");
+const lodash_1 = require("lodash");
+const generateRosStackTemplate = (stackName, iac, context) => {
     const app = new ros.App();
-    new iacStack_1.IacStack(app, iac, context);
+    new rosStack_1.RosStack(app, iac, context);
     const assembly = app.synth();
-    const stackArtifact = assembly.getStackByName(stackName);
-    return { template: stackArtifact.template };
+    const { template } = assembly.getStackByName(stackName);
+    const assetFolderPath = (0, lodash_1.get)(assembly.tryGetArtifact(`${stackName}.assets`), 'file', '');
+    const assetsFileBody = node_fs_1.default.readFileSync(assetFolderPath);
+    const assets = {
+        rootPath: assembly.directory,
+        ...JSON.parse(assetsFileBody.toString('utf-8').trim()),
+    };
+    return { template, assets };
+};
+exports.generateRosStackTemplate = generateRosStackTemplate;
+const generateRfsStackTemplate = (stackName, iac, context) => {
+    const stack = new rfsStack_1.RfsStack(iac, context);
+    const hcl = stack.toHclTerraform();
+    console.log('HCL:', hcl);
+    return { template: hcl };
 };
+exports.generateRfsStackTemplate = generateRfsStackTemplate;
 const deployStack = async (stackName, iac, context) => {
-    const { template } = generateStackTemplate(stackName, iac, context);
+    const { template, assets } = (0, exports.generateRosStackTemplate)(stackName, iac, context);
+    await (0, rosStack_1.prepareBootstrapStack)(context);
+    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! 🎉`);
 };
 exports.deployStack = deployStack;
+const generateStackTemplate = (stackName, iac, context) => {
+    if (iac.provider.name === common_1.ProviderEnum.ALIYUN) {
+        return (0, exports.generateRosStackTemplate)(stackName, iac, context);
+    }
+    else if (iac.provider.name === common_1.ProviderEnum.HUAWEI) {
+        return (0, exports.generateRfsStackTemplate)(stackName, iac, context);
+    }
+    return { template: '' };
+};
+exports.generateStackTemplate = generateStackTemplate;

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

@@ -1,3 +1 @@
 export { deployStack } from './deploy';
-export * from './parse';
-export * from './iacSchema';

package/dist/src/stack/index.js

@@ -1,21 +1,5 @@
 "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.deployStack = void 0;
 var deploy_1 = require("./deploy");
 Object.defineProperty(exports, "deployStack", { enumerable: true, get: function () { return deploy_1.deployStack; } });
-__exportStar(require("./parse"), exports);
-__exportStar(require("./iacSchema"), exports);

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

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveFunction = void 0;
+const common_1 = require("../../common");
+const fgsApplication = (context, service) => `
+resource "huaweicloud_fgs_application" "${service}_app" {
+  name = "${service}-app"
+  description = "${service} application"
+  package_type = "event"
+}
+`;
+const fgsFunction = (fn, context, service) => `
+resource "huaweicloud_fgs_function" "${fn.key}" {
+  name = "${fn.name}"
+  handler = "${fn.handler}"
+  runtime = "${fn.runtime}"
+  memory_size = ${fn.memory}
+  timeout = ${fn.timeout}
+  environment = ${JSON.stringify(fn.environment)}
+  code_type = "inline"
+  func_code = "${(0, common_1.resolveCode)(fn.code)}"
+  app = "huaweicloud_fgs_application.${service}_app.id"
+}
+`;
+const resolveFunction = (stack, functions, context, service) => {
+    if (!functions) {
+        return undefined;
+    }
+    const app = fgsApplication(context, service);
+    stack.appendHcl(app + '\n' + functions.map((fn) => fgsFunction(fn, context, service)).join('\n'));
+};
+exports.resolveFunction = resolveFunction;

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

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

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

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RfsStack = void 0;
+const function_1 = require("./function");
+const provider = (stack, context) => {
+    const hcl = `
+terraform {
+  required_providers {
+    huaweicloud = {
+      source  = "huaweicloud/huaweicloud"
+      version = ">= 1.67.1"
+    }
+  }
+}
+
+provider "huaweicloud" {
+  region     = "${context.region}"
+  access_key = "${context.accessKeyId}"
+  secret_key = "${context.accessKeySecret}"
+}
+  `;
+    stack.appendHcl(hcl);
+};
+class RfsStack {
+    constructor(iac, context) {
+        this.iac = iac;
+        this.context = context;
+        this.hcl = '';
+        provider(this, context);
+        (0, function_1.resolveFunction)(this, iac.functions, context, iac.service);
+    }
+    toHclTerraform() {
+        return this.hcl;
+    }
+    appendHcl(hcl) {
+        this.hcl += hcl;
+    }
+}
+exports.RfsStack = RfsStack;

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

@@ -0,0 +1,40 @@
+"use strict";
+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 template = {
+        Description: 'ServerlessInsight Bootstrap Stack',
+        Metadata: {
+            'ALIYUN::ROS::Interface': {
+                TemplateTags: ['Bootstrap stack created by ServerlessInsight'],
+            },
+        },
+        ROSTemplateFormatVersion: '2015-09-01',
+        Resources: {
+            ServerlessInsight_artifacts_bucket: {
+                Type: 'ALIYUN::OSS::Bucket',
+                Properties: {
+                    BucketName: {
+                        'Fn::Sub': 'si-bootstrap-artifacts-${ALIYUN::AccountId}-${ALIYUN::Region}',
+                    },
+                    AccessControl: 'private',
+                    DeletionForce: false,
+                    EnableOssHdfsService: false,
+                    RedundancyType: 'LRS',
+                    ServerSideEncryptionConfiguration: {
+                        SSEAlgorithm: 'KMS',
+                    },
+                },
+            },
+        },
+    };
+    return { stackName, template };
+};
+const prepareBootstrapStack = async (context) => {
+    const { stackName, template } = await getBootstrapTemplate(context);
+    await (0, common_1.rosStackDeploy)(stackName, template, context);
+};
+exports.prepareBootstrapStack = prepareBootstrapStack;

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

@@ -0,0 +1,314 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDatabases = void 0;
+const rds = __importStar(require("@alicloud/ros-cdk-rds"));
+const common_1 = require("../../common");
+const lodash_1 = require("lodash");
+const esServerless = __importStar(require("@alicloud/ros-cdk-elasticsearchserverless"));
+const rdsEngineMap = new Map([
+    [
+        `${"RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */}-${"MYSQL_5.7" /* DatabaseVersionEnum['MYSQL_5.7'] */}`,
+        {
+            engine: 'MySQL',
+            version: '5.7',
+            category: 'serverless_basic',
+            dbInstanceClass: 'mysql.n2.serverless.1c',
+            quota: { minCapacity: 0.5, maxCapacity: 32, ha: false },
+            storage: { type: 'general_essd', bursting: true, optimizedWrites: true, encryption: false },
+        },
+    ],
+    [
+        `${"RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */}-${"MYSQL_8.0" /* DatabaseVersionEnum['MYSQL_8.0'] */}`,
+        {
+            engine: 'MySQL',
+            version: '8.0',
+            category: 'serverless_basic',
+            dbInstanceClass: 'mysql.n2.serverless.1c',
+            quota: { minCapacity: 0.5, maxCapacity: 32, ha: false },
+            storage: { type: 'general_essd', bursting: true, optimizedWrites: true, encryption: false },
+        },
+    ],
+    [
+        `${"RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */}-${"MYSQL_HA_5.7" /* DatabaseVersionEnum['MYSQL_HA_5.7'] */}`,
+        {
+            engine: 'MySQL',
+            version: '5.7',
+            category: 'serverless_standard',
+            dbInstanceClass: 'mysql.n2.serverless.2c',
+            quota: { minCapacity: 0.5, maxCapacity: 32, ha: true },
+            storage: { type: 'general_essd', bursting: true, optimizedWrites: true, encryption: true },
+        },
+    ],
+    [
+        `${"RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */}-${"MYSQL_HA_8.0" /* DatabaseVersionEnum['MYSQL_HA_8.0'] */}`,
+        {
+            engine: 'MySQL',
+            version: '8.0',
+            category: 'serverless_standard',
+            dbInstanceClass: 'mysql.n2.serverless.2c',
+            quota: { minCapacity: 0.5, maxCapacity: 32, ha: true },
+            storage: { type: 'general_essd', bursting: true, optimizedWrites: true, encryption: true },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_14" /* DatabaseVersionEnum['PGSQL_14'] */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '14.0',
+            category: 'serverless_basic',
+            dbInstanceClass: 'pg.n2.serverless.1c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: false },
+            storage: { type: 'general_essd', bursting: true, optimizedWrites: false, encryption: false },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_15" /* DatabaseVersionEnum['PGSQL_15'] */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '15.0',
+            category: 'serverless_basic',
+            dbInstanceClass: 'pg.n2.serverless.1c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: false },
+            storage: { type: 'general_essd', bursting: true, optimizedWrites: false, encryption: false },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_16" /* DatabaseVersionEnum['PGSQL_16'] */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '16.0',
+            category: 'serverless_basic',
+            dbInstanceClass: 'pg.n2.serverless.1c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: false },
+            storage: { type: 'general_essd', bursting: true, optimizedWrites: false, encryption: false },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_HA_14" /* DatabaseVersionEnum['PGSQL_HA_14'] */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '14.0',
+            category: 'serverless_standard',
+            dbInstanceClass: 'pg.n2.serverless.2c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: true },
+            storage: { type: 'general_essd', bursting: true, optimizedWrites: false, encryption: false },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_HA_15" /* DatabaseVersionEnum['PGSQL_HA_15'] */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '15.0',
+            category: 'serverless_standard',
+            dbInstanceClass: 'pg.n2.serverless.2c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: true },
+            storage: { type: 'general_essd', bursting: true, optimizedWrites: false, encryption: false },
+        },
+    ],
+    [
+        `${"RDS_PGSQL_SERVERLESS" /* DatabaseEnum.RDS_PGSQL_SERVERLESS */}-${"PGSQL_HA_16" /* DatabaseVersionEnum['PGSQL_HA_16'] */}`,
+        {
+            engine: 'PostgreSQL',
+            version: '16.0',
+            category: 'serverless_standard',
+            dbInstanceClass: 'pg.n2.serverless.2c',
+            quota: { minCapacity: 0.5, maxCapacity: 14, ha: true },
+            storage: { type: 'general_essd', bursting: true, optimizedWrites: false, encryption: false },
+        },
+    ],
+    [
+        `${"RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */}-${"MSSQL_HA_2016" /* DatabaseVersionEnum['MSSQL_HA_2016'] */}`,
+        {
+            engine: 'SQLServer',
+            version: '2016_std_sl',
+            category: 'serverless_ha',
+            dbInstanceClass: 'mssql.mem2.serverless.s2',
+            quota: { minCapacity: 2, maxCapacity: 8, ha: true },
+            storage: { type: 'cloud_essd', bursting: false, optimizedWrites: false, encryption: false },
+        },
+    ],
+    [
+        `${"RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */}-${"MSSQL_HA_2017" /* DatabaseVersionEnum['MSSQL_HA_2017'] */}`,
+        {
+            engine: 'SQLServer',
+            version: '2017_std_sl',
+            category: 'serverless_ha',
+            dbInstanceClass: 'mssql.mem2.serverless.s2',
+            quota: { minCapacity: 2, maxCapacity: 8, ha: true },
+            storage: { type: 'cloud_essd', bursting: false, optimizedWrites: false, encryption: false },
+        },
+    ],
+    [
+        `${"RDS_MSSQL_SERVERLESS" /* DatabaseEnum.RDS_MSSQL_SERVERLESS */}-${"MSSQL_HA_2019" /* DatabaseVersionEnum['MSSQL_HA_2019'] */}`,
+        {
+            engine: 'SQLServer',
+            version: '2019_std_sl',
+            category: 'serverless_ha',
+            dbInstanceClass: 'mssql.mem2.serverless.s2',
+            quota: { minCapacity: 2, maxCapacity: 8, ha: true },
+            storage: { type: 'cloud_essd', bursting: false, optimizedWrites: false, encryption: false },
+        },
+    ],
+    [
+        `${"ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */}-${"ES_SEARCH_7.10" /* DatabaseVersionEnum['ES_SEARCH_7.10'] */}`,
+        {
+            engine: 'Elasticsearch',
+            version: '7.10',
+            category: 'STANDARD',
+            dbInstanceClass: '',
+            quota: { minCapacity: 2, maxCapacity: 8, ha: false },
+            storage: { type: 'cloud_essd', bursting: false, optimizedWrites: false, encryption: false },
+        },
+    ],
+    [
+        `${"ELASTICSEARCH_SERVERLESS" /* DatabaseEnum.ELASTICSEARCH_SERVERLESS */}-${"ES_TIME_SERIES_7.10" /* DatabaseVersionEnum['ES_TIME_SERIES_7.10'] */}`,
+        {
+            engine: 'Elasticsearch',
+            version: '7.10',
+            category: 'TRIAL',
+            dbInstanceClass: '',
+            quota: { minCapacity: 2, maxCapacity: 8, ha: false },
+            storage: { type: 'cloud_essd', bursting: false, optimizedWrites: false, encryption: false },
+        },
+    ],
+]);
+const resolveDatabases = (scope, databases, context) => {
+    if ((0, lodash_1.isEmpty)(databases)) {
+        return undefined;
+    }
+    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),
+                appVersion: version,
+                authentication: {
+                    basicAuth: [
+                        {
+                            password: (0, common_1.replaceReference)(db.security.basicAuth.password, context),
+                        },
+                    ],
+                },
+                quotaInfo: {
+                    cu: db.cu.min,
+                    storage: db.storage.min,
+                    appType: category,
+                },
+                // network: [
+                //   {
+                //     type: 'PUBLIC_KIBANA',
+                //     enabled: true,
+                //     whiteIpGroup: [{ groupName: 'default', ips: ['0.0.0.0/24'] }],
+                //   },
+                //   {
+                //     type: 'PUBLIC_ES',
+                //     enabled: true,
+                //     whiteIpGroup: [{ groupName: 'default', ips: ['0.0.0.0/24'] }],
+                //   },
+                // ],
+            }, true);
+        }
+        if ([
+            "RDS_MYSQL_SERVERLESS" /* DatabaseEnum.RDS_MYSQL_SERVERLESS */,
+            "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), {
+                engine: engine,
+                /**
+                 * Serverless 实例
+                 *    MySQL：5.7、8.0  - MYSQL_HA_5.7, MYSQL_5.7, MYSQL_HA_8.0, MYSQL_8.0
+                 *    SQL Server：2016_std_sl、2017_std_sl、2019_std_sl  - MSSQL_HA_2016, MSSQL_HA_2017, MSSQL_HA_2019
+                 *    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),
+                /** Serverless 实例
+                 *     serverless_basic：Serverless 基础系列。（仅适用 MySQL 和 PostgreSQL）
+                 *     serverless_standard：Serverless 高可用系列。（仅适用 MySQL 和 PostgreSQL）
+                 *     serverless_ha：SQL Server Serverless 高可用系列。
+                 */
+                category,
+                /**
+                 * MySQL:
+                 *    MySQL 基础系列：mysql.n2.serverless.1c
+                 *    MySQL 高可用系列：mysql.n2.serverless.2c
+                 * SQL Server：
+                 *    mssql.mem2.serverless.s2
+                 * PostgreSQL
+                 *    基础系列：pg.n2.serverless.1c
+                 *    高可用系列：pg.n2.serverless.2c
+                 */
+                dbInstanceClass: dbInstanceClass,
+                /**
+                 * 实例存储类型，取值：
+                 *  cloud_essd：ESSD PL1 云盘。
+                 *  general_essd：通用云盘（推荐）。
+                 */
+                dbInstanceStorageType: storage.type,
+                burstingEnabled: storage.bursting,
+                payType: 'Serverless',
+                /**
+                 * MaxCapacity:
+                 *    MySQL：1~32
+                 *    SQL Server：2~8
+                 *    PostgreSQL：1~14
+                 * MinCapacity:
+                 *    MySQL：0.5~32
+                 *    SQL Server：2~8（仅支持整数）
+                 *    PostgreSQL：0.5~14
+                 */
+                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
+                        ? 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),
+                masterUserType: 'Super',
+                multiAz: quota.ha,
+                securityIpList: (0, common_1.replaceReference)(db.network.ingressRules.join(','), context),
+                connectionStringType: db.network.type === 'PRIVATE' ? 'Inner' : 'Public',
+                dbInstanceNetType: db.network.type === 'PRIVATE' ? 'Intranet' : 'Internet',
+            }, true);
+        }
+    });
+};
+exports.resolveDatabases = resolveDatabases;