idea-aws 4.4.3 → 4.4.4

package/dist/src/resourceController.js

@@ -1,561 +0,0 @@
-"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;