idea-aws 3.6.2 → 3.7.2

package/dist/src/sns.js

@@ -0,0 +1,70 @@
+"use strict";
+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.
+ */
+class SNS {
+    /**
+     * Create a new endpoint in the SNS platform specified.
+     * @return platform endpoint ARN
+     */
+    async createPushPlatormEndpoint(platform, token, snsParams) {
+        let platformARN;
+        switch (platform) {
+            case idea_toolbox_1.PushNotificationsPlatforms.APNS:
+                platformARN = snsParams.appleArn;
+                break;
+            case idea_toolbox_1.PushNotificationsPlatforms.APNS_SANDBOX:
+                platformARN = snsParams.appleDevArn;
+                break;
+            case idea_toolbox_1.PushNotificationsPlatforms.FCM:
+                platformARN = snsParams.androidArn;
+                break;
+            default:
+                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
+            .createPlatformEndpoint({ PlatformApplicationArn: platformARN, Token: token })
+            .promise();
+        return result.EndpointArn;
+    }
+    /**
+     * Publish a message to a SNS endpoint.
+     */
+    async publish(snsParams) {
+        let structuredMessage;
+        if (snsParams.json)
+            structuredMessage = { default: JSON.stringify(snsParams.json) };
+        else
+            switch (snsParams.platform) {
+                case idea_toolbox_1.PushNotificationsPlatforms.APNS:
+                    structuredMessage = { APNS: JSON.stringify({ aps: { alert: snsParams.message } }) };
+                    break;
+                case idea_toolbox_1.PushNotificationsPlatforms.APNS_SANDBOX:
+                    structuredMessage = { APNS_SANDBOX: JSON.stringify({ aps: { alert: snsParams.message } }) };
+                    break;
+                case idea_toolbox_1.PushNotificationsPlatforms.FCM:
+                    structuredMessage = {
+                        GCM: JSON.stringify({ notification: { body: snsParams.message, title: snsParams.message } })
+                    };
+                    break;
+                default:
+                    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
+            .publish({ MessageStructure: 'json', Message: JSON.stringify(structuredMessage), TargetArn: snsParams.endpoint })
+            .promise();
+    }
+}
+exports.SNS = SNS;

package/dist/src/streamController.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamController = void 0;
+const idea_toolbox_1 = require("idea-toolbox");
+const genericController_1 = require("./genericController");
+/**
+ * An abstract class to inherit to manage AWS DDB streams in an AWS Lambda function.
+ */
+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);
+    }
+}
+exports.StreamController = StreamController;

package/dist/{translate.d.ts → src/translate.d.ts}

@@ -4,6 +4,9 @@ import { Languages, PDFEntity, PDFTemplateSection } from 'idea-toolbox';
  * A wrapper for Amazon Translate.
  */
 export declare class Translate {
+    /**
+     * The instance of Amazon Translate.
+     */
     protected translate: AWSTranslate;
     /**
      * Default input language code.

package/dist/src/translate.js

@@ -0,0 +1,128 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Translate = 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_translate = null;
+/**
+ * A wrapper for Amazon Translate.
+ */
+class Translate {
+    /**
+     * Initialize a new Translate helper object.
+     */
+    constructor() {
+        if (!ideaWarmStart_translate)
+            ideaWarmStart_translate = new aws_sdk_1.Translate({ apiVersion: '2017-07-01' });
+        this.translate = ideaWarmStart_translate;
+        this.sourceLanguageCode = 'en';
+        this.targetLanguageCode = 'en';
+        this.terminologyNames = new Array();
+    }
+    /**
+     * Translates input text from the source language to the target language.
+     * @param params the parameters for translateText
+     */
+    async text(params) {
+        if (params.sourceLanguageCode)
+            this.sourceLanguageCode = params.sourceLanguageCode;
+        if (params.targetLanguageCode)
+            this.targetLanguageCode = params.targetLanguageCode;
+        if (params.terminologyNames)
+            this.terminologyNames = params.terminologyNames;
+        if (!this.sourceLanguageCode || !this.targetLanguageCode || !params.text)
+            throw new Error('Bad parameters');
+        const result = await this.translate
+            .translateText({
+            Text: params.text,
+            SourceLanguageCode: this.sourceLanguageCode,
+            TargetLanguageCode: this.targetLanguageCode,
+            TerminologyNames: this.terminologyNames
+        })
+            .promise();
+        return result.TranslatedText;
+    }
+    /**
+     * Get the contents of a PDF template (against a PDFEntity) translated in the desired language,
+     * if the latter isn't between the ones already available.
+     * @return an object that maps original texts with their translations (or nothing).
+     */
+    async pdfTemplate(entity, template, language, languages) {
+        // if the language is included in the ones supported by the team, skip
+        if (languages.available.some(l => l === language))
+            return null;
+        // analyse the template to extract terms to translate based on the entity (using a sourceLanguage as reference)
+        const termsToTranslate = Array.from(await this.analysePDFTemplateForTermsToTranslate(template, entity, languages.default));
+        const translations = {};
+        for (let i = 0; i < termsToTranslate.length; i++) {
+            const original = termsToTranslate[i];
+            const translated = await this.text({
+                sourceLanguageCode: languages.default,
+                targetLanguageCode: language,
+                text: original
+            });
+            translations[original] = translated
+                // fix markdown issue (the translations add a space before and after asterisks)
+                .replace(/\*\* /gm, '**')
+                .replace(/ \*\*/gm, '**');
+        }
+        return translations;
+    }
+    /**
+     * Analyse a PDFTemplate to extract terms to translate based on a PDFEntity (using a sourceLanguage as reference).
+     */
+    async analysePDFTemplateForTermsToTranslate(template, entity, sourceLanguage) {
+        const toTranslate = new Set();
+        // gather the terms to translate from contents available on this level
+        template
+            .filter(s => s.isEither(idea_toolbox_1.PDFTemplateSectionTypes.ROW, idea_toolbox_1.PDFTemplateSectionTypes.HEADER))
+            .forEach(s => {
+            switch (s.type) {
+                case idea_toolbox_1.PDFTemplateSectionTypes.ROW:
+                    s.columns
+                        .filter((_, index) => s.doesColumnContainAField(index))
+                        .forEach(field => {
+                        field = field;
+                        if (field.isComplex()) {
+                            const complex = field;
+                            toTranslate.add(complex.content[sourceLanguage]);
+                        }
+                        else {
+                            const simple = field;
+                            toTranslate.add(simple.label[sourceLanguage]);
+                            // try to consider only notes (long fields)
+                            if (typeof entity[simple.code] === 'string' && entity[simple.code].length > 50)
+                                toTranslate.add(entity[simple.code]);
+                        }
+                    });
+                    break;
+                case idea_toolbox_1.PDFTemplateSectionTypes.HEADER:
+                    toTranslate.add(s.title[sourceLanguage]);
+                    break;
+            }
+        });
+        // gather inner sections in a flat structure for further elaboraton
+        const innerSections = new Array();
+        template
+            .filter(s => s.isEither(idea_toolbox_1.PDFTemplateSectionTypes.INNER_SECTION, idea_toolbox_1.PDFTemplateSectionTypes.REPEATED_INNER_SECTION))
+            .forEach(s => {
+            switch (s.type) {
+                case idea_toolbox_1.PDFTemplateSectionTypes.INNER_SECTION:
+                    innerSections.push({ data: entity[s.context], template: s.innerTemplate });
+                    break;
+                case idea_toolbox_1.PDFTemplateSectionTypes.REPEATED_INNER_SECTION:
+                    entity[s.context].forEach((element) => innerSections.push({ data: element, template: s.innerTemplate }));
+                    break;
+            }
+        });
+        // run (inception) the inner sections to gather terms to translate from inner levels
+        for (let i = 0; i < innerSections.length; i++) {
+            const s = innerSections[i];
+            const res = await this.analysePDFTemplateForTermsToTranslate(s.template, s.data, sourceLanguage);
+            res.forEach(x => toTranslate.add(x));
+        }
+        return toTranslate;
+    }
+}
+exports.Translate = Translate;

package/index.ts

@@ -0,0 +1,12 @@
+export * from './src/genericController';
+export * from './src/resourceController';
+export * from './src/streamController';
+
+export * from './src/dynamoDB';
+export * from './src/cognito';
+export * from './src/comprehend';
+export * from './src/s3';
+export * from './src/ses';
+export * from './src/sns';
+export * from './src/translate';
+export * from './src/attachments';

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "idea-aws",
-  "version": "3.6.2",
+  "version": "3.7.2",
   "description": "AWS wrappers to use in IDEA's back-ends",
-  "engines": {
-    "node": ">=6.0.0"
-  },
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
+    "lint": "eslint --ext .ts",
+    "compile": "tsc --build",
+    "docs": "typedoc",
     "build": "./build.sh",
     "publishPackage": "./build.sh && npm publish"
   },
@@ -34,30 +34,24 @@
   },
   "homepage": "https://uatisdeproblem.github.io/IDEA-AWS",
   "dependencies": {
-    "idea-toolbox": "^6.3.2",
-    "nanoid": "^3.1.23",
-    "nodemailer": "^6.6.0",
+    "idea-toolbox": "^6.4.1",
+    "nanoid": "^3.1.25",
+    "nodemailer": "^6.6.3",
     "shortid": "^2.2.16",
-    "uuid": "^3.4.0"
+    "uuid": "^8.3.2"
   },
   "devDependencies": {
-    "@types/aws-lambda": "^8.10.19",
-    "@types/node": "^11.9.5",
-    "@types/nodemailer": "^4.6.6",
+    "@tsconfig/node14": "^1.0.0",
+    "@types/aws-lambda": "^8.10.72",
+    "@types/node": "^14.14.26",
+    "@types/nodemailer": "^6.4.4",
     "@types/shortid": "0.0.29",
-    "@types/uuid": "^3.4.4",
-    "@typescript-eslint/eslint-plugin": "4.3.0",
-    "@typescript-eslint/parser": "4.3.0",
-    "aws-sdk": "^2.411.0",
-    "eslint": "^7.6.0",
-    "eslint-plugin-import": "^2.22.1",
-    "eslint-plugin-jsdoc": "^30.7.9",
-    "eslint-plugin-prefer-arrow": "^1.2.2",
-    "ts-loader": "^8.0.14",
-    "typedoc": "^0.17.8",
-    "typescript": "^3.9.7",
-    "webpack": "^5.11.1",
-    "webpack-cli": "^4.3.1",
-    "webpack-node-externals": "^2.5.2"
+    "@types/uuid": "^8.3.1",
+    "@typescript-eslint/eslint-plugin": "^4.31.1",
+    "@typescript-eslint/parser": "^4.31.1",
+    "aws-sdk": "^2.991.0",
+    "eslint": "^7.32.0",
+    "typedoc": "^0.22.4",
+    "typescript": "^4.4.3"
   }
 }

package/webpack.config.js

@@ -1,18 +0,0 @@
-var nodeExternals = require('webpack-node-externals');
-
-module.exports = {
-  name: 'prod',
-  entry: './src/index.ts',
-  resolve: { extensions: ['.ts', '.tsx', '.js'] },
-  module: { rules: [{ test: /\.tsx?$/, loader: 'ts-loader', options: { transpileOnly: false } }] },
-  output: {
-    filename: 'index.js',
-    /* path: SPECIFIED BY COMMAND LINE */
-    libraryTarget: 'umd'
-  },
-  target: 'node',
-  externals: [nodeExternals()],
-  mode: 'production',
-  optimization: { minimize: false },
-  stats: 'normal'
-};