totoms 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nicolas Matteazzi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,413 @@
+# Toto Microservice SDK - NodeJS
+
+The Toto Microservice SDK is a framework for building cloud-agnostic microservices. <br>
+This is the NodeJS SDK documentation. 
+
+## Table of Contents
+
+1. [Installation](#1-installation)
+2. [Overview](#2-overview)
+3. [Usage](#3-usage)
+   - [3.1. The Toto Microservice Configuration](#31-the-toto-microservice-configuration)
+   - [3.2. Create and Register APIs](#32-create-and-register-apis)
+   - [3.3. Use a Message Bus](#33-use-a-message-bus)
+   - [3.4. Load Secrets](#34-load-secrets)
+   - [3.5. Custom Configurations](#35-custom-configurations)
+
+Other: 
+* [Build and Deploy on NPM](./docs/buildpublish.md)
+
+## 1. Installation
+
+```bash
+npm install totoms
+```
+
+### Cloud-Specific Dependencies
+
+Install the peer dependencies for your target cloud platform:
+
+**AWS:**
+```bash
+npm install @aws-sdk/client-secrets-manager @aws-sdk/client-sns @aws-sdk/client-sqs
+```
+
+**GCP:**
+```bash
+npm install @google-cloud/pubsub @google-cloud/secret-manager
+```
+
+## 2. Overview
+
+Everything starts with `TotoMicroservice` and the `TotoMicroserviceConfiguration`.<br>
+`TotoMicroservice` is the main orchestrator that coordinates your entire microservice. It initializes and manages:
+
+- **API Controller & API Endpoints**: Express-based REST API setup with automatic endpoint registration
+- **Message Bus & Message Handlers**: Event-driven communication via Pub/Sub and Queues. Registration and routing of event handlers to appropriate topics.
+- **Secrets Management**: Automatic loading of secrets from your cloud provider
+- **Service Lifecycle**: Initialization, startup, and shutdown management
+
+The configuration is **declarative**. The goal is to make it very simple to configure a full microservice, with a syntax that will look like this:
+
+```typescript
+import { TotoMicroservice, TotoMicroserviceConfiguration } from 'totoms';
+
+const config: TotoMicroserviceConfiguration = {
+    serviceName: "my-service",
+    basePath: '/myservice',
+    environment: {
+        hyperscaler: "aws", // or "gcp", "azure"
+        aws: {
+            region: "us-east-1"
+        }
+    },
+    config: new MyControllerConfig()
+};
+
+await TotoMicroservice.init(config);
+```
+
+The `TotoMicroserviceConfiguration` object specifies:
+
+- **Service Metadata**: Service name and base path for API endpoints
+- **Environment**: Cloud provider (AWS, GCP, Azure) information
+- **API Configuration**: REST endpoints with their handlers
+- **Message Bus Configuration**: Topics to subscribe to and message handlers
+- **Custom Configuration**: Your application-specific settings
+
+## 3. Usage
+
+### 3.1. The Toto Microservice Configuration
+
+The microservice is configured through the `TotoMicroserviceConfiguration` object and the `TotoControllerConfig` base class.
+
+```typescript
+import { TotoControllerConfig } from 'totoms';
+
+export class MyControllerConfig extends TotoControllerConfig {
+    
+    mongoUser: string | undefined;
+    mongoPwd: string | undefined;
+    
+    getMongoSecretNames() {
+        return { 
+            userSecretName: 'my-mongo-user', 
+            pwdSecretName: 'my-mongo-pswd' 
+        };
+    }
+    
+    getDBName() { 
+        return 'mydb' 
+    }
+    
+    getCollections() { 
+        return { users: 'users' } 
+    }
+}
+```
+
+### 3.2. Create and Register APIs
+
+Your microservice exposes REST API endpoints using Express. <br>
+Endpoints are defined when creating the API controller and are automatically set up.
+
+#### Create a Toto Delegate
+
+Every endpoint needs to be managed by a **Toto Delegate**. <br>
+Toto Delegates implement the `TotoDelegate` interface.
+
+This is how you define a Toto Delegate. <br>
+*The following example shows a delegate that processes user creation*.
+
+```typescript
+import { TotoDelegate, UserContext } from 'totoms';
+import { Request } from 'express';
+
+class CreateUserDelegate implements TotoDelegate {
+    async do(req: Request, userContext: UserContext, config: any) {
+        // Extract data from the request
+        const { name, email } = req.body;
+        
+        // Your business logic here
+        const userId = await createUser(name, email);
+        
+        // Return the response
+        return { 
+            userId, 
+            status: "success" 
+        };
+    }
+}
+```
+
+#### Register Your Delegate
+
+You can now register your endpoints with the API controller:
+
+```typescript
+import { TotoAPIController } from 'totoms';
+
+const api = new TotoAPIController(config, { basePath: '/myservice' });
+
+// Register the endpoint
+api.path('POST', '/users', new CreateUserDelegate());
+
+// Start listening
+api.listen();
+```
+
+The microservice will start an Express application with all registered endpoints available at the specified base path.
+
+---
+
+### 3.3. Use a Message Bus
+
+The Message Bus enables event-driven communication between microservices.<br>
+It supports both PUSH (webhook-based from cloud Pub/Sub) and PULL (polling) delivery models, depending on your cloud provider and configuration.
+
+#### 3.3.1. React to Messages
+
+Message handlers are the primary way to react to events.
+
+##### Create a Message Handler
+
+Create a handler by **extending** `TotoMessageHandler` and implementing the required methods:
+
+```typescript
+import { TotoMessageHandler, TotoMessage, ProcessingResponse } from 'totoms';
+
+class TopicRefreshedEventHandler extends TotoMessageHandler {
+    
+    getHandledMessageType(): string {
+        // Return the message type this handler processes
+        return "topicRefreshed";
+    }
+    
+    async processMessage(message: TotoMessage): Promise<ProcessingResponse> {
+        // Access message metadata
+        const correlationId = message.correlationId;
+        const messageId = message.id;
+        
+        // Extract event data
+        const topicName = message.payload.name;
+        const blogUrl = message.payload.blogURL;
+        const user = message.payload.user;
+        
+        // Your handler has access to context
+        this.logger.compute(correlationId, `Processing topic refresh for: ${topicName}`);
+        
+        // Perform your business logic
+        await this.refreshTopic(topicName, blogUrl, user);
+        
+        // Return success or failure
+        return { success: true };
+    }
+    
+    private async refreshTopic(name: string, url: string, user: string) {
+        // Implementation here
+    }
+}
+```
+
+##### Register a Message Handler
+
+Register your message handlers with the message bus configuration.
+
+**IMPORTANT NOTE:** <br>
+* When using PubSub infrastructure, you need to register topics. <br>
+Topics are registered by giving them:
+    * A `logical name` which is the name that will be used in the application to reference the topic.
+    * A topic identifier (e.g., ARN on AWS or fully-qualified Topic Name on GCP)
+
+```typescript
+import { TotoMessageBus, MessageHandlerRegistrationOptions } from 'totoms';
+
+const messageBus = new TotoMessageBus(config, environment);
+
+// Register topics
+messageBus.registerTopic({
+    logicalName: "topic-events",
+    topicName: process.env.TOPIC_EVENTS_TOPIC_NAME! // From environment or secrets
+});
+
+// Register message handlers
+const handlerOptions: MessageHandlerRegistrationOptions = {
+    topic: { logicalName: "topic-events" }
+};
+
+messageBus.registerMessageHandler(
+    new TopicRefreshedEventHandler(),
+    handlerOptions
+);
+```
+
+When the microservice starts, it automatically subscribes to the configured topics and routes incoming messages to the appropriate handlers based on their message type.
+
+#### 3.3.2. Publish Messages
+
+You can always publish messages to topics.
+
+**NOTE:**
+* In the Message Destination, the topic is the **logical name of the topic** (see above).
+
+```typescript
+import { TotoMessage, MessageDestination } from 'totoms';
+
+async function publishTopicUpdate(messageBus: any, topicId: string, topicName: string) {
+    // Create the message
+    const message = new TotoMessage({
+        type: "topicUpdated",
+        correlationId: "correlation-id-123",
+        id: topicId,
+        payload: { 
+            name: topicName, 
+            timestamp: new Date().toISOString() 
+        }
+    });
+    
+    const destination: MessageDestination = { 
+        topicName: "topic-events" 
+    };
+
+    await messageBus.publishMessage(destination, message);
+}
+```
+
+##### Getting Access to the Message Bus
+
+There are different ways to get access to the Message Bus instance:
+
+* Through the `TotoMicroservice` singleton: <br>
+`TotoMicroservice.getInstance().messageBus`
+
+* Through an existing instance of `TotoMicroservice`
+
+* In a `TotoMessageHandler` you will have `messageBus` as an instance variable: <br>
+`this.messageBus`
+
+* In a `TotoDelegate`, you can access it through the config or by maintaining a reference in your application
+
+---
+
+### 3.4. Load Secrets
+
+The SDK handles secret loading from your cloud provider automatically. Access secrets through the configuration or use the `SecretsManager` directly:
+
+```typescript
+import { SecretsManager } from 'totoms';
+
+const secrets = new SecretsManager({ hyperscaler: "aws" });
+
+// Load a secret by name
+const apiKey = await secrets.getSecret("api-key");
+const databaseUrl = await secrets.getSecret("database-url");
+```
+
+Secrets are typically stored as environment variable names or secret manager references, depending on your deployment environment.
+
+---
+
+### 3.5. Custom Configurations
+
+You can define your own custom configurations by extending the `TotoControllerConfig` base class.
+
+An example:
+
+```typescript
+import { TotoControllerConfig } from 'totoms';
+
+export class MyServiceConfig extends TotoControllerConfig {
+    
+    apiKey: string | undefined;
+    
+    async load(): Promise<void> {
+        // Load secrets using the secrets manager
+        this.apiKey = await this.secretsManager.getSecret("my-api-key");
+    }
+    
+    getMongoSecretNames() {
+        // Return null if your service doesn't use MongoDB
+        return null;
+    }
+}
+```
+
+What you can do with a Custom Configuration:
+
+1. **Load Secrets** <br>
+You can do that by overriding the `load()` async method and using `this.secretsManager.getSecret("your-secret-name")` to load secrets.
+
+2. **Configure MongoDB** <br>
+Override `getMongoSecretNames()`, `getDBName()`, and `getCollections()` to configure MongoDB integration.
+
+3. **Custom Authentication** <br>
+Override `getCustomAuthVerifier()` to provide custom authentication logic.
+
+## Core Components
+
+### TotoAPIController
+The main controller for building REST APIs with Express. Provides:
+- Automatic route registration
+- Built-in validation
+- CORS support
+- Health check endpoints
+- File upload support
+- API documentation generation
+
+### TotoMicroservice
+High-level wrapper that initializes the entire microservice stack including API controller, message bus, and environment configuration.
+
+### TotoMessageBus
+Unified interface for pub/sub messaging across cloud platforms:
+- **AWS**: SNS/SQS
+- **GCP**: Cloud Pub/Sub
+- **Azure**: Service Bus (in development)
+
+### TotoControllerConfig
+Base configuration class for microservices with support for:
+- MongoDB connection management
+- Authentication settings
+- Secrets management
+- Custom validators
+
+### Logger
+Structured logging with correlation ID support for request tracing.
+
+### Validator
+Request validation framework with support for:
+- JWT token validation
+- Google OAuth
+- Custom validation logic
+
+## Cloud Platform Support
+
+### AWS
+- **Messaging**: SNS (topics), SQS (queues)
+- **Secrets**: AWS Secrets Manager
+- **Region Configuration**: Configurable per service
+
+### GCP
+- **Messaging**: Cloud Pub/Sub
+- **Secrets**: Secret Manager
+- **Project Configuration**: Uses default project credentials
+
+### Azure
+- **Messaging**: Service Bus (in development)
+- **Secrets**: Key Vault (in development)
+
+## License
+
+MIT
+
+## Author
+
+nicolasances
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request to the [toto-microservice-sdk repository](https://github.com/nicolasances/toto-microservice-sdk).
+
+## Related Projects
+
+- [Toto Ecosystem](https://github.com/nicolasances/toto)
+- [Python Toto Microservice SDK](../python)

package/dist/api/TotoAPIController.d.ts

@@ -0,0 +1,30 @@
+import { Express, Request } from 'express';
+import { TotoControllerConfig } from '../model/TotoControllerConfig';
+import { TotoDelegate } from '../model/TotoDelegate';
+import { TotoPathOptions } from '../model/TotoPathOptions';
+import { TotoEnvironment } from '..';
+export declare class TotoControllerOptions {
+    debugMode?: boolean;
+    basePath?: string;
+    port?: number;
+}
+export interface TotoControllerProps {
+    apiName: string;
+    environment: TotoEnvironment;
+    config: TotoControllerConfig;
+}
+export declare class TotoAPIController {
+    app: Express;
+    apiName: string;
+    props: TotoControllerProps;
+    options: TotoControllerOptions;
+    constructor(props: TotoControllerProps, options?: TotoControllerOptions);
+    init(): Promise<void>;
+    staticContent(path: string, folder: string, options?: TotoPathOptions): void;
+    streamGET(path: string, delegate: TotoDelegate, options?: TotoPathOptions): void;
+    fileUploadPath(path: string, delegate: TotoDelegate, options?: TotoPathOptions): void;
+    registerPubSubMessageEndpoint(path: string, handler: (req: Request) => Promise<any>, options?: TotoPathOptions): void;
+    path(method: string, path: string, delegate: TotoDelegate, options?: TotoPathOptions): void;
+    listen(): void;
+}
+//# sourceMappingURL=TotoAPIController.d.ts.map

package/dist/api/TotoAPIController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TotoAPIController.d.ts","sourceRoot":"","sources":["../../src/api/TotoAPIController.ts"],"names":[],"mappings":"AAGA,OAAgB,EAAE,OAAO,EAAE,OAAO,EAAY,MAAM,SAAS,CAAA;AAI7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAA;AAEpE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAGrD,OAAO,EAAE,eAAe,EAAE,MAAM,0BAA0B,CAAC;AAI3D,OAAO,EAAE,eAAe,EAAE,MAAM,IAAI,CAAC;AAErC,qBAAa,qBAAqB;IAC9B,SAAS,CAAC,EAAE,OAAO,CAAQ;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAY;IAC7B,IAAI,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,mBAAmB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,eAAe,CAAC;IAC7B,MAAM,EAAE,oBAAoB,CAAC;CAChC;AASD,qBAAa,iBAAiB;IAE1B,GAAG,EAAE,OAAO,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,mBAAmB,CAAC;IAC3B,OAAO,EAAE,qBAAqB,CAAC;gBAQnB,KAAK,EAAE,mBAAmB,EAAE,OAAO,GAAE,qBAA0B;IA2CrE,IAAI;IAgBV,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,eAAe;IAiBrE,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,eAAe;IAgDzE,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,eAAe;IAqF9E,6BAA6B,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC,GAAG,CAAC,EAAE,OAAO,CAAC,EAAE,eAAe;IAuD9G,IAAI,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,YAAY,EAAE,OAAO,CAAC,EAAE,eAAe;IAyDpF,MAAM;CAgBT"}

package/dist/api/TotoAPIController.js

@@ -0,0 +1,226 @@
+import bodyParser from 'body-parser';
+import busboy from 'connect-busboy';
+import fs from 'fs-extra';
+import express from 'express';
+import { v4 as uuidv4 } from 'uuid';
+import { Logger } from '../logger/TotoLogger';
+import { ValidationError, Validator } from '../validation/Validator';
+import { SmokeDelegate } from '../dlg/SmokeDelegate';
+import { TotoRuntimeError } from '../model/TotoRuntimeError';
+import path from 'path';
+import { TotoRegistryAPI } from '../integration/TotoRegistryAPI';
+import { RegistryCache } from '../integration/RegistryCache';
+export class TotoControllerOptions {
+    constructor() {
+        this.debugMode = false;
+        this.basePath = undefined;
+    }
+}
+export class TotoAPIController {
+    constructor(props, options = {}) {
+        this.app = express();
+        this.props = props;
+        this.apiName = props.apiName;
+        this.options = {
+            debugMode: options.debugMode ?? false,
+            basePath: options.basePath,
+            port: options.port ?? 8080
+        };
+        const logger = Logger.getInstance();
+        if (options.debugMode)
+            logger.compute("INIT", `[TotoAPIController Debug] - Config Properties: ${JSON.stringify(this.props.config.getProps())}`);
+        this.app.use(function (req, res, next) {
+            res.header("Access-Control-Allow-Origin", "*");
+            res.header("Access-Control-Allow-Headers", "Origin, X-Requested-With, Content-Type, Accept, Authorization, x-correlation-id, x-msg-id, auth-provider, x-app-version, x-client, x-client-id");
+            res.header("Access-Control-Allow-Methods", "OPTIONS, GET, PUT, POST, DELETE");
+            next();
+        });
+        this.app.use(bodyParser.json());
+        this.app.use(busboy());
+        this.app.use(express.static(path.join(__dirname, 'public')));
+        const smokeEndpoint = new SmokeDelegate(null, this.props.config);
+        smokeEndpoint.apiName = this.apiName;
+        this.path('GET', '/', smokeEndpoint, { noAuth: true, contentType: 'application/json' });
+        this.path('GET', '/', smokeEndpoint, { noAuth: true, contentType: 'application/json', ignoreBasePath: true });
+        this.path('GET', '/health', smokeEndpoint, { noAuth: true, contentType: 'application/json', ignoreBasePath: true });
+        this.staticContent = this.staticContent.bind(this);
+        this.fileUploadPath = this.fileUploadPath.bind(this);
+        this.path = this.path.bind(this);
+    }
+    async init() {
+        const registrationResponse = await new TotoRegistryAPI(this.props.config).registerAPI({ apiName: this.apiName, basePath: this.options.basePath?.replace("/", ""), hyperscaler: this.props.environment.hyperscaler });
+        Logger.getInstance().compute("INIT", `API ${this.apiName} successfully registered with Toto API Registry: ${JSON.stringify(registrationResponse)}`, 'info');
+        RegistryCache.getInstance(this.props.config).refresh();
+    }
+    staticContent(path, folder, options) {
+        const correctedPath = (this.options.basePath && (!options || !options.ignoreBasePath)) ? this.options.basePath.replace(/\/$/, '').trim() + path : path;
+        this.app.use(correctedPath, express.static(folder));
+    }
+    streamGET(path, delegate, options) {
+        const correctedPath = (this.options.basePath && (!options || !options.ignoreBasePath)) ? this.options.basePath.replace(/\/$/, '').trim() + path : path;
+        const validator = new Validator(this.props.config, this.options.debugMode || false);
+        const logger = Logger.getInstance();
+        this.app.route(correctedPath).get((req, res, next) => {
+            validator.validate(req, options).then((userContext) => {
+                logger.apiIn(req.headers['x-correlation-id'], 'GET', correctedPath);
+                delegate.processRequest(req, userContext).then((stream) => {
+                    if (options && options.contentType)
+                        res.header('Content-Type', options.contentType);
+                    res.writeHead(200);
+                    stream.on('data', (data) => {
+                        res.write(data);
+                    });
+                    stream.on('end', () => {
+                        res.end();
+                    });
+                }, (err) => {
+                    logger.compute(req.headers['x-correlation-id'], err, 'error');
+                    if (err != null && err.code == '400')
+                        res.status(400).type('application/json').send(err);
+                    else
+                        res.status(500).type('application/json').send(err);
+                });
+            });
+        });
+    }
+    fileUploadPath(path, delegate, options) {
+        const correctedPath = (this.options.basePath && (!options || !options.ignoreBasePath)) ? this.options.basePath.replace(/\/$/, '').trim() + path : path;
+        const validator = new Validator(this.props.config, this.options.debugMode || false);
+        const logger = Logger.getInstance();
+        this.app.route(correctedPath).post(async (req, res, next) => {
+            logger.apiIn(req.headers['x-correlation-id'], 'POST', correctedPath);
+            const userContext = await validator.validate(req);
+            let fstream;
+            let filename;
+            let filepath;
+            let additionalData = {};
+            req.pipe(req.busboy);
+            req.busboy.on('field', (fieldname, value, metadata) => {
+                additionalData[fieldname] = value;
+            });
+            req.busboy.on('file', (fieldname, file, metadata) => {
+                logger.compute(req.headers['x-correlation-id'], 'Uploading file ' + metadata.filename, 'info');
+                let dir = __dirname + '/app-docs';
+                filename = metadata.filename;
+                filepath = dir + '/' + metadata.filename;
+                fs.ensureDirSync(dir);
+                fstream = fs.createWriteStream(dir + '/' + metadata.filename);
+                file.pipe(fstream);
+            });
+            req.busboy.on("finish", () => {
+                delegate.processRequest({
+                    query: req.query,
+                    params: req.params,
+                    headers: req.headers,
+                    body: { filepath: filepath, filename: filename, ...additionalData }
+                }, userContext).then((data) => {
+                    res.status(200).type('application/json').send(data);
+                }, (err) => {
+                    logger.compute(req.headers['x-correlation-id'], err, 'error');
+                    if (err != null && err.code == '400')
+                        res.status(400).type('application/json').send(err);
+                    else
+                        res.status(500).type('application/json').send(err);
+                });
+            });
+        });
+        logger.compute("INIT", '[' + this.apiName + '] - Successfully added method ' + 'POST' + ' ' + correctedPath);
+    }
+    registerPubSubMessageEndpoint(path, handler, options) {
+        const correctedPath = (this.options.basePath && (!options || !options.ignoreBasePath)) ? this.options.basePath.replace(/\/$/, '').trim() + path : path;
+        const logger = Logger.getInstance();
+        const handleRequest = async (req, res) => {
+            const cid = req.get('x-correlation-id') || uuidv4();
+            try {
+                logger.compute(cid, `Received event on path ${path}`);
+                const data = await handler(req);
+                logger.compute(cid, `Event on path ${path} processed with result: ${JSON.stringify(data)}`);
+                res.status(200).type('application/json').send(data);
+            }
+            catch (error) {
+                logger.compute(cid, `${error}`, "error");
+                if (error instanceof ValidationError || error instanceof TotoRuntimeError) {
+                    res.status(error.code).type("application/json").send(error);
+                }
+                else {
+                    console.log(error);
+                    res.status(500).type('application/json').send(error);
+                }
+            }
+        };
+        this.app.post(correctedPath, parseTextAsJson, handleRequest);
+        logger.compute("INIT", "Successfully added event handler POST " + correctedPath);
+    }
+    path(method, path, delegate, options) {
+        const correctedPath = (this.options.basePath && (!options || !options.ignoreBasePath)) ? this.options.basePath.replace(/\/$/, '').trim() + path : path;
+        const validator = new Validator(this.props.config, this.options.debugMode || false);
+        const logger = Logger.getInstance();
+        const handleRequest = async (req, res) => {
+            const cid = String(req.headers['x-correlation-id']);
+            try {
+                logger.apiIn(cid, method, correctedPath);
+                const userContext = await validator.validate(req, options);
+                const data = await delegate.processRequest(req, userContext);
+                let contentType = 'application/json';
+                let dataToReturn = data;
+                res.status(200).type(contentType).send(dataToReturn);
+            }
+            catch (error) {
+                logger.compute(cid, `${error}`, "error");
+                if (error instanceof ValidationError || error instanceof TotoRuntimeError) {
+                    res.status(error.code).type("application/json").send(error);
+                }
+                else {
+                    console.log(error);
+                    res.status(500).type('application/json').send(error);
+                }
+            }
+        };
+        if (method == "GET")
+            this.app.get(correctedPath, handleRequest);
+        else if (method == "POST")
+            this.app.post(correctedPath, handleRequest);
+        else if (method == "PUT")
+            this.app.put(correctedPath, handleRequest);
+        else if (method == "DELETE")
+            this.app.delete(correctedPath, handleRequest);
+        else
+            this.app.get(correctedPath, handleRequest);
+        logger.compute("INIT", '[' + this.apiName + '] - Successfully added method ' + method + ' ' + correctedPath);
+    }
+    listen() {
+        const validator = new Validator(this.props.config, this.options.debugMode || false);
+        const logger = Logger.getInstance();
+        if (!validator) {
+            logger.compute("INIT", "Waiting for the configuration to load...");
+            setTimeout(() => { this.listen(); }, 300);
+            return;
+        }
+        this.app.listen(this.options.port, () => {
+            logger.compute("INIT", `[${this.apiName}] - Microservice listening on port ${this.options.port}`, 'info');
+        });
+    }
+}
+const parseTextAsJson = (req, res, next) => {
+    const contentType = req.get('content-type') || '';
+    if (contentType.includes('text/plain')) {
+        bodyParser.text({ type: 'text/plain' })(req, res, (err) => {
+            if (err)
+                return next(err);
+            try {
+                if (typeof req.body === 'string') {
+                    req.body = JSON.parse(req.body);
+                }
+                next();
+            }
+            catch (parseError) {
+                console.log(`Failed to parse SNS text/plain body as JSON: ${parseError}`, 'error');
+                next(parseError);
+            }
+        });
+    }
+    else {
+        next();
+    }
+};
+//# sourceMappingURL=TotoAPIController.js.map