idea-aws 3.10.0 → 3.10.4

package/dist/src/cognito.d.ts

@@ -5,7 +5,9 @@ import { CognitoUser } from 'idea-toolbox';
  */
 export declare class Cognito {
     protected cognito: CognitoIdentityServiceProvider;
-    constructor();
+    constructor(params?: {
+        region?: string;
+    });
     /**
      * Change the region in which to find the user pool.
      * Default: the runner's (e.g. Lambda function) region.

package/dist/src/cognito.js

@@ -7,8 +7,8 @@ const idea_toolbox_1 = require("idea-toolbox");
  * A wrapper for AWS Cognito.
  */
 class Cognito {
-    constructor() {
-        this.cognito = new aws_sdk_1.CognitoIdentityServiceProvider({ apiVersion: '2016-04-18' });
+    constructor(params = {}) {
+        this.cognito = new aws_sdk_1.CognitoIdentityServiceProvider({ apiVersion: '2016-04-18', region: params.region });
     }
     /**
      * Change the region in which to find the user pool.

package/dist/src/resourceController.d.ts

@@ -106,6 +106,9 @@ export declare abstract class ResourceController extends GenericController {
      * @deprecated don't run a Lambda from another Lambda (bad practice)
      */
     invokeInternalAPIRequest(params: InternalAPIRequestParams): Promise<any>;
+    private invokeInternalAPIRequestWithLambda;
+    private invokeInternalAPIRequestWithEventBridge;
+    private mapEventForInternalApiRequest;
     /**
      * 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)
@@ -150,13 +153,26 @@ export interface ResourceControllerOptions extends GenericControllerOptions {
 }
 /**
  * The parameters needed to invoke an internal API request.
- * @deprecated don't run a Lambda from another Lambda (bad practice)
+ * @deprecated don't run a Lambda from another Lambda (bad practice).
  */
 export interface InternalAPIRequestParams {
     /**
-     * The name of the lambda function receiving the request; e.g. `project_memberships`.
+     * The name of the Lambda function receiving the request; e.g. `project_memberships`.
+     * Note: the invocation is always syncronous.
+     * Either this attribute or `eventBus` must be set.
      */
-    lambda: string;
+    lambda?: string;
+    /**
+     * The EventBridge destination of the request.
+     * If the bus name or ARN isn't specified, the default one is used.
+     * The `target` maps into the `DetailType` of the event.
+     * Note: the invocation is always asyncronous.
+     * Either this attribute or `lambda` must be set.
+     */
+    eventBridge?: {
+        bus?: string;
+        target?: string;
+    };
     /**
      * The alias of the lambda function to invoke. Default: the value of the current API stage.
      */

package/dist/src/resourceController.js

@@ -106,8 +106,10 @@ class ResourceController extends genericController_1.GenericController {
     }
     initFromEventV2(event, options) {
         this.authorization = event.headers.authorization;
-        const contextFromAuthorizer = event.requestContext?.authorizer?.lambda || {};
-        this.principalId = contextFromAuthorizer.principalId;
+        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.stage = event.requestContext.stage;
         this.httpMethod = event.requestContext.http.method;
         this.resource = event.routeKey.replace('+', ''); // {proxy+} -> {proxy}
@@ -283,49 +285,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
-            if (!event.requestContext)
-                event.requestContext = {};
-            event.requestContext.stage = params.stage || this.stage;
-            event.requestContext.httpMethod = event.httpMethod = params.httpMethod;
-            event.routeKey = event.resource = params.resource;
-            event.pathParameters = params.pathParams || {};
-            event.queryStringParameters = params.queryParams || {};
-            event.body = JSON.stringify(params.body || {});
-            // parse the path
-            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;
-            // invoke the lambda with the event prepaired, simulating an API request
-            new aws_sdk_1.Lambda().invoke({
-                FunctionName: params.lambda,
-                Qualifier: event.requestContext.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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "idea-aws",
-  "version": "3.10.0",
+  "version": "3.10.4",
   "description": "AWS wrappers to use in IDEA's back-ends",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",