@nextage/nx-frame-be 1.0.1

package/README.md

@@ -0,0 +1 @@
+### NxFrameBe Library

package/README.md.old

@@ -0,0 +1,45 @@
+isUndefined -> isNil
+
+
+npm init -y
+npm install typescript ts-node-dev express @types/express
+
+tsc init
+node_modules/typescript/bin/tsc --init
+
+npm install --save-dev @types/jest @types/supertest jest ts-jest supertest mongodb-memory-server
+
+npm install express express-validator cookie session jsonwebtoken @types/cookie-session @types/express @types/jsonwebtoken
+
+
+npm install crypto-js @types/crypto-js
+npm install lodash @types/lodash
+
+npm install async @types/async
+npm install graphql @types/graphql
+npm install lodash @types/lodash
+npm install jszip @types/jszip
+npm install node-schedule @types/node-schedule
+npm install ua-parser-js @types/ua-parser-js
+npm install uuid  @types/uuid
+npm install moment @types/moment
+npm install jzip @types/jszip
+npm install jszip @types/jszip
+npm install @types/jszip
+
+npm install mongoose @types/mongoose
+npm install sequelize @types/sequelize
+npm install updateIfCurrentPlugin
+npm install mongoose-update-if-current
+
+
+
+npm install graphql-constraint-directive
+npm install graphql-subscriptions graphql-type-json graphql-ws @types/graphql-type-json
+npm install @apollo/server @apollo/server-plugin-landing-page-graphql-playground
+npm install socket.io-client @types/socket.io @types/socket.io-client
+npm install tunnel-ssh @types/tunnel-ssh
+npm install @aws-sdk/client-ecs @aws-sdk/client-ses @aws-sdk/client-sqs sqs-consumer @types/sqs-consumer
+
+
+npm install --save-dev @types/node

package/build/app.js

@@ -0,0 +1 @@
+"use strict";

package/build/aws/aws-cluster-manager.d.ts

@@ -0,0 +1,28 @@
+import { AWSBaseConfig, AWSClusterConfig } from './aws.interfaces';
+import { AWSServiceDesiredCountOptions } from './aws.interfaces';
+export declare class AWSClusterManager {
+    private config;
+    private cluster;
+    private desiredCount;
+    private maxCount;
+    private workerJobs;
+    private currentJobs;
+    constructor({ cluster, desiredCount, maxCount, workerJobs }: AWSClusterConfig | undefined, config: AWSBaseConfig);
+    /**
+     *
+     * @param {*} service
+     * @returns
+     */
+    getRunningTasks(serviceName: string): Promise<number>;
+    /**
+     *
+     * @returns
+     */
+    updateDesiredCount(service: string, { upscale, downscale }?: AWSServiceDesiredCountOptions): Promise<boolean>;
+    /**
+     *
+     * @param {*} param0
+     * @returns
+     */
+    scaleECSService(service: string, desiredCount?: number): Promise<boolean>;
+}

package/build/aws/aws-cluster-manager.js

@@ -0,0 +1,105 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWSClusterManager = void 0;
+const client_ecs_1 = require("@aws-sdk/client-ecs");
+const common_1 = require("../common");
+class AWSClusterManager {
+    constructor({ cluster, desiredCount, maxCount, workerJobs } = { cluster: '' }, config) {
+        this.currentJobs = { pending: 0, running: 0 };
+        this.config = config || { region: 'eu-south-1' };
+        this.cluster = cluster;
+        this.desiredCount = desiredCount || 1;
+        this.maxCount = maxCount || 10;
+        this.workerJobs = workerJobs || 2;
+        common_1.APP.logger.info(`ECS manager init [cluster: ${this.cluster}]`);
+    }
+    /**
+     *
+     * @param {*} service
+     * @returns
+     */
+    getRunningTasks(serviceName) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!serviceName) {
+                common_1.APP.logger.error(`Missing service parameter to get running tasks`);
+                return 0;
+            }
+            if (!this.cluster || !serviceName) {
+                common_1.APP.logger.error(`Missing parameter to update service - cluster <${this.cluster}>, service <${serviceName}>`);
+                return 0;
+            }
+            try {
+                const ecs = new client_ecs_1.ECS(this.config);
+                const params = { cluster: this.cluster, serviceName };
+                const tasks = yield ecs.listTasks(params);
+                return (tasks.taskArns || []).length;
+            }
+            catch (err) {
+                common_1.APP.logger.error('Cannot get tasks list %o %o', err, err.stack);
+                return 0;
+            }
+        });
+    }
+    /**
+     *
+     * @returns
+     */
+    updateDesiredCount(service_1) {
+        return __awaiter(this, arguments, void 0, function* (service, { upscale, downscale } = { upscale: true, downscale: true }) {
+            if (!service) {
+                common_1.APP.logger.error(`Missing service to be updated`);
+                return false;
+            }
+            const pending = this.currentJobs.pending;
+            let desiredCount = 1;
+            const taskCount = yield this.getRunningTasks(service);
+            common_1.APP.logger.info(`There are <${taskCount}> running tasks for service <${service}>`);
+            this.desiredCount = taskCount;
+            if (pending > this.workerJobs)
+                desiredCount = Math.floor(pending / this.workerJobs);
+            if ((desiredCount === this.desiredCount) ||
+                !downscale && desiredCount < this.desiredCount ||
+                !upscale && desiredCount > this.desiredCount) {
+                common_1.APP.logger.info(`Scaling service <${service}> not needed`);
+                return false;
+            }
+            return this.scaleECSService(service, desiredCount);
+        });
+    }
+    /**
+     *
+     * @param {*} param0
+     * @returns
+     */
+    scaleECSService(service_1) {
+        return __awaiter(this, arguments, void 0, function* (service, desiredCount = 1) {
+            if (!this.cluster || !service) {
+                common_1.APP.logger.error(`Missing parameter to update service - cluster <${this.cluster}>, service <${service}>`);
+                return false;
+            }
+            common_1.APP.logger.info(`Scaling service <${service}> to desired count <${desiredCount}>`);
+            try {
+                const ecs = new client_ecs_1.ECS(this.config);
+                const params = { cluster: this.cluster, service, desiredCount: desiredCount || this.desiredCount || 1 };
+                const data = yield ecs.updateService(params);
+                this.desiredCount = desiredCount;
+                common_1.APP.logger.info(`Service <${service}> scaled to desired count <${desiredCount}>`);
+                return true;
+            }
+            catch (err) {
+                common_1.APP.logger.error('Cannot update service %o %o', err, err.stack);
+                return false;
+            }
+        });
+    }
+}
+exports.AWSClusterManager = AWSClusterManager;

package/build/aws/aws-email-manager.d.ts

@@ -0,0 +1,24 @@
+import { SendEmailCommandOutput } from '@aws-sdk/client-ses';
+import { AWSBaseConfig, AWSEmailConfig } from './aws.interfaces';
+import { AWSEmailContent, AWSEmailRecipient } from './aws.interfaces';
+export declare class AWSEmailManager {
+    private config;
+    private ses;
+    private domain?;
+    private charset;
+    constructor({ domain, charset }: AWSEmailConfig | undefined, config: AWSBaseConfig);
+    /**
+     *
+     * @param {*} source
+     * @param {*} addresses
+     * @param {*} emaildata
+     * @returns
+     */
+    sendMail(source: string, { to, cc, ccn }: AWSEmailRecipient, { body, plain, subject, charset, replyTo }: AWSEmailContent): Promise<SendEmailCommandOutput | null>;
+    /**
+     *
+     * @param {*} values
+     * @returns
+     */
+    checkAddresses(values: string | string[]): string[];
+}

package/build/aws/aws-email-manager.js

@@ -0,0 +1,57 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWSEmailManager = void 0;
+const client_ses_1 = require("@aws-sdk/client-ses");
+const common_1 = require("../common");
+class AWSEmailManager {
+    constructor({ domain, charset } = {}, config) {
+        this.config = config || { region: 'eu-south-1' };
+        this.ses = new client_ses_1.SESClient(this.config);
+        this.domain = domain;
+        this.charset = charset || 'UTF-8';
+    }
+    /**
+     *
+     * @param {*} source
+     * @param {*} addresses
+     * @param {*} emaildata
+     * @returns
+     */
+    sendMail(source_1, _a, _b) {
+        return __awaiter(this, arguments, void 0, function* (source, { to, cc, ccn }, { body, plain, subject, charset, replyTo = [] }) {
+            if (!(0, common_1.isEmail)(source) || !to || !body || !subject) {
+                common_1.APP.logger.error(`Missing or wrong parameter to send email - source <${source}>, to <${to}>, body <${body}>, subject <${subject}>`);
+                return null;
+            }
+            const Charset = charset || this.charset;
+            const params = {
+                Destination: { ToAddresses: this.checkAddresses(to), CcAddresses: this.checkAddresses(cc || []) },
+                Message: { Body: {}, Subject: { Charset, Data: subject } },
+                Source: source,
+                ReplyToAddresses: this.checkAddresses(replyTo)
+            };
+            params.Message.Body[plain ? 'Text' : 'Html'] = { Charset, Data: body };
+            return this.ses.send(new client_ses_1.SendEmailCommand(params));
+        });
+    }
+    /**
+     *
+     * @param {*} values
+     * @returns
+     */
+    checkAddresses(values) {
+        if (!Array.isArray(values))
+            values = [values];
+        return values.filter(a => (0, common_1.isEmail)(a));
+    }
+}
+exports.AWSEmailManager = AWSEmailManager;

package/build/aws/aws-queue-manager.d.ts

@@ -0,0 +1,37 @@
+import { Message } from '@aws-sdk/client-sqs';
+import { AWSBaseConfig, AWSQueueConfig } from './aws.interfaces';
+export declare class AWSQueueManager {
+    private config;
+    private sqs;
+    private name;
+    private queueUrl;
+    private visibilityTimeout?;
+    private heartbeatInterval?;
+    private consumer?;
+    constructor({ name, queueUrl, visibilityTimeout, heartbeatInterval }: AWSQueueConfig, config: AWSBaseConfig);
+    /**
+     *
+     * @param messageAttributeNames
+     * @param method
+     */
+    initConsumer(messageAttributeNames?: string[], method?: Function): void;
+    /**
+     *
+     * @param {*} messageAttributeNames
+     * @param {*} method
+     * @returns
+     */
+    startConsumer(messageAttributeNames?: string[], method?: Function): void;
+    /**
+     *
+     * @param {*} message
+     * @param {*} method
+     * @returns
+     */
+    processMessage(message: Message, method?: Function): Promise<any>;
+    /**
+     *
+     * @param {*} message
+     */
+    deleteMessage(message: Message): Promise<boolean>;
+}

package/build/aws/aws-queue-manager.js

@@ -0,0 +1,100 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AWSQueueManager = void 0;
+const sqs_consumer_1 = require("sqs-consumer");
+const client_sqs_1 = require("@aws-sdk/client-sqs");
+const common_1 = require("../common");
+class AWSQueueManager {
+    constructor({ name, queueUrl, visibilityTimeout, heartbeatInterval }, config) {
+        // this.region   = region;
+        this.config = config || { region: 'eu-south-1' };
+        this.sqs = new client_sqs_1.SQS(this.config);
+        this.name = name;
+        this.queueUrl = queueUrl;
+        this.visibilityTimeout = visibilityTimeout;
+        this.heartbeatInterval = heartbeatInterval;
+    }
+    /**
+     *
+     * @param messageAttributeNames
+     * @param method
+     */
+    initConsumer(messageAttributeNames = [], method = () => { }) {
+        var _a;
+        common_1.APP.logger.info(`SQS ${this.name} consumer init`);
+        (_a = this.consumer) === null || _a === void 0 ? void 0 : _a.stop();
+        this.consumer = sqs_consumer_1.Consumer.create({
+            queueUrl: this.queueUrl,
+            messageAttributeNames,
+            visibilityTimeout: this.visibilityTimeout,
+            heartbeatInterval: this.heartbeatInterval,
+            terminateVisibilityTimeout: true,
+            shouldDeleteMessages: false, // Boolean - Default to true, if you don't want the package to delete messages from sqs set this to false
+            handleMessage: (message) => this.processMessage(message, method),
+            sqs: new client_sqs_1.SQS({ region: this.config.region })
+        });
+    }
+    /**
+     *
+     * @param {*} messageAttributeNames
+     * @param {*} method
+     * @returns
+     */
+    startConsumer(messageAttributeNames = [], method = () => { }) {
+        var _a;
+        this.initConsumer(messageAttributeNames, method);
+        (_a = this.consumer) === null || _a === void 0 ? void 0 : _a.start();
+        common_1.APP.logger.info(`SQS ${this.name} consumer started`);
+    }
+    /**
+     *
+     * @param {*} message
+     * @param {*} method
+     * @returns
+     */
+    processMessage(message_1) {
+        return __awaiter(this, arguments, void 0, function* (message, method = (message) => { return Promise.resolve(message); }) {
+            common_1.APP.logger.info(`SQS ${this.name} message ${message} received`);
+            try {
+                const res = yield method(message);
+                // if method returns a truely value then delete message from queue
+                return res ? this.deleteMessage(message) : res;
+            }
+            catch (err) {
+                common_1.APP.logger.error(`SQS ${this.name} message ${message} error: %o`, err);
+                return false;
+            }
+        });
+    }
+    /**
+     *
+     * @param {*} message
+     */
+    deleteMessage(message) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const deleteParams = {
+                    QueueUrl: this.queueUrl,
+                    ReceiptHandle: message.ReceiptHandle
+                };
+                yield this.sqs.deleteMessage(deleteParams);
+                common_1.APP.logger.info(`SQS ${this.name} message ${message} deleted`);
+                return true;
+            }
+            catch (err) {
+                common_1.APP.logger.info(`SQS ${this.name} message ${message} delete error ${err}`);
+                throw err;
+            }
+        });
+    }
+}
+exports.AWSQueueManager = AWSQueueManager;

package/build/aws/aws.interfaces.d.ts

@@ -0,0 +1,39 @@
+export interface AWSBaseConfig {
+    region?: string;
+}
+export interface AWSClusterConfig {
+    cluster: string;
+    desiredCount?: number;
+    maxCount?: number;
+    workerJobs?: number;
+}
+export interface AWSJobsData {
+    pending: number;
+    running: number;
+}
+export interface AWSServiceDesiredCountOptions {
+    upscale: boolean;
+    downscale: boolean;
+}
+export interface AWSEmailConfig {
+    domain?: string;
+    charset?: string;
+}
+export interface AWSEmailRecipient {
+    to: string | string[];
+    cc?: string | string[];
+    ccn?: string | string[];
+}
+export interface AWSEmailContent {
+    body: string;
+    subject: string;
+    plain?: boolean;
+    charset?: string;
+    replyTo?: string[];
+}
+export interface AWSQueueConfig {
+    name: string;
+    queueUrl: string;
+    visibilityTimeout?: number;
+    heartbeatInterval?: number;
+}

package/build/aws/aws.interfaces.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/aws/index.d.ts

@@ -0,0 +1,4 @@
+export * from './aws.interfaces';
+export * from './aws-cluster-manager';
+export * from './aws-email-manager';
+export * from './aws-queue-manager';

package/build/aws/index.js

@@ -0,0 +1,20 @@
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./aws.interfaces"), exports);
+__exportStar(require("./aws-cluster-manager"), exports);
+__exportStar(require("./aws-email-manager"), exports);
+__exportStar(require("./aws-queue-manager"), exports);

package/build/common/base/__test__/base.model.test.d.ts

@@ -0,0 +1 @@
+export {};