feat: setup es serverless schema

Signed-off-by: seven <[email protected]>

Author: Blankll

package-lock.json

@@ -52,6 +52,7 @@
     "@alicloud/openapi-client": "^0.4.12",
     "@alicloud/ros-cdk-apigateway": "^1.4.0",
     "@alicloud/ros-cdk-core": "^1.4.0",
+    "@alicloud/ros-cdk-elasticsearchserverless": "^1.4.0",
     "@alicloud/ros-cdk-fc3": "^1.4.0",
     "@alicloud/ros-cdk-oss": "^1.4.0",
     "@alicloud/ros-cdk-ossdeployment": "^1.4.0",

package.json

@@ -111,6 +111,37 @@ const schema = {
         },
       },
     },
+    databases: {
+      type: 'object',
+      patternProperties: {
+        '.*': {
+          type: 'object',
+          properties: {
+            name: { type: 'string' },
+            type: { type: 'string', enum: ['ELASTICSEARCH_SERVERLESS'] },
+            version: { type: 'string' },
+            engine_mode: { type: 'string', enum: ['SEARCH', 'TIMESERIES'] },
+            security: {
+              type: 'object',
+              properties: {
+                basic_auth: {
+                  type: 'object',
+                  properties: {
+                    password: { type: 'string' },
+                  },
+                  required: ['password'],
+                },
+              },
+              required: ['basic_auth'],
+            },
+            cu: { type: 'number' },
+            storage_size: { type: 'number' },
+          },
+          required: ['name', 'type', 'version', 'security', 'cu', 'storage_size'],
+          additionalProperties: false,
+        },
+      },
+    },
   },
   required: ['version', 'provider', 'service'],
   additionalProperties: false,

src/stack/iacSchema.ts

@@ -1,19 +1,27 @@
 import * as ros from '@alicloud/ros-cdk-core';
 import { RosParameterType } from '@alicloud/ros-cdk-core';
-import { ActionContext, EventTypes, ServerlessIac } from '../types';
+import {
+  ActionContext,
+  DatabaseEngineMode,
+  DatabaseEnum,
+  EventTypes,
+  ServerlessIac,
+} from '../types';
 import * as fc from '@alicloud/ros-cdk-fc3';
 import { RosFunction } from '@alicloud/ros-cdk-fc3/lib/fc3.generated';
 import * as ram from '@alicloud/ros-cdk-ram';
 import * as agw from '@alicloud/ros-cdk-apigateway';
 import * as oss from '@alicloud/ros-cdk-oss';
 import * as ossDeployment from '@alicloud/ros-cdk-ossdeployment';
+import * as esServerless from '@alicloud/ros-cdk-elasticsearchserverless';
 import {
   CODE_ZIP_SIZE_LIMIT,
   getFileSource,
   readCodeSize,
   replaceReference,
   resolveCode,
 } from '../common';
+import { isEmpty } from 'lodash';
 
 export class IacStack extends ros.Stack {
   private readonly service: string;
@@ -47,15 +55,15 @@ export class IacStack extends ros.Stack {
     new ros.RosInfo(this, ros.RosInfo.description, `${this.service} stack`);
 
     const fileSources = iac.functions
-      .filter(({ code }) => readCodeSize(code) > CODE_ZIP_SIZE_LIMIT)
+      ?.filter(({ code }) => readCodeSize(code) > CODE_ZIP_SIZE_LIMIT)
       .map(({ code, name }) => {
         const fcName = replaceReference(name, context);
 
         return { fcName, ...getFileSource(fcName, code) };
       });
 
     let destinationBucket: oss.Bucket;
-    if (fileSources.length > 0) {
+    if (!isEmpty(fileSources)) {
       // creat oss to store code
       destinationBucket = new oss.Bucket(
         this,
@@ -70,7 +78,7 @@ export class IacStack extends ros.Stack {
         this,
         `${this.service}_artifacts_code_deployment`,
         {
-          sources: fileSources.map(({ source }) => source),
+          sources: fileSources!.map(({ source }) => source),
           destinationBucket,
           timeout: 300,
           logMonitoring: false, // 是否开启日志监控，设为false则不开启
@@ -79,14 +87,14 @@ export class IacStack extends ros.Stack {
       );
     }
 
-    iac.functions.forEach((fnc) => {
+    iac.functions?.forEach((fnc) => {
       let code: RosFunction.CodeProperty = {
         zipFile: resolveCode(fnc.code),
       };
       if (readCodeSize(fnc.code) > CODE_ZIP_SIZE_LIMIT) {
         code = {
           ossBucketName: destinationBucket.attrName,
-          ossObjectName: fileSources.find(({ fcName }) => fcName === fnc.name)?.objectKey,
+          ossObjectName: fileSources?.find(({ fcName }) => fcName === fnc.name)?.objectKey,
         };
       }
       new fc.RosFunction(
@@ -204,5 +212,30 @@ export class IacStack extends ros.Stack {
         });
       });
     }
+    iac.databases?.forEach((db) => {
+      if ([DatabaseEnum.ELASTICSEARCH_SERVERLESS].includes(db.type)) {
+        new esServerless.App(
+          this,
+          replaceReference(db.key, context),
+          {
+            appName: replaceReference(db.name, context),
+            appVersion: db.version,
+            authentication: {
+              basicAuth: [
+                {
+                  password: replaceReference(db.security.basicAuth.password, context),
+                },
+              ],
+            },
+            quotaInfo: {
+              cu: db.cu,
+              storage: db.storageSize,
+              appType: db.engineMode === DatabaseEngineMode.TIMESERIES ? 'TRIAL' : 'STANDARD',
+            },
+          },
+          true,
+        );
+      }
+    });
   }
 }

src/stack/iacStack.ts

@@ -1,6 +1,6 @@
 import { parse } from 'yaml';
 import { existsSync, readFileSync } from 'node:fs';
-import { Event, IacFunction, RawServerlessIac, ServerlessIac } from '../types';
+import { Event, IacDatabase, IacFunction, RawServerlessIac, ServerlessIac } from '../types';
 import { validateYaml } from './iacSchema';
 
 const mapToArr = (obj: Record<string, Record<string, unknown> | string | null | undefined>) => {
@@ -38,6 +38,7 @@ const transformYaml = (iacJson: RawServerlessIac): ServerlessIac => {
       { key: 'iac-provider', value: 'ServerlessInsight' },
       ...mapToKvArr(iacJson.tags),
     ] as unknown as Array<{ key: string; value: string }>,
+    databases: mapToArr(iacJson.databases) as unknown as Array<IacDatabase>,
   };
 };
 

src/stack/parse.ts

@@ -55,6 +55,31 @@ export type RawServerlessIac = {
   tags: Tags;
   functions: { [key: string]: IacFunction };
   events: Events;
+  databases: { [key: string]: IacDatabase };
+};
+
+export enum DatabaseEnum {
+  ELASTICSEARCH_SERVERLESS = 'ELASTICSEARCH_SERVERLESS',
+}
+
+export enum DatabaseEngineMode {
+  SEARCH = 'SEARCH',
+  TIMESERIES = 'TIMESERIES',
+}
+
+export type IacDatabase = {
+  key: string;
+  name: string;
+  type: DatabaseEnum;
+  version: string;
+  engineMode: string;
+  security: {
+    basicAuth: {
+      password: string;
+    };
+  };
+  cu: number;
+  storageSize: number;
 };
 
 export type ServerlessIac = {
@@ -64,8 +89,9 @@ export type ServerlessIac = {
   vars?: Vars;
   stages?: Stages;
   tags?: Array<{ key: string; value: string }>;
-  functions: Array<IacFunction>;
+  functions?: Array<IacFunction>;
   events?: Array<Event>;
+  databases?: Array<IacDatabase>;
 };
 
 export type ActionContext = {

src/types.ts

@@ -1,4 +1,4 @@
-import { ServerlessIac } from '../../src/types';
+import { DatabaseEnum, ServerlessIac } from '../../src/types';
 import { cloneDeep, set } from 'lodash';
 
 export const oneFcOneGatewayIac = {
@@ -747,3 +747,52 @@ export const defaultContext = {
   stackName: 'my-demo-stack',
   stage: 'default',
 };
+
+export const esServerlessMinimumIac: ServerlessIac = {
+  service: 'my-demo-es-serverless-service',
+  version: '0.0.1',
+  provider: 'aliyun',
+  databases: [
+    {
+      key: 'insight_es_db_test',
+      name: 'insight-poc-es-test',
+      type: DatabaseEnum.ELASTICSEARCH_SERVERLESS,
+      version: '7.10',
+      engineMode: 'SEARCH',
+      security: {
+        basicAuth: {
+          password: 'test-password',
+        },
+      },
+      cu: 1,
+      storageSize: 20,
+    },
+  ],
+};
+
+export const esServerlessMinimumRos = {
+  Description: 'my-demo-es-serverless-service stack',
+  Metadata: { 'ALIYUN::ROS::Interface': { TemplateTags: ['Create by ROS CDK'] } },
+  ROSTemplateFormatVersion: '2015-09-01',
+  Resources: {
+    insight_es_db_test: {
+      Properties: {
+        AppName: 'insight-poc-es-test',
+        AppVersion: '7.10',
+        Authentication: {
+          BasicAuth: [
+            {
+              Password: 'test-password',
+            },
+          ],
+        },
+        QuotaInfo: {
+          AppType: 'STANDARD',
+          Cu: 1,
+          Storage: 20,
+        },
+      },
+      Type: 'ALIYUN::ElasticSearchServerless::App',
+    },
+  },
+};

tests/fixtures/deployFixture.ts

@@ -0,0 +1,20 @@
+version: 0.0.1
+provider: aliyun
+
+
+service: insight-es-poc
+
+tags:
+  owner: geek-fun
+
+databases:
+  insight_es_db:
+    name: insight-poc-es
+    type: ELASTICSEARCH_SERVERLESS
+    version: 7.10
+    engine_mode: SEARCH
+    security:
+      basic_auth:
+        password: 123456
+    cu: 1
+    storage_size: 20

tests/fixtures/serverless-insight-es.yml

@@ -35,16 +35,17 @@ functions:
       TEST_VAR_EXTRA: abcds-${vars.testv}-andyou
 
 #databases:
-#  insight_poc_db:
-#    name: insight-poc-db
-#    type: RDS
-#    region: ${vars.region}
-#    instance_class: rds.mysql.t5.xlarge
+#  insight_es_db:
+#    name: insight-poc-es
+#    type: ELASTICSEARCH_SERVERLESS
+#    version: 7.10
+#    engine_mode: SEARCH
+#    security:
+#      basic_auth:
+#        password: 123456
+#    cu: 1
 #    storage_size: 20
-#    username: root
-#    password: 123456
-#    database: insight_poc_db
-#
+
 events:
   gateway_event:
     type: API_GATEWAY

tests/fixtures/serverless-insight.yml

@@ -1,6 +1,8 @@
 import { deployStack } from '../../src/stack';
 import { ActionContext } from '../../src/types';
 import {
+  esServerlessMinimumIac,
+  esServerlessMinimumRos,
   largeCodeRos,
   minimumIac,
   minimumRos,
@@ -124,4 +126,18 @@ describe('Unit tests for stack deployment', () => {
     expect(mockedResolveCode).toHaveBeenCalledTimes(1);
     expect(mockedRosStackDeploy).toHaveBeenCalledWith(stackName, largeCodeRos, { stackName });
   });
+
+  describe('unit test for deploy of databases', () => {
+    it('should deploy elasticsearch serverless when database minimum fields provided', () => {
+      const stackName = 'my-demo-es-serverless-stack';
+      mockedRosStackDeploy.mockResolvedValueOnce(stackName);
+
+      deployStack(stackName, esServerlessMinimumIac, { stackName } as ActionContext);
+
+      expect(mockedRosStackDeploy).toHaveBeenCalledTimes(1);
+      expect(mockedRosStackDeploy).toHaveBeenCalledWith(stackName, esServerlessMinimumRos, {
+        stackName,
+      });
+    });
+  });
 });