refactor: serverlessInsight repo resturcture (#15)

refactor: serverlessInsight repo restructure

- [x] type definitions restructure
- [x] schema validation restructure
- [x] transformer restructure
- [x] parse restructure

Refs:

---------

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

Author: Blankll

src/commands/deploy.ts

@@ -1,5 +1,6 @@
-import { deployStack, parseYaml } from '../stack';
+import { deployStack } from '../stack';
 import { constructActionContext, logger } from '../common';
+import { parseYaml } from '../parser';
 
 export const deploy = async (
   stackName: string,

src/commands/template.ts

@@ -2,7 +2,7 @@ import { TemplateFormat } from '../types';
 import yaml from 'yaml';
 import { generateStackTemplate } from '../stack/deploy';
 import { constructActionContext, logger } from '../common';
-import { parseYaml } from '../stack';
+import { parseYaml } from '../parser';
 
 export const template = (
   stackName: string,

src/commands/validate.ts

@@ -1,5 +1,5 @@
 import { constructActionContext, logger } from '../common';
-import { parseYaml } from '../stack';
+import { parseYaml } from '../parser';
 
 export const validate = (location: string | undefined, stage: string | undefined) => {
   const context = constructActionContext({ location, stage });

src/parser/databaseParser.ts

@@ -0,0 +1,27 @@
+import { DatabaseDomain, DatabaseEnum, DatabaseRaw } from '../types';
+import { get, isEmpty } from 'lodash';
+
+export const parseDatabase = (databases?: {
+  [key: string]: DatabaseRaw;
+}): Array<DatabaseDomain> | 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,
+    },
+  }));
+};

src/parser/eventParser.ts

@@ -0,0 +1,13 @@
+import { EventDomain, EventRaw } from '../types';
+
+export const parseEvent = (events: { [key: string]: EventRaw }): Array<EventDomain> | undefined => {
+  if (!events) {
+    return undefined;
+  }
+  return Object.entries(events).map(([key, event]) => ({
+    key,
+    name: event.name,
+    type: event.type,
+    triggers: event.triggers,
+  }));
+};

src/parser/functionParser.ts

@@ -0,0 +1,20 @@
+import { FunctionDomain, FunctionRaw } from '../types';
+import { isEmpty } from 'lodash';
+
+export const parseFunction = (functions?: {
+  [key: string]: FunctionRaw;
+}): Array<FunctionDomain> | undefined => {
+  if (isEmpty(functions)) {
+    return undefined;
+  }
+  return Object.entries(functions).map(([key, func]) => ({
+    key,
+    name: func.name,
+    runtime: func.runtime,
+    handler: func.handler,
+    memory: func.memory,
+    timeout: func.timeout,
+    environment: func.environment,
+    code: func.code,
+  }));
+};

src/parser/index.ts

@@ -0,0 +1,39 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { ServerlessIac, ServerlessIacRaw } from '../types';
+import { parseFunction } from './functionParser';
+import { parseEvent } from './eventParser';
+import { parseDatabase } from './databaseParser';
+import { parseTag } from './tagParser';
+import { parse } from 'yaml';
+import { validateYaml } from '../validator';
+
+const validateExistence = (path: string) => {
+  if (!existsSync(path)) {
+    throw new Error(`File does not exist at path: ${path}`);
+  }
+};
+
+const transformYaml = (iacJson: ServerlessIacRaw): ServerlessIac => {
+  return {
+    service: iacJson.service,
+    version: iacJson.version,
+    provider: iacJson.provider,
+    vars: iacJson.vars,
+    stages: iacJson.stages,
+    functions: parseFunction(iacJson.functions),
+    events: parseEvent(iacJson.events),
+    databases: parseDatabase(iacJson.databases),
+    tags: parseTag(iacJson.tags),
+  };
+};
+
+export const parseYaml = (yamlPath: string): ServerlessIac => {
+  validateExistence(yamlPath);
+
+  const yamlContent = readFileSync(yamlPath, 'utf8');
+  const iacJson = parse(yamlContent) as ServerlessIacRaw;
+
+  validateYaml(iacJson);
+
+  return transformYaml(iacJson);
+};

src/parser/tagParser.ts

@@ -0,0 +1,9 @@
+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 }))];
+};

src/stack/iacSchema.ts

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