feat: implement elasitcsearch serverless for aliyun resources

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

Author: Blankll

package-lock.json

@@ -57,7 +57,7 @@
     "@alicloud/ros-cdk-oss": "^1.4.0",
     "@alicloud/ros-cdk-ossdeployment": "^1.4.0",
     "@alicloud/ros-cdk-ram": "^1.4.0",
-    "@alicloud/ros20190910": "^3.5.0",
+    "@alicloud/ros20190910": "^3.5.2",
     "ajv": "^8.17.1",
     "chalk": "^5.3.0",
     "commander": "^12.1.0",

package.json

@@ -121,6 +121,8 @@ const schema = {
             type: { type: 'string', enum: ['ELASTICSEARCH_SERVERLESS'] },
             version: { type: 'string' },
             engine_mode: { type: 'string', enum: ['SEARCH', 'TIMESERIES'] },
+            cu: { type: 'number' },
+            storage_size: { type: 'number' },
             security: {
               type: 'object',
               properties: {
@@ -134,8 +136,12 @@ const schema = {
               },
               required: ['basic_auth'],
             },
-            cu: { type: 'number' },
-            storage_size: { type: 'number' },
+            network: {
+              type: 'object',
+              properties: {
+                public: { type: 'boolean' },
+              },
+            },
           },
           required: ['name', 'type', 'version', 'security', 'cu', 'storage_size'],
           additionalProperties: false,

src/stack/iacSchema.ts

@@ -232,6 +232,18 @@ export class IacStack extends ros.Stack {
               storage: db.storageSize,
               appType: db.engineMode === DatabaseEngineMode.TIMESERIES ? 'TRIAL' : 'STANDARD',
             },
+            // 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,
         );

src/stack/iacStack.ts

@@ -1,7 +1,16 @@
 import { parse } from 'yaml';
 import { existsSync, readFileSync } from 'node:fs';
-import { Event, IacDatabase, IacFunction, RawServerlessIac, ServerlessIac } from '../types';
+import {
+  DatabaseEnum,
+  Event,
+  IacDatabase,
+  IacFunction,
+  RawIacDatabase,
+  RawServerlessIac,
+  ServerlessIac,
+} from '../types';
 import { validateYaml } from './iacSchema';
+import { get, isEmpty } from 'lodash';
 
 const mapToArr = (obj: Record<string, Record<string, unknown> | string | null | undefined>) => {
   if (!obj) {
@@ -24,7 +33,30 @@ const validateExistence = (path: string) => {
     throw new Error(`File does not exist at path: ${path}`);
   }
 };
-
+const transformDatabase = (databases?: {
+  [key: string]: RawIacDatabase;
+}): Array<IacDatabase> | undefined => {
+  if (isEmpty(databases)) {
+    return undefined;
+  }
+  return Object.entries(databases)?.map(([key, database]) => ({
+    key: key,
+    name: database.name,
+    type: database.type as DatabaseEnum,
+    version: database.version,
+    engineMode: database.engine_mode,
+    security: {
+      basicAuth: {
+        password: get(database, 'security.basic_auth.password'),
+      },
+    },
+    cu: database.cu,
+    storageSize: database.storage_size,
+    network: database.network && {
+      public: database.network?.public as boolean,
+    },
+  }));
+};
 const transformYaml = (iacJson: RawServerlessIac): ServerlessIac => {
   return {
     service: iacJson.service,
@@ -38,7 +70,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>,
+    databases: transformDatabase(iacJson.databases),
   };
 };
 

src/stack/parse.ts

@@ -45,6 +45,22 @@ type Events = {
 type Tags = {
   [key: string]: string;
 };
+export type RawIacDatabase = {
+  name: string;
+  type: DatabaseEnum;
+  version: string;
+  engine_mode: DatabaseEngineMode;
+  security: {
+    basic_auth: {
+      password: string;
+    };
+  };
+  network?: {
+    public: boolean;
+  };
+  cu: number;
+  storage_size: number;
+};
 
 export type RawServerlessIac = {
   version: string;
@@ -55,7 +71,7 @@ export type RawServerlessIac = {
   tags: Tags;
   functions: { [key: string]: IacFunction };
   events: Events;
-  databases: { [key: string]: IacDatabase };
+  databases: { [key: string]: RawIacDatabase };
 };
 
 export enum DatabaseEnum {
@@ -78,6 +94,9 @@ export type IacDatabase = {
       password: string;
     };
   };
+  network?: {
+    public: boolean;
+  };
   cu: number;
   storageSize: number;
 };

src/types.ts

@@ -791,6 +791,16 @@ export const esServerlessMinimumRos = {
           Cu: 1,
           Storage: 20,
         },
+        // Network: [
+        //   {
+        //     Enabled: true,
+        //     Type: 'PUBLIC_KIBANA',
+        //   },
+        //   {
+        //     Enabled: true,
+        //     Type: 'PUBLIC_ES',
+        //   },
+        // ],
       },
       Type: 'ALIYUN::ElasticSearchServerless::App',
     },

tests/fixtures/deployFixture.ts

@@ -11,10 +11,11 @@ databases:
   insight_es_db:
     name: insight-poc-es
     type: ELASTICSEARCH_SERVERLESS
-    version: 7.10
+    version: '7.10'
     engine_mode: SEARCH
-    security:
-      basic_auth:
-        password: 123456
     cu: 1
     storage_size: 20
+    security:
+      basic_auth:
+        password: 'U34I6InQ8elseTgqTWT2t2oFXpoqFg'
+

tests/fixtures/serverless-insight-es.yml

@@ -0,0 +1,39 @@
+import { parseYaml } from '../../src/stack';
+import path from 'node:path';
+
+describe('unit test for parse', () => {
+  describe('domain - databases', () => {
+    const yamlPath = path.resolve(__dirname, '../fixtures/serverless-insight-es.yml');
+
+    it('should pass databases from yaml to domain instance when the yaml is valid', () => {
+      const databaseDomain = parseYaml(yamlPath);
+      expect(databaseDomain).toEqual({
+        service: 'insight-es-poc',
+        version: '0.0.1',
+        provider: 'aliyun',
+        tags: [
+          { key: 'iac-provider', value: 'ServerlessInsight' },
+          { key: 'owner', value: 'geek-fun' },
+        ],
+        events: [],
+        functions: [],
+        databases: [
+          {
+            key: 'insight_es_db',
+            type: 'ELASTICSEARCH_SERVERLESS',
+            name: 'insight-poc-es',
+            engineMode: 'SEARCH',
+            version: '7.10',
+            security: {
+              basicAuth: {
+                password: 'U34I6InQ8elseTgqTWT2t2oFXpoqFg',
+              },
+            },
+            cu: 1,
+            storageSize: 20,
+          },
+        ],
+      });
+    });
+  });
+});