idea-aws 3.9.1 → 3.10.2

package/dist/src/resourceController.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResourceController = void 0;
-/* eslint-disable no-invalid-this */
+exports.RCError = exports.ResourceController = void 0;
+require("source-map-support/register");
 const fs_1 = require("fs");
 const aws_sdk_1 = require("aws-sdk");
 const idea_toolbox_1 = require("idea-toolbox");
+const logger_1 = require("./logger");
 const genericController_1 = require("./genericController");
 /**
  * An abstract class to inherit to manage API requests (AWS API Gateway) in an AWS Lambda function.
@@ -12,82 +13,82 @@ const genericController_1 = require("./genericController");
 class ResourceController extends genericController_1.GenericController {
     constructor(event, callback, options = {}) {
         super(event, callback, options);
+        this.logger = new logger_1.Logger();
         this.templateMatcher = /{{\s?([^{}\s]*)\s?}}/g;
         ///
         /// REQUEST HANDLERS
         ///
-        this.handleRequest = () => {
-            this.checkAuthBeforeRequest()
-                .then(() => {
-                let request;
-                if (this.resourceId)
-                    switch (this.httpMethod) {
-                        // resource/{resourceId}
-                        case 'GET':
-                            request = this.getResource();
-                            break;
-                        case 'POST':
-                            request = this.postResource();
-                            break;
-                        case 'PUT':
-                            request = this.putResource();
-                            break;
-                        case 'DELETE':
-                            request = this.deleteResource();
-                            break;
-                        case 'PATCH':
-                            request = this.patchResource();
-                            break;
-                        case 'HEAD':
-                            request = this.headResource();
-                            break;
-                        default: /* nope */
+        this.handleRequest = async () => {
+            try {
+                await this.checkAuthBeforeRequest();
+                try {
+                    let response;
+                    if (this.resourceId) {
+                        switch (this.httpMethod) {
+                            // resource/{resourceId}
+                            case 'GET':
+                                response = await this.getResource();
+                                break;
+                            case 'POST':
+                                response = await this.postResource();
+                                break;
+                            case 'PUT':
+                                response = await this.putResource();
+                                break;
+                            case 'DELETE':
+                                response = await this.deleteResource();
+                                break;
+                            case 'PATCH':
+                                response = await this.patchResource();
+                                break;
+                            case 'HEAD':
+                                response = await this.headResource();
+                                break;
+                            default:
+                                this.done(new RCError('Unsupported method'));
+                        }
                     }
-                else
-                    switch (this.httpMethod) {
-                        // resource
-                        case 'GET':
-                            request = this.getResources();
-                            break;
-                        case 'POST':
-                            request = this.postResources();
-                            break;
-                        case 'PUT':
-                            request = this.putResources();
-                            break;
-                        case 'DELETE':
-                            request = this.deleteResources();
-                            break;
-                        case 'PATCH':
-                            request = this.patchResources();
-                            break;
-                        case 'HEAD':
-                            request = this.headResources();
-                            break;
-                        default: /* nope */
+                    else {
+                        switch (this.httpMethod) {
+                            // resource
+                            case 'GET':
+                                response = await this.getResources();
+                                break;
+                            case 'POST':
+                                response = await this.postResources();
+                                break;
+                            case 'PUT':
+                                response = await this.putResources();
+                                break;
+                            case 'DELETE':
+                                response = await this.deleteResources();
+                                break;
+                            case 'PATCH':
+                                response = await this.patchResources();
+                                break;
+                            case 'HEAD':
+                                response = await this.headResources();
+                                break;
+                            default:
+                                this.done(new RCError('Unsupported method'));
+                        }
                     }
-                if (!request)
-                    this.done(new Error('Unsupported method'));
-                else {
-                    request.then((res) => this.done(null, res)).catch((err) => this.done(err));
+                    this.done(null, response);
                 }
-            })
-                .catch(err => this.done(new Error(err?.message ?? 'Forbidden')));
+                catch (err) {
+                    this.done(this.controlHandlerError(err, 'HANDLER-ERROR', 'Operation failed'));
+                }
+            }
+            catch (err) {
+                this.done(this.controlHandlerError(err, 'AUTH-CHECK-ERROR', 'Forbidden'));
+            }
         };
-        this.authorization = event.headers?.Authorization;
-        this.claims = event.requestContext?.authorizer?.claims;
-        this.principalId = this.claims?.sub;
-        this.user = this.principalId ? new idea_toolbox_1.CognitoUser(this.claims) : null;
-        this.stage = event.requestContext?.stage;
-        this.httpMethod = event.httpMethod;
-        this.resource = (event.resource || '').replace('+', ''); // {proxy+} -> {proxy}
-        this.path = event.path || '';
-        this.resourceId =
-            event.pathParameters && event.pathParameters[options.resourceId || 'proxy']
-                ? decodeURIComponent(event.pathParameters[options.resourceId || 'proxy'])
-                : '';
-        this.queryParams = event.queryStringParameters || {};
-        this.body = (event.body ? JSON.parse(event.body) : {}) || {};
+        this.event = event;
+        this.callback = callback;
+        if (event.version === '2.0')
+            this.initFromEventV2(event, options);
+        else
+            this.initFromEventV1(event, options);
         this.logRequestsWithKey = options.logRequestsWithKey;
         // acquire some info about the client, if available
         let version = '?', platform = '?';
@@ -101,15 +102,55 @@ class ResourceController extends genericController_1.GenericController {
         }
         // print the initial log
         const info = { principalId: this.principalId, queryParams: this.queryParams, body: this.body, version, platform };
-        (0, idea_toolbox_1.logger)(`START: ${this.httpMethod} ${this.stage} ${this.path}`, null, info, true);
+        this.logger.info(`START: ${this.httpMethod} ${this.path}`, info);
+    }
+    initFromEventV2(event, options) {
+        this.authorization = event.headers.authorization;
+        const contextFromAuthorizer = event.requestContext?.authorizer?.lambda || {};
+        this.principalId = contextFromAuthorizer.principalId;
+        this.stage = event.requestContext.stage;
+        this.httpMethod = event.requestContext.http.method;
+        this.resource = event.routeKey.replace('+', ''); // {proxy+} -> {proxy}
+        this.path = event.rawPath;
+        this.pathParameters = {};
+        for (const param in event.pathParameters)
+            this.pathParameters[param] = event.pathParameters[param] ? decodeURIComponent(event.pathParameters[param]) : null;
+        this.resourceId = this.pathParameters[options.resourceId || 'proxy'];
+        this.queryParams = event.queryStringParameters || {};
+        this.body = (event.body ? JSON.parse(event.body) : {}) || {};
+    }
+    initFromEventV1(event, options) {
+        this.authorization = event.headers.Authorization;
+        this.claims = event.requestContext.authorizer?.claims || {};
+        this.principalId = this.claims.sub;
+        this.cognitoUser = this.principalId ? new idea_toolbox_1.CognitoUser(this.claims) : null;
+        this.stage = event.requestContext.stage;
+        this.httpMethod = event.httpMethod;
+        this.resource = event.resource.replace('+', ''); // {proxy+} -> {proxy}
+        this.path = event.path;
+        this.pathParameters = {};
+        for (const param in event.pathParameters)
+            this.pathParameters[param] = event.pathParameters[param] ? decodeURIComponent(event.pathParameters[param]) : null;
+        this.resourceId = this.pathParameters[options.resourceId || 'proxy'];
+        this.queryParams = event.queryStringParameters || {};
+        this.body = (event.body ? JSON.parse(event.body) : {}) || {};
     }
-    done(err, res, statusCode) {
-        (0, idea_toolbox_1.logger)(err ? 'DONE WITH ERRORS' : 'DONE', err, res, true);
+    controlHandlerError(err = {}, context, replaceWithErrorMessage) {
+        if (err instanceof RCError)
+            return new Error(err.message);
+        this.logger.error(context, err);
+        return new Error(replaceWithErrorMessage);
+    }
+    done(err, res, statusCode = this.returnStatusCode || (err ? 400 : 200)) {
+        if (err)
+            this.logger.info('END-FAILED', { statusCode, error: err.message || err.errorMessage });
+        else
+            this.logger.info('END-SUCCESS', { statusCode });
         // if configured, store the log of the request
         if (this.logRequestsWithKey)
             this.storeLog(!err);
         this.callback(null, {
-            statusCode: statusCode ?? (err ? '400' : '200'),
+            statusCode: String(statusCode),
             body: err ? JSON.stringify({ message: err.message }) : JSON.stringify(res || {}),
             headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' }
         });
@@ -117,80 +158,80 @@ class ResourceController extends genericController_1.GenericController {
     /**
      * To @override
      */
-    checkAuthBeforeRequest() {
-        return new Promise(resolve => resolve());
+    async checkAuthBeforeRequest() {
+        return;
     }
     /**
      * To @override
      */
-    getResource() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async getResource() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    postResource() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async postResource() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    putResource() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async putResource() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    deleteResource() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async deleteResource() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    headResource() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async headResource() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    getResources() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async getResources() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    postResources() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async postResources() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    putResources() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async putResources() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    patchResource() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async patchResource() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    patchResources() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async patchResources() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    deleteResources() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async deleteResources() {
+        throw new RCError('Unsupported method');
     }
     /**
      * To @override
      */
-    headResources() {
-        return new Promise((_, reject) => reject(new Error('Unsupported method')));
+    async headResources() {
+        throw new RCError('Unsupported method');
     }
     ///
     /// HELPERS
@@ -242,47 +283,56 @@ class ResourceController extends genericController_1.GenericController {
      * @return the body of the response
      * @deprecated don't run a Lambda from another Lambda (bad practice)
      */
-    invokeInternalAPIRequest(params) {
-        return new Promise((resolve, reject) => {
-            // create a copy of the event
-            const event = JSON.parse(JSON.stringify(this.event));
-            // change only the event attributes we need; e.g. the authorization is unchanged
-            event.stage = params.stage || this.stage;
-            event.httpMethod = params.httpMethod;
-            event.resource = params.resource;
-            event.pathParameters = params.pathParams || {};
-            event.queryStringParameters = params.queryParams || {};
-            event.body = JSON.stringify(params.body || {});
-            // parse the path
-            event.path = event.resource;
-            for (const p in event.pathParameters)
-                if (event.pathParameters[p])
-                    event.resource = event.resource.replace(`{${p}}`, event.pathParameters[p]);
-            // set a flag to make the invoked to recognise that is an internal request
-            event.internalAPIRequest = true;
-            // invoke the lambda with the event prepaired, simulating an API request
-            new aws_sdk_1.Lambda().invoke({
-                FunctionName: params.lambda,
-                Qualifier: event.stage,
-                InvocationType: 'RequestResponse',
-                Payload: JSON.stringify(event)
-            }, (err, res) => {
-                // reject in case of internal error
-                if (err)
-                    reject(err);
-                else {
-                    // parse the payload and the body
-                    const payload = JSON.parse(res.Payload);
-                    const body = JSON.parse(payload.body);
-                    // if the response is successfull, return the body
-                    if (Number(payload.statusCode) === 200)
-                        resolve(body);
-                    // otherwise, reject the controlled error
-                    else
-                        reject(new Error(body.message));
-                }
-            });
-        });
+    async invokeInternalAPIRequest(params) {
+        if (params.lambda)
+            return await this.invokeInternalAPIRequestWithLambda(params);
+        if (params.eventBridge)
+            return await this.invokeInternalAPIRequestWithEventBridge(params);
+        throw new Error('Either "lambda" or "eventBus" parameters must be set.');
+    }
+    async invokeInternalAPIRequestWithLambda(params) {
+        const lambdaInvokeParams = {
+            FunctionName: params.lambda,
+            InvocationType: 'RequestResponse',
+            Payload: this.mapEventForInternalApiRequest(params),
+            Qualifier: params.stage || this.stage
+        };
+        const res = await new aws_sdk_1.Lambda().invoke(lambdaInvokeParams).promise();
+        const payload = JSON.parse(res.Payload);
+        const body = JSON.parse(payload.body);
+        if (Number(payload.statusCode) !== 200)
+            throw new Error(body.message);
+        return body;
+    }
+    async invokeInternalAPIRequestWithEventBridge(params) {
+        const request = {
+            EventBusName: params.eventBridge.bus,
+            Source: this.constructor.name,
+            DetailType: params.eventBridge.target,
+            Detail: this.mapEventForInternalApiRequest(params)
+        };
+        return await new aws_sdk_1.EventBridge().putEvents({ Entries: [request] }).promise();
+    }
+    mapEventForInternalApiRequest(params) {
+        const event = JSON.parse(JSON.stringify(this.event));
+        // change only the event attributes we need; e.g. the authorization is unchanged
+        if (!event.requestContext)
+            event.requestContext = {};
+        event.requestContext.stage = params.stage || this.stage;
+        if (!event.requestContext.http)
+            event.requestContext.http;
+        event.requestContext.http.method = event.httpMethod = params.httpMethod;
+        event.routeKey = event.resource = params.resource;
+        event.pathParameters = params.pathParams || {};
+        event.queryStringParameters = params.queryParams || {};
+        event.body = JSON.stringify(params.body || {});
+        event.rawPath = event.path = params.resource;
+        for (const p in event.pathParameters)
+            if (event.pathParameters[p])
+                event.rawPath = event.path = event.path.replace(`{${p}}`, event.pathParameters[p]);
+        // set a flag to make the invoked to recognise that is an internal request
+        event.internalAPIRequest = true;
+        return JSON.stringify(event);
     }
     /**
      * Whether the current request comes from an internal API request, i.e. it was invoked by another controller.
@@ -365,3 +415,13 @@ class ResourceController extends genericController_1.GenericController {
     }
 }
 exports.ResourceController = ResourceController;
+/**
+ * Explicitly define a specific type of error to use in the RC's handler, to distinguish it from the normal errors.
+ */
+class RCError extends Error {
+    constructor(message) {
+        super(message);
+        Object.setPrototypeOf(this, RCError.prototype);
+    }
+}
+exports.RCError = RCError;

package/dist/src/s3.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GetObjectTypes = exports.S3 = void 0;
 const aws_sdk_1 = require("aws-sdk");
 const idea_toolbox_1 = require("idea-toolbox");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_s3 = null;
+const logger_1 = require("./logger");
+const logger = new logger_1.Logger();
 /**
  * A wrapper for AWS Simple Storage Service.
  */
@@ -17,9 +17,7 @@ class S3 {
         this.DEFAULT_DOWNLOAD_BUCKET = 'idea-downloads';
         this.DEFAULT_DOWNLOAD_BUCKET_SEC_TO_EXP = 180;
         this.DEFAULT_UPLOAD_BUCKET_SEC_TO_EXP = 300;
-        if (!ideaWarmStart_s3)
-            ideaWarmStart_s3 = new aws_sdk_1.S3({ apiVersion: '2006-03-01', signatureVersion: 'v4' });
-        this.s3 = ideaWarmStart_s3;
+        this.s3 = new aws_sdk_1.S3({ apiVersion: '2006-03-01', signatureVersion: 'v4' });
     }
     /**
      * Create a download link of a piece of data (through S3).
@@ -67,14 +65,14 @@ class S3 {
      * Make a copy of an object of the bucket.
      */
     async copyObject(options) {
-        (0, idea_toolbox_1.logger)('S3 COPY OBJECT', null, options.key);
+        logger.debug(`S3 copy object: ${options.key}`);
         await this.s3.copyObject({ CopySource: options.copySource, Bucket: options.bucket, Key: options.key }).promise();
     }
     /**
      * Get an object from a S3 bucket.
      */
     async getObject(options) {
-        (0, idea_toolbox_1.logger)('S3 GET OBJECT', null, options.type);
+        logger.debug(`S3 get object: ${options.type}`);
         const result = await this.s3.getObject({ Bucket: options.bucket, Key: options.key }).promise();
         switch (options.type) {
             case GetObjectTypes.JSON:
@@ -96,21 +94,21 @@ class S3 {
             params.ACL = options.acl;
         if (options.metadata)
             params.Metadata = options.metadata;
-        (0, idea_toolbox_1.logger)('S3 PUT OBJECT', null, options.key);
+        logger.debug(`S3 put object: ${options.key}`);
         return await this.s3.putObject(params).promise();
     }
     /**
      * Delete an object from an S3 bucket.
      */
     async deleteObject(options) {
-        (0, idea_toolbox_1.logger)('S3 DELETE OBJECT', null, options.key);
+        logger.debug(`S3 delete object: ${options.key}`);
         return await this.s3.deleteObject({ Bucket: options.bucket, Key: options.key }).promise();
     }
     /**
      * List the objects of an S3 bucket.
      */
     async listObjects(options) {
-        (0, idea_toolbox_1.logger)('S3 LIST OBJECTS', null, options.prefix);
+        logger.debug(`S3 list object: ${options.prefix}`);
         return await this.s3.listObjects({ Bucket: options.bucket, Prefix: options.prefix }).promise();
     }
     /**

package/dist/src/secretsManager.js

@@ -2,30 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SecretsManager = void 0;
 const aws_sdk_1 = require("aws-sdk");
-const idea_toolbox_1 = require("idea-toolbox");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_secretsManager = null;
 /**
  * A wrapper for AWS Secrets manager.
  */
 class SecretsManager {
     constructor() {
-        if (!ideaWarmStart_secretsManager)
-            ideaWarmStart_secretsManager = new aws_sdk_1.SecretsManager();
-        this.sm = ideaWarmStart_secretsManager;
+        this.sm = new aws_sdk_1.SecretsManager();
     }
     /**
      * Get a secret string from the Secret Manager by its id.
      */
     async getStringById(secretId) {
-        try {
-            const result = await this.sm.getSecretValue({ SecretId: secretId }).promise();
-            return result.SecretString;
-        }
-        catch (err) {
-            (0, idea_toolbox_1.logger)('SECRET NOT FOUND', err, secretId);
-            throw new Error('Not found');
-        }
+        const result = await this.sm.getSecretValue({ SecretId: secretId }).promise();
+        return result.SecretString;
     }
 }
 exports.SecretsManager = SecretsManager;

package/dist/src/ses.js

@@ -3,10 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SES = void 0;
 const aws_sdk_1 = require("aws-sdk");
 const nodemailer_1 = require("nodemailer");
-const idea_toolbox_1 = require("idea-toolbox");
 const dynamoDB_1 = require("./dynamoDB");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_ses = null;
+const logger_1 = require("./logger");
+const logger = new logger_1.Logger();
 /**
  * A wrapper for AWS Simple Email Service.
  */
@@ -24,10 +23,8 @@ class SES {
             Source: sesParams.sourceName ? `${sesParams.sourceName} <${sesParams.source}>` : sesParams.source,
             SourceArn: sesParams.sourceArn
         };
-        (0, idea_toolbox_1.logger)('SES SEND TEMPLATED EMAIL');
-        if (!ideaWarmStart_ses)
-            ideaWarmStart_ses = new aws_sdk_1.SES({ region: sesParams.region });
-        return await ideaWarmStart_ses.sendTemplatedEmail(request).promise();
+        logger.debug('SES send templated email');
+        return await new aws_sdk_1.SES({ region: sesParams.region }).sendTemplatedEmail(request).promise();
     }
     /**
      * Send an email through AWS Simple Email Service.
@@ -61,10 +58,8 @@ class SES {
             Source: sesParams.sourceName ? `${sesParams.sourceName} <${sesParams.source}>` : sesParams.source,
             SourceArn: sesParams.sourceArn
         };
-        (0, idea_toolbox_1.logger)('SES SEND EMAIL');
-        if (!ideaWarmStart_ses)
-            ideaWarmStart_ses = new aws_sdk_1.SES({ region: sesParams.region });
-        return await ideaWarmStart_ses.sendEmail(request).promise();
+        logger.debug('SES send email');
+        return await new aws_sdk_1.SES({ region: sesParams.region }).sendEmail(request).promise();
     }
     async sendEmailWithNodemailer(emailData, sesParams) {
         const mailOptions = {};
@@ -82,10 +77,8 @@ class SES {
         if (emailData.text)
             mailOptions.text = emailData.text;
         mailOptions.attachments = emailData.attachments;
-        (0, idea_toolbox_1.logger)('SES SEND EMAIL (NODEMAILER)');
-        if (!ideaWarmStart_ses)
-            ideaWarmStart_ses = new aws_sdk_1.SES({ region: sesParams.region });
-        return await (0, nodemailer_1.createTransport)({ SES: ideaWarmStart_ses }).sendMail(mailOptions);
+        logger.debug('SES send email (Nodemailer)');
+        return await (0, nodemailer_1.createTransport)({ SES: new aws_sdk_1.SES({ region: sesParams.region }) }).sendMail(mailOptions);
     }
     prepareEmailDestination(emailData) {
         return {

package/dist/src/sns.js

@@ -3,8 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SNS = void 0;
 const aws_sdk_1 = require("aws-sdk");
 const idea_toolbox_1 = require("idea-toolbox");
-// declare libs as global vars to be reused in warm starts by the Lambda function
-let ideaWarmStart_sns = null;
 /**
  * A wrapper for AWS Simple Notification Service.
  */
@@ -29,9 +27,7 @@ class SNS {
                 throw new Error('Unsupported platform');
         }
         (0, idea_toolbox_1.logger)('SNS ADD PLATFORM ENDPOINT');
-        if (!ideaWarmStart_sns)
-            ideaWarmStart_sns = new aws_sdk_1.SNS({ apiVersion: '2010-03-31', region: snsParams.region });
-        const result = await ideaWarmStart_sns
+        const result = await new aws_sdk_1.SNS({ apiVersion: '2010-03-31', region: snsParams.region })
             .createPlatformEndpoint({ PlatformApplicationArn: platformARN, Token: token })
             .promise();
         return result.EndpointArn;
@@ -60,9 +56,7 @@ class SNS {
                     throw new Error('Unsupported platform');
             }
         (0, idea_toolbox_1.logger)('SNS PUBLISH IN TOPIC');
-        if (!ideaWarmStart_sns)
-            ideaWarmStart_sns = new aws_sdk_1.SNS({ apiVersion: '2010-03-31', region: snsParams.region });
-        return await ideaWarmStart_sns
+        return await new aws_sdk_1.SNS({ apiVersion: '2010-03-31', region: snsParams.region })
             .publish({ MessageStructure: 'json', Message: JSON.stringify(structuredMessage), TargetArn: snsParams.endpoint })
             .promise();
     }

package/dist/src/streamController.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StreamController = void 0;
-const idea_toolbox_1 = require("idea-toolbox");
 const genericController_1 = require("./genericController");
+const logger_1 = require("./logger");
+const logger = new logger_1.Logger();
 /**
  * An abstract class to inherit to manage AWS DDB streams in an AWS Lambda function.
  */
@@ -10,7 +11,7 @@ class StreamController extends genericController_1.GenericController {
     constructor(event, callback, options = {}) {
         super(event, callback, options);
         this.records = event.Records || [];
-        (0, idea_toolbox_1.logger)(`START STREAM: ${this.records.length || 0} records`, null, null, true);
+        logger.info(`START STREAM: ${this.records.length || 0} records`);
     }
 }
 exports.StreamController = StreamController;