idea-aws 4.4.1 → 4.4.3

package/dist/src/resourceController.js

@@ -0,0 +1,561 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResourceController = void 0;
+const fs_1 = require("fs");
+const Lambda = __importStar(require("@aws-sdk/client-lambda"));
+const EventBridge = __importStar(require("@aws-sdk/client-eventbridge"));
+const idea_toolbox_1 = require("idea-toolbox");
+const metrics_1 = require("./metrics");
+const genericController_1 = require("./genericController");
+const dynamoDB_1 = require("./dynamoDB");
+const ENV = process?.env ?? {};
+const { PROJECT, STAGE, RESOURCE } = ENV;
+ENV.POWERTOOLS_SERVICE_NAME = [PROJECT, STAGE, RESOURCE].filter(x => x).join('_');
+/**
+ * An abstract class to inherit to manage API requests (AWS API Gateway) in an AWS Lambda function.
+ */
+class ResourceController extends genericController_1.GenericController {
+    constructor(event, callback, options = {}) {
+        super(event, callback);
+        this.initError = false;
+        this.project = PROJECT;
+        this.stage = STAGE;
+        this.resource = RESOURCE;
+        this.clientVersion = '?';
+        this.clientPlatform = '?';
+        this.clientBundle = null;
+        this.templateMatcher = /{{\s?([^{}\s]*)\s?}}/g;
+        ///
+        /// REQUEST HANDLERS
+        ///
+        this.handleRequest = async () => {
+            if (this.initError)
+                return;
+            this.logger.info('START', { event: this.getEventSummary() });
+            let lambdaSegment, rcSegment;
+            if (this.tracer) {
+                lambdaSegment = this.tracer.getSegment();
+                if (lambdaSegment) {
+                    rcSegment = lambdaSegment.addNewSubsegment('RC');
+                    this.tracer.setSegment(rcSegment);
+                }
+                this.tracer.annotateColdStart();
+                this.tracer.addServiceNameAnnotation();
+                this.tracer.putMetadata('START', { event: this.getEventSummary() });
+            }
+            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 genericController_1.HandledError('Unsupported method'));
+                        }
+                    }
+                    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 genericController_1.HandledError('Unsupported method'));
+                        }
+                    }
+                    this.done(null, response);
+                }
+                catch (err) {
+                    this.done(this.handleControllerError(err, 'HANDLER-ERROR', 'Operation failed'));
+                }
+            }
+            catch (err) {
+                this.done(this.handleControllerError(err, 'AUTH-CHECK-ERROR', 'Forbidden'));
+            }
+            finally {
+                if (this.tracer && lambdaSegment && rcSegment) {
+                    rcSegment.close();
+                    this.tracer.setSegment(lambdaSegment);
+                }
+            }
+        };
+        this.event = event;
+        this.callback = callback;
+        try {
+            if (event.version === '2.0')
+                this.initFromEventV2(event, options);
+            else
+                this.initFromEventV1(event, options);
+            this.logRequestsWithKey = options.logRequestsWithKey;
+            this.tracer = options.tracer;
+            // acquire some info about the client, if available
+            if (this.queryParams['_v']) {
+                this.clientVersion = this.queryParams['_v'];
+                delete this.queryParams['_v'];
+            }
+            if (this.queryParams['_p']) {
+                this.clientPlatform = this.queryParams['_p'];
+                delete this.queryParams['_p'];
+            }
+            if (this.queryParams['_b']) {
+                this.clientBundle = this.queryParams['_b'];
+                delete this.queryParams['_b'];
+            }
+            if (options.useMetrics)
+                this.prepareMetrics();
+        }
+        catch (err) {
+            this.initError = true;
+            this.done(this.handleControllerError(err, 'INIT-ERROR', 'Malformed request'));
+        }
+    }
+    initFromEventV2(event, options) {
+        this.authorization = event.headers.authorization;
+        const authorizer = event.requestContext?.authorizer ?? {};
+        const contextFromAuthorizer = authorizer.lambda ?? authorizer.jwt?.claims ?? {};
+        this.principalId = contextFromAuthorizer.principalId ?? contextFromAuthorizer.sub ?? null;
+        this.cognitoUser = authorizer.jwt?.claims ? new idea_toolbox_1.CognitoUser(authorizer.jwt?.claims) : null;
+        this.auth0User = contextFromAuthorizer.auth0User ? new idea_toolbox_1.Auth0User(contextFromAuthorizer.auth0User) : null;
+        this.stage = this.stage ?? event.requestContext.stage;
+        this.httpMethod = event.requestContext.http.method;
+        this.resourcePath = 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 || {};
+        try {
+            this.body = (event.body ? JSON.parse(event.body) : {}) || {};
+        }
+        catch (error) {
+            throw new genericController_1.HandledError('Malformed 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.auth0User = null;
+        this.stage = this.stage ?? event.requestContext.stage;
+        this.httpMethod = event.httpMethod;
+        this.resourcePath = 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 || {};
+        try {
+            this.body = (event.body ? JSON.parse(event.body) : {}) || {};
+        }
+        catch (error) {
+            throw new genericController_1.HandledError('Malformed body');
+        }
+    }
+    getEventSummary() {
+        return {
+            httpMethod: this.httpMethod,
+            path: this.path,
+            principalId: this.principalId,
+            queryParams: this.queryParams,
+            body: this.body,
+            version: this.clientVersion,
+            platform: this.clientPlatform,
+            bundle: this.clientBundle
+        };
+    }
+    /**
+     * Force the parsing of a query parameter as an array of strings.
+     */
+    getQueryParamAsArray(paramName) {
+        if (!this.queryParams[paramName])
+            return [];
+        else if (Array.isArray(this.queryParams[paramName]))
+            return this.queryParams[paramName];
+        else
+            return String(this.queryParams[paramName]).split(',');
+    }
+    done(error, rawResult, statusCode = this.returnStatusCode ?? (error ? 400 : 200)) {
+        const result = error ? { message: error.message } : rawResult ?? {};
+        const responseTrace = { result: Array.isArray(result) ? { array: result.length } : result };
+        this.logger.debug('END-DETAIL', responseTrace);
+        if (this.tracer)
+            this.tracer.addResponseAsMetadata(responseTrace, 'END-DETAIL');
+        const finalLogContent = { statusCode, event: this.getEventSummary() };
+        if (error) {
+            if (error.unhandled)
+                this.logger.error('END-FAILED', error, finalLogContent);
+            else
+                this.logger.warn('END-FAILED', error, finalLogContent);
+            if (this.tracer)
+                this.tracer.addErrorAsMetadata(error);
+        }
+        else
+            this.logger.info('END-SUCCESS', finalLogContent);
+        if (this.logRequestsWithKey)
+            this.storeLog(!error);
+        if (this.metrics)
+            this.publishMetrics(statusCode, error);
+        this.callback(null, {
+            statusCode: String(statusCode),
+            body: JSON.stringify(result),
+            headers: { 'Content-Type': 'application/json', 'Access-Control-Allow-Origin': '*' }
+        });
+    }
+    /**
+     * To @override
+     */
+    async checkAuthBeforeRequest() {
+        return;
+    }
+    /**
+     * To @override
+     */
+    async getResource() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async postResource() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async putResource() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async deleteResource() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async headResource() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async getResources() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async postResources() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async putResources() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async patchResource() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async patchResources() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async deleteResources() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    /**
+     * To @override
+     */
+    async headResources() {
+        throw new genericController_1.HandledError('Unsupported method');
+    }
+    ///
+    /// HELPERS
+    ///
+    /**
+     * Store the log associated to the request (no response/error handling).
+     */
+    async storeLog(succeeded) {
+        const log = new idea_toolbox_1.APIRequestLog({
+            logId: this.logRequestsWithKey,
+            userId: this.principalId,
+            resource: this.resourcePath,
+            path: this.path,
+            resourceId: this.resourceId,
+            method: this.httpMethod,
+            succeeded
+        });
+        // optionally add a track of the action
+        if (this.httpMethod === 'PATCH' && this.body && this.body.action)
+            log.action = this.body.action;
+        try {
+            await new dynamoDB_1.DynamoDB().put({ TableName: 'idea_logs', Item: log });
+        }
+        catch (error) {
+            // ignore
+        }
+    }
+    /**
+     * Check whether shared resource exists in the back-end (translation, template, etc.).
+     * Search for the specified file path in both the Lambda function's main folder and the layers folder.
+     */
+    sharedResourceExists(filePath) {
+        return (0, fs_1.existsSync)(`assets/${filePath}`) || (0, fs_1.existsSync)(`/opt/nodejs/assets/${filePath}`);
+    }
+    /**
+     * Load a shared resource in the back-end (translation, template, etc.).
+     * Search for the specified file path in both the Lambda function's main folder and the layers folder.
+     */
+    loadSharedResource(filePath) {
+        let path = null;
+        if ((0, fs_1.existsSync)(`assets/${filePath}`))
+            path = `assets/${filePath}`;
+        else if ((0, fs_1.existsSync)(`/opt/nodejs/assets/${filePath}`))
+            path = `/opt/nodejs/assets/${filePath}`;
+        return path ? (0, fs_1.readFileSync)(path, { encoding: 'utf-8' }) : null;
+    }
+    /**
+     * Prepare the CloudWatch metrics at the beginning of a request.
+     */
+    prepareMetrics() {
+        this.metrics = new metrics_1.CloudWatchMetrics({ project: this.project });
+        this.metrics.addDimension('stage', this.stage);
+        this.metrics.addDimension('resource', this.resource);
+        this.metrics.addDimension('method', this.httpMethod);
+        this.metrics.addDimension('target', this.resourceId ? 'id' : 'list');
+        this.metrics.addDimension('action', this.body?.action);
+        this.metrics.addDimension('userId', this.principalId);
+        this.metrics.addDimension('clientVersion', this.clientVersion);
+        this.metrics.addDimension('clientPlatform', this.clientPlatform);
+        this.metrics.addDimension('clientBundle', this.clientBundle ?? '-');
+        this.metrics.addMetadata('resourceId', this.resourceId);
+    }
+    /**
+     * Publish the CloudWatch metrics (default and custom-defined) at the end of a reqeust.
+     */
+    publishMetrics(statusCode, error) {
+        if (!this.metrics)
+            return;
+        this.metrics.addMetric('request');
+        this.metrics.addMetric('statusCode', statusCode);
+        if (error) {
+            this.metrics.addMetric('failed');
+            this.metrics.addMetadata('error', error.name);
+        }
+        else
+            this.metrics.addMetric('success');
+        this.metrics.publishStoredMetrics();
+    }
+    ///
+    /// MANAGE INTERNAL API REQUESTS (lambda invokes masked as API requests)
+    ///
+    /**
+     * Simulate an internal API request, invoking directly the lambda and therefore saving resources.
+     * @return the body of the response
+     * @deprecated don't run a Lambda from another Lambda (bad practice)
+     */
+    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 command = new Lambda.InvokeCommand({
+            FunctionName: params.lambda,
+            InvocationType: 'RequestResponse',
+            Payload: this.mapEventForInternalApiRequest(params),
+            Qualifier: params.stage ?? this.stage
+        });
+        const client = new Lambda.LambdaClient();
+        const { Payload } = await client.send(command);
+        const payload = JSON.parse(Buffer.from(Payload).toString());
+        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)
+        };
+        const client = new EventBridge.EventBridgeClient();
+        const command = new EventBridge.PutEventsCommand({ Entries: [request] });
+        return await client.send(command);
+    }
+    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.
+     * @deprecated don't run a Lambda from another Lambda (bad practice)
+     */
+    comesFromInternalRequest() {
+        return Boolean(this.event.internalAPIRequest);
+    }
+    //
+    // TRANSLATIONS
+    //
+    /**
+     * Load the translations from the shared resources and set them with a fallback language.
+     */
+    loadTranslations(lang, defLang) {
+        // check for the existance of the mandatory source file
+        if (!this.sharedResourceExists(`i18n/${lang}.json`))
+            return;
+        // set the languages
+        this.currentLang = lang;
+        this.defaultLang = defLang ?? lang;
+        this.translations = {};
+        // load the translations in the chosen language
+        this.translations[this.currentLang] = JSON.parse(this.loadSharedResource(`i18n/${this.currentLang}.json`).toString());
+        // load the translations in the default language, if set and differ from the current
+        if (this.defaultLang !== this.currentLang && this.sharedResourceExists(`i18n/${this.defaultLang}.json`))
+            this.translations[this.defaultLang] = JSON.parse(this.loadSharedResource(`i18n/${this.defaultLang}.json`).toString());
+    }
+    /**
+     * Get a translated term by key, optionally interpolating variables (e.g. `{{user}}`).
+     * If the term doesn't exist in the current language, it is searched in the default language.
+     */
+    t(key, interpolateParams) {
+        if (!this.translations || !this.currentLang)
+            return;
+        if (!this.isDefined(key) || !key.length)
+            return;
+        let res = this.interpolate(this.getValue(this.translations[this.currentLang], key), interpolateParams);
+        if (res === undefined && this.defaultLang !== null && this.defaultLang !== this.currentLang)
+            res = this.interpolate(this.getValue(this.translations[this.defaultLang], key), interpolateParams);
+        return res;
+    }
+    /**
+     * Interpolates a string to replace parameters.
+     * `"This is a {{ key }}"` ==> `"This is a value", with params = { key: "value" }`.
+     */
+    interpolate(expr, params) {
+        if (!params || !expr)
+            return expr;
+        return expr.replace(this.templateMatcher, (substring, b) => {
+            const r = this.getValue(params, b);
+            return this.isDefined(r) ? r : substring;
+        });
+    }
+    /**
+     * Gets a value from an object by composed key.
+     * `getValue({ key1: { keyA: 'valueI' }}, 'key1.keyA')` ==> `'valueI'`.
+     */
+    getValue(target, key) {
+        const keys = typeof key === 'string' ? key.split('.') : [key];
+        key = '';
+        do {
+            key += keys.shift();
+            if (this.isDefined(target) && this.isDefined(target[key]) && (typeof target[key] === 'object' || !keys.length)) {
+                target = target[key];
+                key = '';
+            }
+            else if (!keys.length)
+                target = undefined;
+            else
+                key += '.';
+        } while (keys.length);
+        return target;
+    }
+    /**
+     * Helper to quicly check if the value is defined.
+     */
+    isDefined(value) {
+        return value !== undefined && value !== null;
+    }
+}
+exports.ResourceController = ResourceController;