@clairejs/server 3.15.2 → 3.16.0

package/dist/job/decorators.js

@@ -0,0 +1,57 @@
+import { Errors, initObjectMetadata } from "@clairejs/core";
+export const IntervalJob = (
+/**
+ * Unique name of job
+ */
+jobName, 
+/**
+ * Interval duration in second
+ */
+interval) => (prototype, propertyKey) => {
+    const metadata = initObjectMetadata(prototype);
+    if (!metadata.jobs) {
+        metadata.jobs = [];
+    }
+    metadata.jobs.push({
+        jobName,
+        interval,
+        handlerName: propertyKey,
+    });
+};
+export const CronJob = (
+/**
+ * Unique name of job
+ */
+jobName, 
+/**
+ * Cron expression
+ */
+cron) => (prototype, propertyKey) => {
+    const metadata = initObjectMetadata(prototype);
+    if (!metadata.jobs) {
+        metadata.jobs = [];
+    }
+    //-- validate cron
+    if (cron.split(" ").length !== 5) {
+        throw Errors.SYSTEM_ERROR("Invalid cron expression, expect minute / hour / day / month / day-of-week");
+    }
+    metadata.jobs.push({
+        jobName,
+        cron,
+        handlerName: propertyKey,
+    });
+};
+export const CustomJob = (
+/**
+ * Unique name of job
+ */
+jobName) => (prototype, propertyKey) => {
+    const metadata = initObjectMetadata(prototype);
+    if (!metadata.jobs) {
+        metadata.jobs = [];
+    }
+    metadata.jobs.push({
+        jobName,
+        handlerName: propertyKey,
+    });
+};

package/dist/job/interfaces.js

@@ -0,0 +1,10 @@
+export const INTERVAL_REQUEST_METHOD = "interval";
+export const CRON_REQUEST_METHOD = "cron";
+export var JobInterval;
+(function (JobInterval) {
+    JobInterval[JobInterval["EVERY_5S"] = 5] = "EVERY_5S";
+    JobInterval[JobInterval["EVERY_10S"] = 10] = "EVERY_10S";
+    JobInterval[JobInterval["EVERY_15S"] = 15] = "EVERY_15S";
+    JobInterval[JobInterval["EVERY_20S"] = 20] = "EVERY_20S";
+    JobInterval[JobInterval["EVERY_30S"] = 30] = "EVERY_30S";
+})(JobInterval || (JobInterval = {}));

package/dist/logging/FileLogMedium.js

@@ -0,0 +1,44 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var FileLogMedium_1;
+import fs from "fs";
+import path from "path";
+import { LogLevel, Initable } from "@clairejs/core";
+let FileLogMedium = FileLogMedium_1 = class FileLogMedium {
+    static levels = Object.values(LogLevel);
+    destination;
+    separated;
+    constructor(config) {
+        const paths = config.separated
+            ? FileLogMedium_1.levels.map((level) => path.join(config.destination, level + ".log"))
+            : [config.destination];
+        //-- open files and let the OS close the file(s)
+        this.destination = paths.map((p) => {
+            if (!fs.existsSync(path.dirname(p))) {
+                fs.mkdirSync(path.dirname(p), { recursive: true });
+            }
+            return fs.openSync(p, "a");
+        });
+        this.separated = !!config.separated;
+    }
+    async init() { }
+    exit() {
+        this.destination.forEach((dest) => fs.closeSync(dest));
+    }
+    write(level, content) {
+        const fd = this.separated ? this.destination[FileLogMedium_1.levels.indexOf(level)] : 0;
+        fs.appendFileSync(fd, content);
+    }
+};
+FileLogMedium = FileLogMedium_1 = __decorate([
+    Initable(),
+    __metadata("design:paramtypes", [Object])
+], FileLogMedium);
+export { FileLogMedium };

package/dist/services/AbstractFileService.js

@@ -0,0 +1,28 @@
+import { FileOperation } from "../common/FileOperation";
+const delay = (timeMs) => new Promise((resolve) => setTimeout(resolve, timeMs));
+export class AbstractFileService {
+    async getUploadUrlForTempUri(temporaryUri) {
+        const getPutUrl = async () => {
+            const result = await this.getPresignedUrl(FileOperation.PUT, [temporaryUri]);
+            return result[0];
+        };
+        const getDeleteUrl = async () => {
+            const result = await this.getPresignedUrl(FileOperation.DELETE, [temporaryUri]);
+            return result[0];
+        };
+        let result = {
+            objectKey: temporaryUri,
+            putPresignedUrl: await getPutUrl(),
+            deletePresignedUrl: await getDeleteUrl(),
+        };
+        while (result.putPresignedUrl.endsWith("/")) {
+            await delay(1000);
+            result.putPresignedUrl = await getPutUrl();
+        }
+        while (result.deletePresignedUrl.endsWith("/")) {
+            await delay(1000);
+            result.deletePresignedUrl = await getDeleteUrl();
+        }
+        return result;
+    }
+}

package/dist/services/AbstractMailService.js

@@ -0,0 +1,2 @@
+export class AbstractMailService {
+}

package/dist/services/AbstractService.js

@@ -0,0 +1,3 @@
+import { Transactionable } from "../common/Transactionable";
+export class AbstractService extends Transactionable {
+}

package/dist/services/AbstractSmsService.js

@@ -0,0 +1,2 @@
+export class AbstractSmsService {
+}

package/dist/services/implementations/LocalFileService.js

@@ -0,0 +1,42 @@
+import axios from "axios";
+import { FileOperation } from "../../common/FileOperation";
+import { AbstractFileService } from "../AbstractFileService";
+export class LocalFileService extends AbstractFileService {
+    fileServerUrl;
+    constructor(fileServerUrl) {
+        super();
+        this.fileServerUrl = fileServerUrl;
+    }
+    async getFileSize(objectKeys) {
+        const fileInfo = Promise.all(objectKeys.map(async (uri) => {
+            const response = await axios.head(`${this.fileServerUrl}/info?objectKey="/${uri}"`);
+            return response.data?.size || 0;
+        }));
+        return fileInfo;
+    }
+    async getAccessUrls(uris, _isPublic) {
+        return uris.map((key) => `${this.fileServerUrl}/${key}`);
+    }
+    async getPresignedUrl(operation, uris) {
+        if (operation === FileOperation.GET) {
+            return this.getAccessUrls(uris, true);
+        }
+        return uris.map((uri) => `${this.fileServerUrl}/?objectKey="/${uri}"`);
+    }
+    async moveObject(uris) {
+        await Promise.all(uris.map((uri) => axios.post(`${this.fileServerUrl}/`, {
+            from: uri.fromURI,
+            to: uri.toURI,
+        })));
+    }
+    async copyObject(uris) {
+        await Promise.all(uris.map((uri) => axios.post(`${this.fileServerUrl}/`, {
+            from: uri.fromURI,
+            to: uri.toURI,
+            copy: true,
+        })));
+    }
+    async removeObject(uris) {
+        await Promise.all(uris.map((uri) => axios.delete(`${this.fileServerUrl}/?objectKey="/${uri}"`)));
+    }
+}

package/dist/services/implementations/LocalMailService.js

@@ -0,0 +1,27 @@
+import fs from "fs";
+import path from "path";
+import { AbstractMailService } from "../AbstractMailService";
+export class LocalMailService extends AbstractMailService {
+    folderPath;
+    constructor(folderPath) {
+        super();
+        this.folderPath = folderPath;
+        if (!fs.existsSync(this.folderPath)) {
+            fs.mkdirSync(folderPath, { recursive: true });
+        }
+    }
+    async send(email) {
+        //-- write email to local folder
+        const mailFilePath = path.join(this.folderPath, `${Date.now()}.html`);
+        fs.writeFileSync(mailFilePath, `
+                From: ${email.sender}\n
+                To: ${email.receivers.join(", ")}\n
+                Cc: ${(email.cc || []).join(", ")}\n
+                Bcc: ${(email.bcc || []).join(", ")}\n
+
+                Subject: ${email.subject}\n
+                Content: ${email.contentType}\n
+                ${email.content}
+            `.trim());
+    }
+}

package/dist/services/implementations/LocalSmsService.js

@@ -0,0 +1,17 @@
+import fs from "fs";
+import path from "path";
+import { AbstractSmsService } from "../AbstractSmsService";
+export class LocalSmsService extends AbstractSmsService {
+    folderPath;
+    constructor(folderPath) {
+        super();
+        this.folderPath = folderPath;
+        if (!fs.existsSync(this.folderPath)) {
+            fs.mkdirSync(this.folderPath, { recursive: true });
+        }
+    }
+    async send(fromNumber, toNumber, content) {
+        const filePath = path.join(this.folderPath, `${Date.now()}`);
+        fs.writeFileSync(filePath, `${fromNumber}-${toNumber}: ${content}\n`);
+    }
+}

package/dist/services/implementations/S3FileService.js

@@ -0,0 +1,107 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { AbstractLogger, LogContext } from "@clairejs/core";
+import aws from "aws-sdk";
+import { AbstractFileService } from "../AbstractFileService";
+let S3FileService = class S3FileService extends AbstractFileService {
+    config;
+    logger;
+    s3Client;
+    cloudfrontSigner;
+    constructor(config, logger) {
+        super();
+        this.config = config;
+        this.logger = logger;
+        this.s3Client = new aws.S3({
+            signatureVersion: "v4",
+            region: this.config.S3_BUCKET_REGION,
+        });
+        this.cloudfrontSigner = new aws.CloudFront.Signer(this.config.CLOUD_FRONT_PUBLIC_KEY_ID, Buffer.from(this.config.CLOUD_FRONT_PRIVATE_KEY_BASE64, "base64").toString());
+    }
+    async getFileSize(objectKeys) {
+        return await Promise.all(objectKeys.map((uri) => this.getSingleFileSize(uri)));
+    }
+    async getAccessUrls(uris, isPublic) {
+        return uris.map((uri) => this.getSingleAccessUrl(uri, isPublic));
+    }
+    async getPresignedUrl(operation, uris) {
+        return uris.map((uri) => this.getSinglePresignedUrl(operation, uri));
+    }
+    async moveObject(uris) {
+        await Promise.all(uris.map((uri) => this.moveSingleObject(uri.fromURI, uri.toURI)));
+    }
+    async copyObject(uris) {
+        await Promise.all(uris.map((uri) => this.copySingleObject(uri.fromURI, uri.toURI)));
+    }
+    async removeObject(uris) {
+        await Promise.all(uris.map((uri) => this.removeSingleObject(uri)));
+    }
+    async getSingleFileSize(objectKey) {
+        const size = await this.s3Client
+            .headObject({ Key: objectKey, Bucket: this.config.S3_BUCKET_NAME })
+            .promise()
+            .then((res) => res.ContentLength);
+        return size || 0;
+    }
+    getSinglePresignedUrl(_operation, objectKey) {
+        return this.cloudfrontSigner.getSignedUrl({
+            url: `${this.config.CLOUD_FRONT_PUBLIC_DOMAIN}/${objectKey}`,
+            expires: Date.now() + 3600000,
+        });
+    }
+    async copySingleObject(fromObjectKey, toObjectKey) {
+        try {
+            await this.s3Client
+                .copyObject({
+                Bucket: this.config.S3_BUCKET_NAME,
+                CopySource: `/${this.config.S3_BUCKET_NAME}/${fromObjectKey}`,
+                Key: toObjectKey,
+            })
+                .promise();
+        }
+        catch (err) {
+            this.logger.error(err);
+            throw err;
+        }
+    }
+    async moveSingleObject(fromObjectKey, toObjectKey) {
+        try {
+            await this.copySingleObject(fromObjectKey, toObjectKey);
+            await this.removeSingleObject(fromObjectKey);
+        }
+        catch (err) {
+            this.logger.error(err);
+            throw err;
+        }
+    }
+    getSingleAccessUrl(objectKey, isPublic) {
+        const url = `${this.config.CLOUD_FRONT_PUBLIC_DOMAIN}/${objectKey}`;
+        if (isPublic) {
+            return url;
+        }
+        return this.cloudfrontSigner.getSignedUrl({
+            url,
+            expires: Date.now() + this.config.PRESIGNED_URL_EXPIRATION_S * 1000,
+        });
+    }
+    async removeSingleObject(objectKey) {
+        await this.s3Client
+            .deleteObject({
+            Bucket: this.config.S3_BUCKET_NAME,
+            Key: objectKey,
+        })
+            .promise();
+    }
+};
+S3FileService = __decorate([
+    LogContext(),
+    __metadata("design:paramtypes", [Object, AbstractLogger])
+], S3FileService);
+export { S3FileService };

package/dist/services/implementations/SesMailService.js

@@ -0,0 +1,64 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { AbstractLogger, Errors, LogContext } from "@clairejs/core";
+import aws from "aws-sdk";
+import { AbstractMailService } from "../AbstractMailService";
+let SesMailService = class SesMailService extends AbstractMailService {
+    config;
+    logger;
+    emailClient;
+    constructor(config, logger) {
+        super();
+        this.config = config;
+        this.logger = logger;
+        this.emailClient = new aws.SES({ apiVersion: "2010-12-01", region: this.config.SES_REGION });
+    }
+    async send(email) {
+        try {
+            const param = {
+                Destination: {
+                    BccAddresses: email.bcc,
+                    CcAddresses: email.cc,
+                    ToAddresses: email.receivers,
+                },
+                Message: {
+                    Body: {},
+                    Subject: {
+                        Charset: "UTF-8",
+                        Data: email.subject,
+                    },
+                },
+                Source: email.sender,
+            };
+            if (email.contentType === "html") {
+                param.Message.Body.Html = {
+                    Charset: "UTF-8",
+                    Data: email.content,
+                };
+            }
+            else if (email.contentType === "text") {
+                param.Message.Body.Text = {
+                    Charset: "UTF-8",
+                    Data: email.content,
+                };
+            }
+            await this.emailClient.sendEmail(param).promise();
+        }
+        catch (err) {
+            this.logger.error(err);
+            throw Errors.SYSTEM_ERROR("Cannot send email");
+        }
+    }
+};
+SesMailService = __decorate([
+    LogContext(),
+    __metadata("design:paramtypes", [Object, AbstractLogger])
+], SesMailService);
+export { SesMailService };

package/dist/socket/AbstractServerSocket.js

@@ -0,0 +1,44 @@
+import { MessageType } from "@clairejs/core";
+export class AbstractServerSocket {
+    socketInfo;
+    constructor(socketInfo) {
+        this.socketInfo = socketInfo;
+    }
+    getId() {
+        return this.socketInfo.id;
+    }
+    getAuthInfo() {
+        return this.socketInfo.authInfo;
+    }
+    async send(data, channel) {
+        if (channel) {
+            //-- check if socket is allowed to receive data from channel
+            if (this.socketInfo.channels.find((c) => c.name === channel && c.serverToClientAllowed)) {
+                await this.sendRaw({
+                    type: MessageType.PLAIN,
+                    data: { message: data, channel },
+                });
+            }
+        }
+        else {
+            await this.sendRaw({
+                type: MessageType.PLAIN,
+                data: {
+                    message: data,
+                },
+            });
+        }
+    }
+    async sendRaw(data) {
+        await this.physicSend(data);
+    }
+    removeChannels(channels) {
+        this.socketInfo.channels = this.socketInfo.channels.filter((c) => !channels.includes(c.name));
+    }
+    addChannels(channelInfos) {
+        this.socketInfo.channels.push(...channelInfos);
+    }
+    getChannelsInfo() {
+        return this.socketInfo.channels;
+    }
+}

package/dist/socket/AbstractServerSocketManager.d.ts

@@ -39,7 +39,7 @@ export declare abstract class AbstractServerSocketManager {
     removeSocketFromChannel(socketId: string, channels: string[], persist?: boolean): Promise<void>;
     abstract getSocketsByChannel(channel: string): Promise<IServerSocket[]>;
     abstract broadcastToChannel(channel: string, data: any): Promise<void>;
-    removeSocket(socketId: string, physicRemove?: boolean): Promise<void>;
+    removeSocket(socketId: string, _physicRemove?: boolean): Promise<void>;
     abstract getById(socketId: string): Promise<AbstractServerSocket | undefined>;
     handle(socketData: SocketData): Promise<void>;
     getMountedEndpointInfo(): Promise<MountedEndpointInfo[]>;