refactor: evaluate variables during parsing insead of iacStack (#16)

refactor: evaluate variables during parsing instead of iacStack

- [x] tags
- [x] events
- [x] functions
- [x] databases
- [x] service
- [x] version
- [x] provider
- [x] stages

Refs:

---------

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

Author: Blankll

src/commands/deploy.ts

@@ -8,7 +8,7 @@ export const deploy = async (
 ) => {
   const context = constructActionContext({ ...options, stackName });
   logger.info('Validating yaml...');
-  const iac = parseYaml(context.iacLocation);
+  const iac = parseYaml(context);
   logger.info('Yaml is valid! 🎉');
 
   logger.info('Deploying stack...');

src/commands/template.ts

@@ -9,7 +9,7 @@ export const template = (
   options: { format: TemplateFormat; location: string; stage: string | undefined },
 ) => {
   const context = constructActionContext({ ...options, stackName });
-  const iac = parseYaml(context.iacLocation);
+  const iac = parseYaml(context);
   const { template } = generateStackTemplate(stackName, iac, context);
 
   const output =

src/commands/validate.ts

@@ -3,7 +3,7 @@ import { parseYaml } from '../parser';
 
 export const validate = (location: string | undefined, stage: string | undefined) => {
   const context = constructActionContext({ location, stage });
-  parseYaml(context.iacLocation);
+  parseYaml(context);
   logger.info('Yaml is valid! 🎉');
   logger.debug('Yaml is valid! debug🎉');
 };

src/parser/index.ts

@@ -1,5 +1,5 @@
 import { existsSync, readFileSync } from 'node:fs';
-import { ServerlessIac, ServerlessIacRaw } from '../types';
+import { ActionContext, ServerlessIac, ServerlessIacRaw } from '../types';
 import { parseFunction } from './functionParser';
 import { parseEvent } from './eventParser';
 import { parseDatabase } from './databaseParser';
@@ -27,10 +27,10 @@ const transformYaml = (iacJson: ServerlessIacRaw): ServerlessIac => {
   };
 };
 
-export const parseYaml = (yamlPath: string): ServerlessIac => {
-  validateExistence(yamlPath);
+export const parseYaml = (context: ActionContext): ServerlessIac => {
+  validateExistence(context.iacLocation);
 
-  const yamlContent = readFileSync(yamlPath, 'utf8');
+  const yamlContent = readFileSync(context.iacLocation, 'utf8');
   const iacJson = parse(yamlContent) as ServerlessIacRaw;
 
   validateYaml(iacJson);

src/parser/tagParser.ts

@@ -1,9 +1,8 @@
 import { TagDomain, Tags } from '../types';
-import { isEmpty } from 'lodash';
 
-export const parseTag = (tags?: Tags): Array<TagDomain> => {
-  const tagList = [{ key: 'iac-provider', value: 'ServerlessInsight' }];
-  if (isEmpty(tags)) return tagList;
-
-  return [...tagList, ...Object.entries(tags).map(([key, value]) => ({ key, value }))];
+export const parseTag = (tags: Tags | undefined): Array<TagDomain> => {
+  return [
+    { key: 'iac-provider', value: 'ServerlessInsight' },
+    ...Object.entries(tags ?? {}).map(([key, value]) => ({ key, value })),
+  ];
 };

src/stack/deploy.ts

@@ -1,15 +1,15 @@
 import * as ros from '@alicloud/ros-cdk-core';
 import { ActionContext, ServerlessIac } from '../types';
 import { logger, rosStackDeploy } from '../common';
-import { IacStack } from './iacStack';
+import { RosStack } from './rosStack/rosStack';
 
 export const generateStackTemplate = (
   stackName: string,
   iac: ServerlessIac,
   context: ActionContext,
 ) => {
   const app = new ros.App();
-  new IacStack(app, iac, context);
+  new RosStack(app, iac, context);
 
   const assembly = app.synth();
   const stackArtifact = assembly.getStackByName(stackName);

src/stack/iacStack.ts

@@ -0,0 +1,52 @@
+import * as ros from '@alicloud/ros-cdk-core';
+import { replaceReference } from '../../common';
+import { ActionContext, DatabaseDomain, DatabaseEngineMode, DatabaseEnum } from '../../types';
+import { isEmpty } from 'lodash';
+import * as esServerless from '@alicloud/ros-cdk-elasticsearchserverless';
+
+export const resolveDatabases = (
+  scope: ros.Construct,
+  databases: Array<DatabaseDomain> | undefined,
+  context: ActionContext,
+) => {
+  if (isEmpty(databases)) {
+    return undefined;
+  }
+  databases!.forEach((db) => {
+    if ([DatabaseEnum.ELASTICSEARCH_SERVERLESS].includes(db.type)) {
+      new esServerless.App(
+        scope,
+        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',
+          },
+          // 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,
+      );
+    }
+  });
+};