@ikonintegration/ikapi 5.0.0-alpha1 → 5.0.0

package/README.md

@@ -1,6 +1,7 @@
 # IKApi ![Node.js Package](https://github.com/ikon-integration/IKApi/workflows/Node.js%20Package/badge.svg)
 Ikon nodejs API foundation
 
+[Docs](https://ikon-integration.github.io/ikapi/)
 
 ### Overall
 
@@ -13,124 +14,113 @@ Ikon nodejs API foundation
 
 - Router
 
-````
-import * as Config from './routes/tenant/config.js';
+```
+import { Router } from '@ikonintegration/ikapi';
+import HealthCheck from './routes/health/get';
 
 const routes = [
-  { route: '/tenant/config', method: 'GET', handler: Config.get },
+  { route: '/health', method: 'GET', handler: HealthCheck.handler },
+  // Additional routes can be added here
 ];
-//Main handler
-export const handler = async (event, context) => {
-  (await (new IKAPI.IKRouter(routes, {
-    database: {
-      type: 'DDB | SQL', -- fallback to DDB if not set
-      //DDB Specific
-      region: IBEWCoreGlobals.DatabaseRegion,
-      tableName: IBEWCoreGlobals.DatabaseTableName,
-      //SQL Specific
-      host: '127.0.0.1', database: 'DB',
-      port: 3307, user: 'root', password: 'IDK'
-    },
-    //Cache
-    cache: {
-      type: 'REDIS',
-      host: '127.0.0.1',
-      password: '22P',
-      user: '22U',
-      enableTLS: true,
-    },
-    //IKValidator
-    validation: {
-      additionalTypes: { TYPE: (val) => { return validate(val); } }
-    },
-    //Logger
-    logger: {
-      //takes precende over process.env.LOG_LEVEL
-      level: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR',
-      enableSensitiveFiltering: false, //defaults to false
-      sensitiveFilteringKeywords: [], //replaced default blacklist set
-    },
-    //Queue
-    publisher: { region: 'SNS-REGION' },
-    //Resources tracker
-    resourcesTracker: { //by default, it will auto track (lambda, ecs, ddb)
-      busName: 'busName',
-      region: 'region',
-      appName: 'appName',
-    }
-  };)).handleEvent(event, context));
-}
-```
-
-- Mailer
 
-```
-const mailer = new IKAPI.IKMailer(LMCoreGlobals.SESSender, LMCoreGlobals.SESRegion);
-```
+export const router = new Router({
+  routes,
+  healthCheckRoute: '/otherHealth',
+  logger: {
+    logLevel: 'DEBUG', // or process.env.LOG_LEVEL
+    sensitiveFilteringKeywords: ['password', 'secret'],
+  },
+});
 
-- Process
+// Handler export
+export const handler = router.getExport();
 
-```
-export const main = async () => {
-  const interval = (Docket.Globals.ExtractorPollerInterval * 1000);
-  console.debug('Using interval of', interval);
-  //init authorization
-  await (new Docket.Core({},  Docket.Globals.AccessLevel.ANY)).authenticate(async (core) => {
-    await (new IKAPI.IKProcess(Docket.Globals.API_Config, interval)).execute( async (process) => {
-      await pull(core);
-    });
-  });
-};
 ```
 
-- Event Process (Queue/SQS)
+- Route
 
 ```
-//Main handler
-export const handler = async (event, context) => {
-  //Start event processor, if any event failed, execution will stop!
-  await (new IKAPI.IKEventProcessor(event, context, Docket.Globals.API_Config)).processEvent( async (transaction, recordContent) => {
-    //init authorization
-    return await (new Docket.Core(transaction,  Docket.Globals.AccessLevel.ANY)).authenticate(async (core) => {
-      core.queue.publishOnTopic(event, Docket.Globals.SNSTopic_ExtractorNotification);
-      return IKAPI.IKSuccessResponse();
-    });
-  });
-};
+import { Response, Route, HttpMethod } from '@ikonintegration/ikapi';
+
+interface GetHealthRoute extends Route<null, { message: string }> {}
+
+export default class HealthCheck implements GetHealthRoute {
+  public path: string = '/health';
+  public method: HttpMethod = HttpMethod.GET;
+  public openApi = {
+    summary: 'System health check',
+    description: 'Returns if the system is healthy or not',
+    tags: ['Health'],
+    security: [],
+  };
+
+  public handler: GetHealthRoute['handler'] = async () => {
+    return new Response({ message: 'System is healthy' });
+  };
+}
 ```
 
+
 - Transaction
 
 ```
+import { Response, ResponseErrorType, Transaction } from '@ikonintegration/ikapi'
+import type { Context, SQSEvent } from 'aws-lambda'
+
+import Core from '../core/Core.js'
+import Globals, { AccessLevel } from '../core/Globals.js'
+
+export type SuccessResponseType = { message: string }
+
 //Main handler
-export const handler = async (event, context) => {
-  //Start event processor, if any event failed, execution will stop!
-  await (new IKAPI.IKTransaction(event, context, Docket.Globals.API_Config)).execute( async (transaction) => {
-    //init authorization
-    return await (new Docket.Core(transaction,  Docket.Globals.AccessLevel.ANY)).authenticate(async (core) => {
-      const queue = event.queue;
-      //Get from specified queue
-      if (!queue) throw new Error(`Empty queue URL! - ${queue}`);
-      //Success :)
-      return IKAPI.IKSuccessResponse();
-    });
-  });
-};
+export const handler = async (event: SQSEvent, context: Context): Promise<void> => {
+  await new Transaction<null, SuccessResponseType | ResponseErrorType>(
+    event,
+    context,
+    Globals.API_Config
+  ).execute(async transaction => {
+    const type = event['eventType']
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    return await new Core(transaction, AccessLevel.PUBLIC).authenticate(async core => {
+      // Schedule
+      if (type == 'SCHEDULE_1') {
+        /* Schedule more message to SQS?*/
+        return Response.SuccessResponse({ message: '213' })
+      }
+
+      return Response.BadRequestResponse('No handler for the specified event type!')
+    })
+  })
+}
+
 ```
 
-- Dynamo Streams
+- Event Processor (SQS)
 
 ```
+import { EventProcessor, Response } from '@ikonintegration/ikapi'
+import type { Context, SQSEvent } from 'aws-lambda'
+
+import Core from '../core/Core.js'
+import Globals, { AccessLevel } from '../core/Globals.js'
+
+export type SuccessResponseType = { message: string }
+
 //Main handler
-export const handler = async (event, context) => {
-  //Start event processor, if any event failed, execution will stop!
-  await (new IKAPI.IKDynamoStream(event, context, Docket.Globals.API_Config)).processEvent( async (transaction, recordContent) => {
-    //Check if is deletion
-    if (!_isDynamoDeletion(recordContent)) return (new IKAPI.IKSuccessNoContentResponse());
-    //init authorization
-    return await (new Docket.Core(transaction,  Docket.Globals.AccessLevel.ANY)).authenticate(async (core) => {
-      return IKAPI.IKSuccessResponse();
-    });
-  });
-};
+export const handler = async (event: SQSEvent, context: Context): Promise<void> => {
+  await new EventProcessor<SuccessResponseType | null>(
+    event,
+    context,
+    Globals.API_Config
+  ).processEvent(async (transaction, recordContent) => {
+    const type = event['eventType'] || recordContent?.['eventType']
+    return await new Core(transaction, AccessLevel.PUBLIC).authenticate(async core => {
+      // Schedule
+      if (type == Globals.EmailEventType.TEMPLATE_EMAIL)
+        return await templateEmailNotification(recordContent, core)
+
+      return Response.BadRequestResponse('No handler for the specified event type!')
+    })
+  })
+}
 ```