idea-aws 3.8.7 → 3.9.1

package/dist/src/cognito.d.ts

@@ -30,6 +30,13 @@ export declare class Cognito {
      * Identify a user by its userId (sub), returning its attributes.
      */
     getUserBySub(sub: string, cognitoUserPoolId: string): Promise<CognitoUserGeneric>;
+    /**
+     * Get all the users of the pool.
+     */
+    getAllUsers(cognitoUserPoolId: string, options?: {
+        pagination?: string;
+        users: CognitoUser[];
+    }): Promise<CognitoUser[]>;
     /**
      * Create a new user (by its email) in the pool specified.
      * @return userId of the new user

package/dist/src/cognito.js

@@ -72,6 +72,21 @@ class Cognito {
             throw new Error('User not found');
         return this.mapCognitoUserAttributesAsPlainObject(user);
     }
+    /**
+     * Get all the users of the pool.
+     */
+    async getAllUsers(cognitoUserPoolId, options = { users: [] }) {
+        const params = { UserPoolId: cognitoUserPoolId };
+        if (options.pagination)
+            params.PaginationToken = options.pagination;
+        const res = await this.cognito.listUsers(params).promise();
+        const pagination = res.PaginationToken;
+        const users = options.users.concat(res.Users.map(u => new idea_toolbox_1.CognitoUser(this.mapCognitoUserAttributesAsPlainObject(u))));
+        if (pagination)
+            return await this.getAllUsers(cognitoUserPoolId, { pagination, users });
+        else
+            return users;
+    }
     /**
      * Create a new user (by its email) in the pool specified.
      * @return userId of the new user

package/dist/src/resourceController.d.ts

@@ -21,7 +21,7 @@ export declare abstract class ResourceController extends GenericController {
     protected translations: any;
     protected templateMatcher: RegExp;
     constructor(event: any, callback: any, options?: ResourceControllerOptions);
-    handleRequest: () => Promise<void>;
+    handleRequest: () => void;
     protected done(err: Error | null, res?: any, statusCode?: number): void;
     /**
      * To @override
@@ -81,12 +81,14 @@ export declare abstract class ResourceController extends GenericController {
     protected storeLog(succeeded: boolean): void;
     /**
      * 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(path: string): boolean;
+    sharedResourceExists(filePath: string): boolean;
     /**
      * 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(path: string): string;
+    loadSharedResource(filePath: string): string;
     /**
      * Simulate an internal API request, invoking directly the lambda and therefore saving resources.
      * @return the body of the response

package/dist/src/resourceController.js

@@ -16,72 +16,63 @@ class ResourceController extends genericController_1.GenericController {
         ///
         /// REQUEST HANDLERS
         ///
-        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 Error('Unsupported method'));
-                        }
+        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 */
                     }
-                    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 Error('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 */
                     }
-                    this.done(null, response);
-                }
-                catch (err) {
-                    const errorMessage = err?.message || err?.errorMessage || 'Operation failed';
-                    this.done(new Error(errorMessage));
+                if (!request)
+                    this.done(new Error('Unsupported method'));
+                else {
+                    request.then((res) => this.done(null, res)).catch((err) => this.done(err));
                 }
-            }
-            catch (err) {
-                const errorMessage = err?.message || err?.errorMessage || 'Forbidden';
-                this.done(new Error(errorMessage));
-            }
+            })
+                .catch(err => this.done(new Error(err?.message ?? 'Forbidden')));
         };
         this.authorization = event.headers?.Authorization;
         this.claims = event.requestContext?.authorizer?.claims;
@@ -126,80 +117,80 @@ class ResourceController extends genericController_1.GenericController {
     /**
      * To @override
      */
-    async checkAuthBeforeRequest() {
-        return;
+    checkAuthBeforeRequest() {
+        return new Promise(resolve => resolve());
     }
     /**
      * To @override
      */
-    async getResource() {
-        throw new Error('Unsupported method');
+    getResource() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async postResource() {
-        throw new Error('Unsupported method');
+    postResource() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async putResource() {
-        throw new Error('Unsupported method');
+    putResource() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async deleteResource() {
-        throw new Error('Unsupported method');
+    deleteResource() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async headResource() {
-        throw new Error('Unsupported method');
+    headResource() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async getResources() {
-        throw new Error('Unsupported method');
+    getResources() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async postResources() {
-        throw new Error('Unsupported method');
+    postResources() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async putResources() {
-        throw new Error('Unsupported method');
+    putResources() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async patchResource() {
-        throw new Error('Unsupported method');
+    patchResource() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async patchResources() {
-        throw new Error('Unsupported method');
+    patchResources() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async deleteResources() {
-        throw new Error('Unsupported method');
+    deleteResources() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     /**
      * To @override
      */
-    async headResources() {
-        throw new Error('Unsupported method');
+    headResources() {
+        return new Promise((_, reject) => reject(new Error('Unsupported method')));
     }
     ///
     /// HELPERS
@@ -226,15 +217,22 @@ class ResourceController extends genericController_1.GenericController {
     }
     /**
      * 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(path) {
-        return (0, fs_1.existsSync)(`assets/${path}`);
+    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(path) {
-        return (0, fs_1.readFileSync)(`assets/${path}`, { encoding: 'utf-8' });
+    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;
     }
     ///
     /// MANAGE INTERNAL API REQUESTS (lambda invokes masked as API requests)

package/dist/src/ses.d.ts

@@ -112,9 +112,10 @@ export interface TemplatedEmailData extends BasicEmailData {
     template: string;
     /**
      * An object containing key-value pairs of variable-content to substitute.
+     * It supports handlebars.js templating.
      */
     templateData: {
-        [variable: string]: string;
+        [variable: string]: any;
     };
     /**
      * The name of the configuration set to use for the sending.

package/package.json

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