idea-aws 4.4.4 → 4.4.5

package/dist/src/ses.js

@@ -0,0 +1,196 @@
+"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.SES = void 0;
+const client_ses_1 = require("@aws-sdk/client-ses");
+const AWSSES = __importStar(require("@aws-sdk/client-sesv2"));
+const nodemailer_1 = require("nodemailer");
+const dynamoDB_1 = require("./dynamoDB");
+const lambdaLogger_1 = require("./lambdaLogger");
+/**
+ * A wrapper for AWS Simple Email Service.
+ */
+class SES {
+    constructor(options = {}) {
+        this.logger = new lambdaLogger_1.LambdaLogger();
+        this.ses = new AWSSES.SESv2Client({ region: options.region });
+    }
+    //
+    // CONFIG
+    //
+    async getTemplate(templateName) {
+        const command = new AWSSES.GetEmailTemplateCommand({ TemplateName: templateName });
+        const { TemplateContent } = await this.ses.send(command);
+        return TemplateContent;
+    }
+    async setTemplate(templateName, subject, content, isHTML) {
+        let isNew = false;
+        try {
+            const command = new AWSSES.GetEmailTemplateCommand({ TemplateName: templateName });
+            await this.ses.send(command);
+        }
+        catch (notFound) {
+            isNew = true;
+        }
+        const template = {
+            TemplateName: templateName,
+            TemplateContent: { Subject: subject }
+        };
+        if (isHTML)
+            template.TemplateContent.Html = content;
+        else
+            template.TemplateContent.Text = content;
+        let command;
+        if (isNew)
+            command = new AWSSES.CreateEmailTemplateCommand(template);
+        else
+            command = new AWSSES.UpdateEmailTemplateCommand(template);
+        await this.ses.send(command);
+    }
+    async deleteTemplate(templateName) {
+        const command = new AWSSES.DeleteEmailTemplateCommand({ TemplateName: templateName });
+        await this.ses.send(command);
+    }
+    async testTemplate(templateName, data) {
+        const command = new AWSSES.TestRenderEmailTemplateCommand({
+            TemplateName: templateName,
+            TemplateData: JSON.stringify(data)
+        });
+        const { RenderedTemplate } = await this.ses.send(command);
+        return RenderedTemplate;
+    }
+    //
+    // SENDING
+    //
+    /**
+     * Send a templated email through AWS Simple Email Service.
+     */
+    async sendTemplatedEmail(emailData, sesParams) {
+        const command = new AWSSES.SendEmailCommand({
+            Destination: this.prepareEmailDestination(emailData),
+            Content: {
+                Template: {
+                    TemplateName: emailData.template,
+                    TemplateData: JSON.stringify(emailData.templateData ?? {})
+                }
+            },
+            ConfigurationSetName: emailData.configurationSet,
+            ReplyToAddresses: emailData.replyToAddresses,
+            FromEmailAddress: sesParams.sourceName ? `${sesParams.sourceName} <${sesParams.source}>` : sesParams.source,
+            FromEmailAddressIdentityArn: sesParams.sourceArn
+        });
+        let ses;
+        if (this.ses.config.region === sesParams.region)
+            ses = this.ses;
+        else
+            ses = new AWSSES.SESv2Client({ region: sesParams.region });
+        this.logger.trace('SES send templated email');
+        return await ses.send(command);
+    }
+    /**
+     * Send an email through AWS Simple Email Service.
+     * It supports IDEA's teams custom configuration.
+     */
+    async sendEmail(emailData, sesParams) {
+        // if requested, check whether there is a custom SES configuration to apply for the team
+        const customSESConfig = await this.searchForCustomSESConfigByTeamId(sesParams.teamId);
+        // if the email includes attachments, send with Nodemailer (to avoid size limitations)
+        if (emailData.attachments?.length)
+            return await this.sendEmailWithNodemailer(emailData, customSESConfig || sesParams);
+        // otherwise, send with SES (more secure)
+        else
+            return await this.sendEmailWithSES(emailData, customSESConfig || sesParams);
+    }
+    async searchForCustomSESConfigByTeamId(teamId) {
+        if (!teamId)
+            return null;
+        try {
+            return (await new dynamoDB_1.DynamoDB().get({ TableName: 'idea_teamsSES', Key: { teamId } }));
+        }
+        catch (err) {
+            return null;
+        }
+    }
+    async sendEmailWithSES(emailData, sesParams) {
+        const command = new AWSSES.SendEmailCommand({
+            Destination: this.prepareEmailDestination(emailData),
+            Content: { Simple: this.prepareEmailMessage(emailData) },
+            ReplyToAddresses: emailData.replyToAddresses,
+            FromEmailAddress: sesParams.sourceName ? `${sesParams.sourceName} <${sesParams.source}>` : sesParams.source,
+            FromEmailAddressIdentityArn: sesParams.sourceArn
+        });
+        let ses;
+        if (this.ses.config.region === sesParams.region)
+            ses = this.ses;
+        else
+            ses = new AWSSES.SESv2Client({ region: sesParams.region });
+        this.logger.trace('SES send email');
+        return await ses.send(command);
+    }
+    async sendEmailWithNodemailer(emailData, sesParams) {
+        const mailOptions = {};
+        mailOptions.to = emailData.toAddresses.join(',');
+        if (emailData.ccAddresses)
+            mailOptions.cc = emailData.ccAddresses.join(',');
+        if (emailData.bccAddresses)
+            mailOptions.bcc = emailData.bccAddresses.join(',');
+        mailOptions.from = sesParams.sourceName ? `${sesParams.sourceName} <${sesParams.source}>` : sesParams.source;
+        if (emailData.replyToAddresses)
+            mailOptions.replyTo = emailData.replyToAddresses.join(',');
+        mailOptions.subject = emailData.subject;
+        if (emailData.html)
+            mailOptions.html = emailData.html;
+        if (emailData.text)
+            mailOptions.text = emailData.text;
+        mailOptions.attachments = emailData.attachments;
+        // note: Nodemailer doesn't support SESv2 as of August 2023
+        const ses = new client_ses_1.SESClient({ region: sesParams.region });
+        this.logger.trace('SES send email (Nodemailer)');
+        // note: this is a workaround to make Nodemailer works with AWS SDK 3;
+        // see: https://github.com/nodemailer/nodemailer/issues/1430
+        return await (0, nodemailer_1.createTransport)({ SES: { ses, aws: { SendRawEmailCommand: client_ses_1.SendRawEmailCommand } } }).sendMail(mailOptions);
+    }
+    prepareEmailDestination(emailData) {
+        return {
+            ToAddresses: emailData.toAddresses,
+            CcAddresses: emailData.ccAddresses,
+            BccAddresses: emailData.bccAddresses
+        };
+    }
+    prepareEmailMessage(emailData) {
+        const message = {
+            Subject: { Charset: 'UTF-8', Data: emailData.subject },
+            Body: {}
+        };
+        if (emailData.html)
+            message.Body.Html = { Charset: 'UTF-8', Data: emailData.html };
+        if (emailData.text)
+            message.Body.Text = { Charset: 'UTF-8', Data: emailData.text };
+        if (!emailData.html && !emailData.text)
+            message.Body.Text = { Charset: 'UTF-8', Data: '' };
+        return message;
+    }
+}
+exports.SES = SES;

package/dist/src/sns.d.ts

@@ -0,0 +1,60 @@
+import * as AWSSNS from '@aws-sdk/client-sns';
+import { PushNotificationsPlatforms } from 'idea-toolbox';
+import { LambdaLogger } from './lambdaLogger';
+/**
+ * A wrapper for AWS Simple Notification Service.
+ */
+export declare class SNS {
+    protected client: AWSSNS.SNSClient;
+    protected logger: LambdaLogger;
+    constructor(options?: {
+        region?: string;
+    });
+    /**
+     * Create a new endpoint in the SNS platform specified.
+     * @return platform endpoint ARN
+     */
+    createPlatormEndpoint(platform: PushNotificationsPlatforms, token: string, options: SNSCreateEndpointParams): Promise<string>;
+    /**
+     * Publish a message to a SNS endpoint.
+     */
+    publish(options: SNSPublishParams): Promise<AWSSNS.PublishCommandOutput>;
+}
+/**
+ * Options for creating a SNS endpoint.
+ */
+export interface SNSCreateEndpointParams {
+    /**
+     * ARN to production of Apple's (iOS, MacOS) notification services.
+     */
+    appleArn?: string;
+    /**
+     * ARN to development of Apple's (iOS, MacOS) notification services.
+     */
+    appleDevArn?: string;
+    /**
+     * ARN to Android's notification services.
+     */
+    androidArn?: string;
+}
+/**
+ * Options to publish a message on a SNS endpoint.
+ */
+export interface SNSPublishParams {
+    /**
+     * The endpoint of the notification.
+     */
+    endpoint: string;
+    /**
+     * The message to send.
+     */
+    message?: string;
+    /**
+     * The platform receiver; used to structure the message.
+     */
+    platform?: PushNotificationsPlatforms;
+    /**
+     * If set, message and platform will be ignored and the content of this attribute will be preferred.
+     */
+    json?: any;
+}

package/dist/src/sns.js

@@ -0,0 +1,94 @@
+"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.SNS = void 0;
+const AWSSNS = __importStar(require("@aws-sdk/client-sns"));
+const idea_toolbox_1 = require("idea-toolbox");
+const lambdaLogger_1 = require("./lambdaLogger");
+/**
+ * A wrapper for AWS Simple Notification Service.
+ */
+class SNS {
+    constructor(options = {}) {
+        this.logger = new lambdaLogger_1.LambdaLogger();
+        this.client = new AWSSNS.SNSClient({ region: options.region });
+    }
+    /**
+     * Create a new endpoint in the SNS platform specified.
+     * @return platform endpoint ARN
+     */
+    async createPlatormEndpoint(platform, token, options) {
+        let platformARN;
+        switch (platform) {
+            case idea_toolbox_1.PushNotificationsPlatforms.APNS:
+                platformARN = options.appleArn;
+                break;
+            case idea_toolbox_1.PushNotificationsPlatforms.APNS_SANDBOX:
+                platformARN = options.appleDevArn;
+                break;
+            case idea_toolbox_1.PushNotificationsPlatforms.FCM:
+                platformARN = options.androidArn;
+                break;
+            default:
+                throw new Error('Unsupported platform');
+        }
+        this.logger.trace('SNS add platform endpoint');
+        const command = new AWSSNS.CreatePlatformEndpointCommand({ PlatformApplicationArn: platformARN, Token: token });
+        const { EndpointArn } = await this.client.send(command);
+        return EndpointArn;
+    }
+    /**
+     * Publish a message to a SNS endpoint.
+     */
+    async publish(options) {
+        let structuredMessage;
+        if (options.json)
+            structuredMessage = { default: JSON.stringify(options.json) };
+        else
+            switch (options.platform) {
+                case idea_toolbox_1.PushNotificationsPlatforms.APNS:
+                    structuredMessage = { APNS: JSON.stringify({ aps: { alert: options.message } }) };
+                    break;
+                case idea_toolbox_1.PushNotificationsPlatforms.APNS_SANDBOX:
+                    structuredMessage = { APNS_SANDBOX: JSON.stringify({ aps: { alert: options.message } }) };
+                    break;
+                case idea_toolbox_1.PushNotificationsPlatforms.FCM:
+                    structuredMessage = {
+                        GCM: JSON.stringify({ notification: { body: options.message, title: options.message } })
+                    };
+                    break;
+                default:
+                    throw new Error('Unsupported platform');
+            }
+        this.logger.trace('SNS publish in topic');
+        const command = new AWSSNS.PublishCommand({
+            MessageStructure: 'json',
+            Message: JSON.stringify(structuredMessage),
+            TargetArn: options.endpoint
+        });
+        return await this.client.send(command);
+    }
+}
+exports.SNS = SNS;

package/dist/src/ssm.d.ts

@@ -0,0 +1,22 @@
+import * as AWSSystemsManager from '@aws-sdk/client-ssm';
+/**
+ * A wrapper for AWS Systems Manager (SSM).
+ */
+export declare class SystemsManager {
+    protected ssm: AWSSystemsManager.SSMClient;
+    protected cache: Map<string, string>;
+    constructor();
+    /**
+     * Get a parameter by its name (path).
+     */
+    getParameterByName(name: string, options?: {
+        noCache?: boolean;
+        withDecryption?: boolean;
+    }): Promise<string>;
+    /**
+     * Get a parameter (with decryption) by its name (path).
+     */
+    getSecretByName(name: string, options?: {
+        noCache?: boolean;
+    }): Promise<string>;
+}

package/dist/src/ssm.js

@@ -0,0 +1,54 @@
+"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.SystemsManager = void 0;
+const AWSSystemsManager = __importStar(require("@aws-sdk/client-ssm"));
+/**
+ * A wrapper for AWS Systems Manager (SSM).
+ */
+class SystemsManager {
+    constructor() {
+        this.cache = new Map();
+        this.ssm = new AWSSystemsManager.SSMClient();
+    }
+    /**
+     * Get a parameter by its name (path).
+     */
+    async getParameterByName(name, options = {}) {
+        if (!options.noCache && this.cache.has(name))
+            return this.cache.get(name);
+        const command = new AWSSystemsManager.GetParameterCommand({ Name: name, WithDecryption: options.withDecryption });
+        const { Parameter } = await this.ssm.send(command);
+        this.cache.set(name, Parameter.Value);
+        return Parameter.Value;
+    }
+    /**
+     * Get a parameter (with decryption) by its name (path).
+     */
+    async getSecretByName(name, options = {}) {
+        return this.getParameterByName(name, { ...options, withDecryption: true });
+    }
+}
+exports.SystemsManager = SystemsManager;

package/dist/src/streamController.d.ts

@@ -0,0 +1,11 @@
+import { DynamoDBRecord } from 'aws-lambda';
+import { GenericController } from './genericController';
+/**
+ * An abstract class to inherit to manage AWS DDB streams in an AWS Lambda function.
+ */
+export declare abstract class StreamController extends GenericController {
+    records: any[];
+    constructor(event: any, callback: any);
+    protected abstract handleRecord(record: DynamoDBRecord): Promise<void>;
+    handleRequest(): Promise<void>;
+}

package/dist/src/streamController.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StreamController = void 0;
+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) {
+        super(event, callback);
+        this.records = event.Records ?? [];
+    }
+    async handleRequest() {
+        this.logger.info('START', { streamOfRecords: this.records.length ?? 0 });
+        await Promise.all(this.records.map(record => this.handleRecord(record)))
+            .then(() => this.done())
+            .catch((err) => this.done(this.handleControllerError(err, 'STREAM-ERROR', 'Operation failed')));
+    }
+}
+exports.StreamController = StreamController;

package/dist/src/translate.d.ts

@@ -0,0 +1,61 @@
+import * as AWSTranslate from '@aws-sdk/client-translate';
+import { Languages, PDFEntity, PDFTemplateSection } from 'idea-toolbox';
+/**
+ * A wrapper for Amazon Translate.
+ */
+export declare class Translate {
+    protected translate: AWSTranslate.TranslateClient;
+    /**
+     * Default input language code.
+     */
+    sourceLanguageCode: string;
+    /**
+     * Default output language code.
+     */
+    targetLanguageCode: string;
+    /**
+     * Default terminology list.
+     */
+    terminologyNames: string[];
+    /**
+     * Initialize a new Translate helper object.
+     */
+    constructor(options?: {
+        region?: string;
+    });
+    /**
+     * Translates input text from the source language to the target language.
+     * @param params the parameters for translateText
+     */
+    text(params: TranslateParameters): Promise<string>;
+    /**
+     * 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).
+     */
+    pdfTemplate(entity: PDFEntity, template: PDFTemplateSection[], language: string, languages: Languages): Promise<Record<string, string>>;
+    /**
+     * Analyse a PDFTemplate to extract terms to translate based on a PDFEntity (using a sourceLanguage as reference).
+     */
+    protected analysePDFTemplateForTermsToTranslate(template: PDFTemplateSection[], entity: PDFEntity, sourceLanguage: string): Promise<Set<string>>;
+}
+export interface TranslateParameters {
+    /**
+     * The text to translate. Required.
+     * The text string can be a maximum of 5,000 bytes long; depending on the char set, it may be fewer than 5,000 chars.
+     */
+    text: string;
+    /**
+     * The input language.
+     */
+    sourceLanguageCode?: string;
+    /**
+     * The output language.
+     */
+    targetLanguageCode?: string;
+    /**
+     * The name of the terminology list file to be used in the TranslateText request.
+     * Terminology lists can contain a maximum of 256 terms.
+     */
+    terminologyNames?: string[];
+}

package/dist/src/translate.js

@@ -0,0 +1,155 @@
+"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.Translate = void 0;
+const AWSTranslate = __importStar(require("@aws-sdk/client-translate"));
+const idea_toolbox_1 = require("idea-toolbox");
+/**
+ * A wrapper for Amazon Translate.
+ */
+class Translate {
+    /**
+     * Initialize a new Translate helper object.
+     */
+    constructor(options = {}) {
+        /**
+         * Default input language code.
+         */
+        this.sourceLanguageCode = 'en';
+        /**
+         * Default output language code.
+         */
+        this.targetLanguageCode = 'en';
+        /**
+         * Default terminology list.
+         */
+        this.terminologyNames = [];
+        this.translate = new AWSTranslate.TranslateClient({ region: options.region });
+    }
+    /**
+     * 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 command = new AWSTranslate.TranslateTextCommand({
+            Text: params.text,
+            SourceLanguageCode: this.sourceLanguageCode,
+            TargetLanguageCode: this.targetLanguageCode,
+            TerminologyNames: this.terminologyNames
+        });
+        const { TranslatedText } = await this.translate.send(command);
+        return 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;