@simplysm/sd-cli 10.0.4 → 10.0.22

package/dist/sd-service-server/src/SdServiceServer.mjs

@@ -0,0 +1,513 @@
+import https from "https";
+import http from "http";
+import url from "url";
+import path from "path";
+import { FsUtil, Logger } from "@simplysm/sd-core-node";
+import { EventEmitter } from "events";
+import { DateTime, JsonConvert, Wait } from "@simplysm/sd-core-common";
+import { WebSocket, WebSocketServer } from "ws";
+import mime from "mime";
+import { ApiServiceError } from "./ApiServiceError";
+export class SdServiceServer extends EventEmitter {
+    constructor(options) {
+        super();
+        this.options = options;
+        this._logger = Logger.get(["simplysm", "sd-service", this.constructor.name]);
+        this.isOpen = false;
+        this._splitReqCache = new Map();
+        this._eventListeners = [];
+        // public devMiddlewares?: NextHandleFunction[];
+        /***
+         * 경로 프록시 (브라우저에 입력된 경로를 기본 파일경로가 아닌 다른 파일경로로 바꾸어 리턴함)
+         *
+         * * from: 서버내 'www' 이후의 상대경로 (절대경로 입력 불가)
+         * * to: 서버내 파일의  절대경로 혹은 DEVSERVER의 port
+         * * 'from'에 'api'로 시작하는 경로 사용 불가
+         *
+         */
+        this.pathProxy = {};
+    }
+    async getWsClientAsync(socketId) {
+        try {
+            await Wait.until(() => {
+                if (!this._wsServer)
+                    return false;
+                const wsClients = Array.from(this._wsServer.clients).filter((item) => item.readyState === WebSocket.OPEN && item["id"] === socketId);
+                if (wsClients.length > 1) {
+                    this._logger.debug("클라이언트 중복: " + socketId + ": " + wsClients.length + "\n" + wsClients.map((item) => "  - " + item["connectedAtDateTime"].toFormatString("yyyy:MM:dd HH:mm:ss.fff")).join("\n"));
+                    return true;
+                }
+                else {
+                    return wsClients.length === 1;
+                }
+            }, 500, 1000);
+            return Array.from(this._wsServer.clients).single((item) => item.readyState === WebSocket.OPEN && item["id"] === socketId);
+        }
+        catch (err) {
+            this._logger.error("소켓요청을 처리하는 중에 클라이언트 소켓이 끊김", err);
+            return undefined;
+        }
+    }
+    async listenAsync() {
+        await new Promise(async (resolve) => {
+            this._logger.debug("서버 시작..." + process.env["SD_VERSION"]);
+            if (this.options.ssl) {
+                const pfx = typeof this.options.ssl.pfxBuffer === "function" ? await this.options.ssl.pfxBuffer() : this.options.ssl.pfxBuffer;
+                this._httpServer = https.createServer({
+                    pfx,
+                    passphrase: this.options.ssl.passphrase,
+                });
+            }
+            else {
+                this._httpServer = http.createServer();
+            }
+            this._httpServer.on("request", async (req, res) => {
+                await this._onWebRequestAsync(req, res);
+            });
+            this._wsServer = new WebSocketServer({ server: this._httpServer });
+            this._wsServer.on("connection", async (wsClient) => {
+                wsClient["isAlive"] = true;
+                wsClient.on("pong", () => {
+                    wsClient["isAlive"] = true;
+                });
+                await this._onWsClientConnectionAsync(wsClient);
+            });
+            clearInterval(this._pingInterval);
+            this._pingInterval = setInterval(() => {
+                this._wsServer.clients.forEach((wsClient) => {
+                    if (wsClient["isAlive"] === false)
+                        return wsClient.terminate();
+                    wsClient["isAlive"] = false;
+                    wsClient.ping();
+                });
+            }, 10000);
+            this._httpServer.listen(this.options.port, () => {
+                resolve();
+            });
+        });
+        this.isOpen = true;
+        this._logger.debug("서버 시작됨");
+        this.emit("ready");
+    }
+    async closeAsync() {
+        clearInterval(this._pingInterval);
+        if (this._wsServer) {
+            this._wsServer.clients.forEach((client) => {
+                client.terminate();
+            });
+            await new Promise((resolve, reject) => {
+                this._wsServer.close((err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+        }
+        await new Promise((resolve, reject) => {
+            if (!this._httpServer || !this._httpServer.listening) {
+                resolve();
+                return;
+            }
+            this._httpServer.close((err) => {
+                if (err) {
+                    reject(err);
+                    return;
+                }
+                resolve();
+            });
+        });
+        this.isOpen = false;
+        this._logger.debug("서버 종료됨");
+        this.emit("close");
+    }
+    broadcastReload() {
+        this._logger.debug("서버내 모든 클라이언트 RELOAD 명령 전송");
+        this._wsServer?.clients.forEach(async (wsClient) => {
+            await this._sendAsync(wsClient, { name: "client-reload" });
+        });
+    }
+    async _getWsClientIdAsync(wsClient) {
+        return await new Promise(async (resolve) => {
+            const msgFn = (msgJson) => {
+                const msg = JsonConvert.parse(msgJson);
+                if (msg.name === "client-get-id-response") {
+                    wsClient.off("message", msgFn);
+                    resolve(msg.body);
+                }
+            };
+            wsClient.on("message", msgFn);
+            await this._sendAsync(wsClient, { name: "client-get-id" });
+        });
+    }
+    async _onWsClientConnectionAsync(wsClient) {
+        const wsClientId = await this._getWsClientIdAsync(wsClient);
+        this._wsServer?.clients.forEach((client) => {
+            if (client["id"] === wsClientId) {
+                this._logger.debug("클라이언트 기존연결 끊기: " + wsClientId + ": " + client["connectedAtDateTime"].toFormatString("yyyy:MM:dd HH:mm:ss.fff"));
+                client.terminate();
+            }
+        });
+        wsClient["id"] = wsClientId;
+        wsClient["connectedAtDateTime"] = new DateTime();
+        this._logger.debug("클라이언트 연결됨: " + wsClientId + ": " + this._wsServer?.clients.size);
+        wsClient.on("close", (code) => {
+            this._onWsClientClosed(wsClientId, code);
+        });
+        wsClient.on("message", async (msgJson) => {
+            await this._onWsClientMessageAsync(wsClientId, msgJson);
+        });
+        await this._sendAsync(wsClient, { name: "connected" });
+    }
+    _onWsClientClosed(wsClientId, code) {
+        this._logger.debug("클라이언트 연결 끊김: " + wsClientId + ": " + this._wsServer?.clients.size + ": " + code);
+        // 클라이언트 창이 닫히거나 RELOAD 될때
+        if (code === 1001) {
+            this._logger.debug("닫힌 소켓의 이벤트 리스너 비우기...");
+            const disconnectedListeners = this._eventListeners.filter((item) => item.socketId === wsClientId);
+            for (const disconnectedListener of disconnectedListeners) {
+                this._eventListeners.remove(disconnectedListener);
+            }
+        }
+    }
+    async _onWsClientMessageAsync(socketId, msgJson) {
+        const msg = JsonConvert.parse(msgJson);
+        if (msg.name === "request") {
+            await this._onSocketRequestAsync(socketId, msg);
+        }
+        else if (msg.name === "request-split") {
+            await this._onSocketRequestSplitAsync(socketId, msg);
+        }
+    }
+    async _onSocketRequestAsync(socketId, req) {
+        this._logger.debug("요청 받음", req);
+        const res = await this._processSocketRequestAsync(socketId, req);
+        this._logger.debug(`응답 전송 (size: ${Buffer.from(JsonConvert.stringify(res)).length})`);
+        await this._sendAsync(socketId, res);
+    }
+    async _onSocketRequestSplitAsync(socketId, splitReq) {
+        this._logger.debug("분할요청 받음", splitReq.uuid + "(" + splitReq.index + ")");
+        const cacheInfo = this._splitReqCache.getOrCreate(splitReq.uuid, { completedSize: 0, data: [] });
+        cacheInfo.data[splitReq.index] = splitReq.body;
+        cacheInfo.completedSize += splitReq.body.length;
+        const isCompleted = cacheInfo.completedSize === splitReq.fullSize;
+        await this._sendAsync(socketId, {
+            name: "response-for-split",
+            reqUuid: splitReq.uuid,
+            completedSize: cacheInfo.completedSize
+        });
+        if (isCompleted) {
+            const req = JsonConvert.parse(cacheInfo.data.join(""));
+            await this._onSocketRequestAsync(socketId, req);
+            this._splitReqCache.delete(splitReq.uuid);
+        }
+    }
+    async _sendAsync(arg, cmd) {
+        const cmdJson = JsonConvert.stringify(cmd);
+        if (cmd.name === "response" && cmdJson.length > 1000 * 1000) {
+            const splitSize = 1000 * 100;
+            let index = 0;
+            let currSize = 0;
+            while (currSize !== cmdJson.length) {
+                const splitBody = cmdJson.substring(currSize, currSize + splitSize - 1);
+                const splitReq = {
+                    name: "response-split",
+                    reqUuid: cmd.reqUuid,
+                    fullSize: cmdJson.length,
+                    index,
+                    body: splitBody
+                };
+                const splitReqJson = JsonConvert.stringify(splitReq);
+                try {
+                    const wsClient = arg instanceof WebSocket ? arg : await this.getWsClientAsync(arg);
+                    wsClient?.send(splitReqJson);
+                }
+                catch (err) {
+                    this._logger.error("소켓요청을 처리하는 중에 클라이언트 소켓이 끊김", err);
+                }
+                currSize += splitBody.length;
+                index++;
+            }
+        }
+        else {
+            try {
+                const wsClient = arg instanceof WebSocket ? arg : await this.getWsClientAsync(arg);
+                wsClient?.send(cmdJson);
+            }
+            catch (err) {
+                this._logger.error("소켓요청을 처리하는 중에 클라이언트 소켓이 끊김", err);
+            }
+        }
+    }
+    async _runServiceMethodAsync(def) {
+        // 서비스 가져오기
+        const serviceClass = this.options.services.last((item) => item.name === def.serviceName);
+        if (!serviceClass) {
+            throw new Error(`서비스[${def.serviceName}]를 찾을 수 없습니다.`);
+        }
+        const service = new serviceClass();
+        service.server = this;
+        service.request = def.request;
+        service.socketId = def.socketId;
+        service.apiHeaders = def.apiHeaders;
+        // 메소드 가져오기
+        const method = service[def.methodName];
+        if (method === undefined) {
+            throw new Error(`메소드[${def.serviceName}.${def.methodName}]를 찾을 수 없습니다.`);
+        }
+        // 실행
+        // eslint-disable-next-line @typescript-eslint/return-await
+        return await method.apply(service, def.params);
+    }
+    async _processSocketRequestAsync(socketId, req) {
+        try {
+            const cmdSplit = req.command.split(".");
+            if (cmdSplit.length === 2) {
+                const serviceName = cmdSplit[0];
+                const methodName = cmdSplit[1];
+                const result = await this._runServiceMethodAsync({
+                    socketId,
+                    request: req,
+                    serviceName,
+                    methodName,
+                    params: req.params
+                });
+                // 응답
+                return {
+                    name: "response",
+                    reqUuid: req.uuid,
+                    state: "success",
+                    body: result
+                };
+            }
+            else if (req.command === "addEventListener") {
+                const key = req.params[0];
+                const eventName = req.params[1];
+                const info = req.params[2];
+                this._eventListeners.push({ key, eventName, info, socketId });
+                return {
+                    name: "response",
+                    reqUuid: req.uuid,
+                    state: "success",
+                    body: undefined
+                };
+            }
+            else if (req.command === "removeEventListener") {
+                const key = req.params[0];
+                this._eventListeners.remove((item) => item.key === key);
+                return {
+                    name: "response",
+                    reqUuid: req.uuid,
+                    state: "success",
+                    body: undefined
+                };
+            }
+            else if (req.command === "getEventListenerInfos") {
+                const eventName = req.params[0];
+                return {
+                    name: "response",
+                    reqUuid: req.uuid,
+                    state: "success",
+                    body: this._eventListeners
+                        .filter((item) => item.eventName === eventName)
+                        .map((item) => ({ key: item.key, info: item.info }))
+                };
+            }
+            else if (req.command === "emitEvent") {
+                const targetKeys = req.params[0];
+                const data = req.params[1];
+                const listeners = this._eventListeners.filter((item) => targetKeys.includes(item.key));
+                for (const listener of listeners) {
+                    const wsClient = await this.getWsClientAsync(listener.socketId);
+                    if (wsClient?.readyState === WebSocket.OPEN) {
+                        const evtMsg = {
+                            name: "event",
+                            key: listener.key,
+                            body: data
+                        };
+                        wsClient.send(JsonConvert.stringify(evtMsg));
+                    }
+                }
+                return {
+                    name: "response",
+                    reqUuid: req.uuid,
+                    state: "success",
+                    body: undefined
+                };
+            }
+            else {
+                // 에러 응답
+                return {
+                    name: "response",
+                    reqUuid: req.uuid,
+                    state: "error",
+                    body: "요청이 잘못되었습니다."
+                };
+            }
+        }
+        catch (err) {
+            // 에러 응답
+            return {
+                name: "response",
+                reqUuid: req.uuid,
+                state: "error",
+                body: err.stack
+            };
+        }
+    }
+    async _onWebRequestAsync(req, res) {
+        try {
+            if (this.options.middlewares) {
+                for (const optMdw of this.options.middlewares) {
+                    await new Promise((resolve, reject) => {
+                        optMdw(req, res, (err) => {
+                            if (err != null) {
+                                reject(err);
+                                return;
+                            }
+                            resolve();
+                        });
+                    });
+                }
+            }
+            const urlObj = url.parse(req.url, true, false);
+            const urlPath = decodeURI(urlObj.pathname.slice(1));
+            const urlPathChain = urlPath.split("/");
+            if (urlPathChain[0] === "api") {
+                if (req.headers.origin?.includes("://localhost") && req.method === "OPTIONS") {
+                    res.writeHead(204, { "Access-Control-Allow-Origin": "*" });
+                    res.end();
+                    return;
+                }
+                const serviceName = urlPathChain[1];
+                const methodName = urlPathChain[2];
+                let params;
+                if (req.method === "GET") {
+                    if (typeof urlObj.query["json"] !== "string")
+                        throw new Error();
+                    if (req.headers["content-type"]?.toLowerCase().includes("json")) {
+                        params = JsonConvert.parse(urlObj.query["json"]);
+                    }
+                    else {
+                        params = [urlObj.query];
+                    }
+                }
+                else if (req.method === "POST") {
+                    const body = await new Promise((resolve) => {
+                        let tmp = Buffer.from([]);
+                        req.on("data", chunk => {
+                            tmp = Buffer.concat([tmp, chunk]);
+                        });
+                        req.on("end", () => {
+                            resolve(tmp);
+                        });
+                    });
+                    if (req.headers["content-type"]?.toLowerCase().includes("json")) {
+                        params = JsonConvert.parse(body.toString());
+                    }
+                    else {
+                        params = [body.toString()];
+                    }
+                }
+                if (params) {
+                    const serviceResult = await this._runServiceMethodAsync({
+                        serviceName,
+                        methodName,
+                        params,
+                        apiHeaders: req.headers
+                    });
+                    const result = req.headers["content-type"]?.toLowerCase().includes("json") ? JsonConvert.stringify(serviceResult) : serviceResult;
+                    res.writeHead(200, {
+                        "Content-Length": Buffer.from(result).length,
+                        "Content-Type": req.headers["content-type"]?.toLowerCase()
+                    });
+                    res.end(result);
+                    return;
+                }
+            }
+            if (req.method === "GET") {
+                let targetFilePath;
+                const currPathProxyFrom = Object.keys(this.pathProxy).single((from) => urlPath.startsWith(from));
+                if (currPathProxyFrom !== undefined) {
+                    if (typeof this.pathProxy[currPathProxyFrom] === "number") {
+                        const proxyReq = http.request({
+                            port: this.pathProxy[currPathProxyFrom],
+                            path: req.url,
+                            method: req.method,
+                            headers: req.headers
+                        }, (proxyRes) => {
+                            if (proxyRes.statusCode === 404) {
+                                res.writeHead(404, { "Content-Type": "text/html" });
+                                res.end("<h1>A custom 404 page</h1>");
+                                return;
+                            }
+                            res.writeHead(proxyRes.statusCode, proxyRes.headers);
+                            proxyRes.pipe(res, { end: true });
+                        });
+                        req.pipe(proxyReq, { end: true });
+                        return;
+                    }
+                    else {
+                        targetFilePath = path.resolve(this.pathProxy[currPathProxyFrom] + urlPath.substring(currPathProxyFrom.length));
+                    }
+                }
+                else {
+                    targetFilePath = path.resolve(this.options.rootPath, "www", urlPath);
+                }
+                targetFilePath = FsUtil.exists(targetFilePath) && FsUtil.stat(targetFilePath).isDirectory() ? path.resolve(targetFilePath, "index.html") : targetFilePath;
+                if (!FsUtil.exists(targetFilePath)) {
+                    const errorMessage = "파일을 찾을 수 없습니다.";
+                    this._responseErrorHtml(res, 404, errorMessage);
+                    this._logger.warn(`[404] ${errorMessage} (${targetFilePath})`);
+                    return;
+                }
+                if (path.basename(targetFilePath).startsWith(".")) {
+                    const errorMessage = "파일을 사용할 권한이 없습니다.";
+                    this._responseErrorHtml(res, 403, errorMessage);
+                    this._logger.warn(`[403] ${errorMessage} (${targetFilePath})`);
+                    return;
+                }
+                const fileStream = FsUtil.createReadStream(targetFilePath);
+                const targetFileSize = (await FsUtil.lstatAsync(targetFilePath)).size;
+                res.setHeader("Access-Control-Allow-Origin", "*");
+                res.setHeader("Content-Length", targetFileSize);
+                res.setHeader("Content-Type", mime.getType(targetFilePath));
+                res.writeHead(200);
+                fileStream.pipe(res);
+            }
+            else {
+                const errorMessage = "요청이 잘못되었습니다.";
+                this._responseErrorHtml(res, 405, errorMessage);
+                this._logger.warn(`[405] ${errorMessage} (${req.method.toUpperCase()})`);
+                return;
+            }
+        }
+        catch (err) {
+            if (err instanceof ApiServiceError) {
+                res.writeHead(err.statusCode);
+                res.end(err.message);
+                this._logger.error(`[${err.statusCode}]\n${err.message}`, err);
+            }
+            else {
+                const errorMessage = "요청 처리중 오류가 발생하였습니다.";
+                this._responseErrorHtml(res, 405, errorMessage);
+                this._logger.error(`[405] ${errorMessage}`, err);
+            }
+        }
+    }
+    _responseErrorHtml(res, code, message) {
+        res.writeHead(code);
+        res.end(`
+<!DOCTYPE html>
+<html>
+<head>
+    <meta name="viewport" content="width=device-width, initial-scale=1">
+    <meta charset="UTF-8">
+    <title>${code}: ${message}</title>
+</head>
+<body>${code}: ${message}</body>
+</html>`);
+    }
+}
+//# sourceMappingURL=SdServiceServer.js.map

package/dist/sd-service-server/src/commons.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" />
+/// <reference types="node" />
+import { Type } from "@simplysm/sd-core-common";
+import { NextHandleFunction } from "connect";
+import { SdServiceServer } from "./SdServiceServer";
+import { ISdServiceRequest } from "@simplysm/sd-service-common";
+import * as http from "http";
+export interface ISdServiceServerOptions {
+    rootPath: string;
+    services: Type<SdServiceBase>[];
+    port: number | string;
+    middlewares?: NextHandleFunction[];
+    ssl?: {
+        pfxBuffer: Buffer | (() => (Promise<Buffer> | Buffer));
+        passphrase: string;
+    };
+}
+export declare class SdServiceBase {
+    server: SdServiceServer;
+    socketId?: string;
+    request?: ISdServiceRequest;
+    apiHeaders?: http.IncomingHttpHeaders;
+}

package/dist/sd-service-server/src/commons.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commons.js","sourceRoot":"","sources":["../../../../sd-service-server/src/commons.ts"],"names":[],"mappings":"AAiBA,MAAM,OAAO,aAAa;CAKzB"}

package/dist/sd-service-server/src/commons.mjs

@@ -0,0 +1,3 @@
+export class SdServiceBase {
+}
+//# sourceMappingURL=commons.js.map

package/dist/sd-service-server/src/index.d.ts

@@ -0,0 +1,8 @@
+export * from "./SdServiceServer";
+export * from "./commons";
+export * from "./ApiServiceError";
+export * from "./utils/SdServiceServerConfigUtil";
+export * from "./services/SdSmtpClientService";
+export * from "./services/SdOrmService";
+export * from "./services/SdCryptoService";
+export * from "./services/SdAutoUpdateService";

package/dist/sd-service-server/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../sd-service-server/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,WAAW,CAAC;AAC1B,cAAc,mBAAmB,CAAC;AAClC,cAAc,mCAAmC,CAAC;AAClD,cAAc,gCAAgC,CAAC;AAC/C,cAAc,yBAAyB,CAAC;AACxC,cAAc,4BAA4B,CAAC;AAC3C,cAAc,gCAAgC,CAAC"}

package/dist/sd-service-server/src/index.mjs

@@ -0,0 +1,9 @@
+export * from "./SdServiceServer";
+export * from "./commons";
+export * from "./ApiServiceError";
+export * from "./utils/SdServiceServerConfigUtil";
+export * from "./services/SdSmtpClientService";
+export * from "./services/SdOrmService";
+export * from "./services/SdCryptoService";
+export * from "./services/SdAutoUpdateService";
+//# sourceMappingURL=index.js.map

package/dist/sd-service-server/src/services/SdAutoUpdateService.d.ts

@@ -0,0 +1,4 @@
+import { SdServiceBase } from "../commons";
+export declare class SdAutoUpdateService extends SdServiceBase {
+    getLastVersionAsync(clientName: string, platform: string): Promise<string | undefined>;
+}

package/dist/sd-service-server/src/services/SdAutoUpdateService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdAutoUpdateService.js","sourceRoot":"","sources":["../../../../../sd-service-server/src/services/SdAutoUpdateService.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,MAAM,CAAC;AACxB,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAC3C,OAAO,EAAE,MAAM,EAAE,MAAM,wBAAwB,CAAC;AAEhD,MAAM,OAAO,mBAAoB,SAAQ,aAAa;IAC7C,KAAK,CAAC,mBAAmB,CAAC,UAAkB,EAAE,QAAgB;QACnE,IAAI;YACF,MAAM,OAAO,GAAG,MAAM,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,QAAQ,EAAE,SAAS,CAAC,CAAC,CAAC;YAC9H,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC;gBACtC,QAAQ,EAAE,IAAI;gBACd,OAAO,EAAE,IAAI,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;aACjD,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,WAAW,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC;YAEvD,OAAO,MAAM,CAAC,aAAa,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,GAAG,CAAC,IAAI,SAAS,CAAC;SACrF;QACD,OAAO,GAAG,EAAE;YACV,OAAO,SAAS,CAAC;SAClB;IACH,CAAC;CACF"}

package/dist/sd-service-server/src/services/SdAutoUpdateService.mjs

@@ -0,0 +1,20 @@
+import path from "path";
+import semver from "semver";
+import { SdServiceBase } from "../commons";
+import { FsUtil } from "@simplysm/sd-core-node";
+export class SdAutoUpdateService extends SdServiceBase {
+    async getLastVersionAsync(clientName, platform) {
+        try {
+            const updates = await FsUtil.readdirAsync(path.resolve(this.server.options.rootPath, "www", clientName, platform, "updates"));
+            const versions = updates.map((item) => ({
+                fileName: item,
+                version: path.basename(item, path.extname(item))
+            })).filter((item) => (/^[0-9.]*$/).test(item.version));
+            return semver.maxSatisfying(versions.map((item) => item.version), "*") ?? undefined;
+        }
+        catch (err) {
+            return undefined;
+        }
+    }
+}
+//# sourceMappingURL=SdAutoUpdateService.js.map

package/dist/sd-service-server/src/services/SdCryptoService.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="node" />
+import { SdServiceBase } from "../commons";
+export declare class SdCryptoService extends SdServiceBase {
+    encryptAsync(data: string | Buffer): Promise<string>;
+    encryptAesAsync(data: Buffer): Promise<string>;
+    decryptAesAsync(encText: string): Promise<Buffer>;
+}

package/dist/sd-service-server/src/services/SdCryptoService.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"SdCryptoService.js","sourceRoot":"","sources":["../../../../../sd-service-server/src/services/SdCryptoService.ts"],"names":[],"mappings":"AAAA,OAAO,MAAM,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,yBAAyB,EAAE,MAAM,oCAAoC,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,YAAY,CAAC;AAE3C,MAAM,OAAO,eAAgB,SAAQ,aAAa;IACzC,KAAK,CAAC,YAAY,CAAC,IAAqB;QAC7C,MAAM,MAAM,GAAG,CACb,MAAM,yBAAyB,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CACvG,CAAC,QAAQ,CAAC,CAAC;QACZ,IAAI,MAAM,KAAK,SAAS,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;SACvC;QAED,OAAO,MAAM,CAAC,UAAU,CAAC,QAAQ,EAAE,MAAM,CAAC,GAAG,CAAC;aAC3C,MAAM,CAAC,IAAI,CAAC;aACZ,MAAM,CAAC,KAAK,CAAC,CAAC;IACnB,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,IAAY;QACvC,MAAM,MAAM,GAAG,CACb,MAAM,yBAAyB,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CACvG,CAAC,QAAQ,CAAC,CAAC;QACZ,IAAI,MAAM,KAAK,SAAS,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;SACvC;QAED,MAAM,EAAE,GAAG,MAAM,CAAC,WAAW,CAAC,EAAE,CAAC,CAAC;QAClC,MAAM,MAAM,GAAG,MAAM,CAAC,cAAc,CAClC,aAAa,EACb,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EACvB,EAAE,CACH,CAAC;QACF,MAAM,SAAS,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;QAEtC,OAAO,CACL,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC;YAClB,GAAG;YACH,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,MAAM,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAC3D,CAAC;IACJ,CAAC;IAEM,KAAK,CAAC,eAAe,CAAC,OAAe;QAC1C,MAAM,MAAM,GAAG,CACb,MAAM,yBAAyB,CAAC,cAAc,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,QAAQ,EAAE,IAAI,CAAC,OAAO,EAAE,UAAU,CAAC,CACvG,CAAC,QAAQ,CAAC,CAAC;QACZ,IAAI,MAAM,KAAK,SAAS,EAAE;YACxB,MAAM,IAAI,KAAK,CAAC,oBAAoB,CAAC,CAAC;SACvC;QAED,MAAM,SAAS,GAAG,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;QACrC,MAAM,EAAE,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,KAAK,EAAG,EAAE,KAAK,CAAC,CAAC;QAClD,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,KAAK,CAAC,CAAC;QAC9D,MAAM,QAAQ,GAAG,MAAM,CAAC,gBAAgB,CACtC,aAAa,EACb,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,EACvB,EAAE,CACH,CAAC;QACF,MAAM,SAAS,GAAG,QAAQ,CAAC,MAAM,CAAC,aAAa,CAAC,CAAC;QAEjD,OAAO,MAAM,CAAC,MAAM,CAAC,CAAC,SAAS,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;IACtD,CAAC;CACF"}

package/dist/sd-service-server/src/services/SdCryptoService.mjs

@@ -0,0 +1,39 @@
+import crypto from "crypto";
+import { SdServiceServerConfigUtil } from "../utils/SdServiceServerConfigUtil";
+import { SdServiceBase } from "../commons";
+export class SdCryptoService extends SdServiceBase {
+    async encryptAsync(data) {
+        const config = (await SdServiceServerConfigUtil.getConfigAsync(this.server.options.rootPath, this.request?.clientName))["crypto"];
+        if (config === undefined) {
+            throw new Error("암호화 설정을 찾을 수 없습니다.");
+        }
+        return crypto.createHmac("sha256", config.key)
+            .update(data)
+            .digest("hex");
+    }
+    async encryptAesAsync(data) {
+        const config = (await SdServiceServerConfigUtil.getConfigAsync(this.server.options.rootPath, this.request?.clientName))["crypto"];
+        if (config === undefined) {
+            throw new Error("암호화 설정을 찾을 수 없습니다.");
+        }
+        const iv = crypto.randomBytes(16);
+        const cipher = crypto.createCipheriv("aes-256-cbc", Buffer.from(config.key), iv);
+        const encrypted = cipher.update(data);
+        return (iv.toString("hex") +
+            ":" +
+            Buffer.concat([encrypted, cipher.final()]).toString("hex"));
+    }
+    async decryptAesAsync(encText) {
+        const config = (await SdServiceServerConfigUtil.getConfigAsync(this.server.options.rootPath, this.request?.clientName))["crypto"];
+        if (config === undefined) {
+            throw new Error("암호화 설정을 찾을 수 없습니다.");
+        }
+        const textParts = encText.split(":");
+        const iv = Buffer.from(textParts.shift(), "hex");
+        const encryptedText = Buffer.from(textParts.join(":"), "hex");
+        const decipher = crypto.createDecipheriv("aes-256-cbc", Buffer.from(config.key), iv);
+        const decrypted = decipher.update(encryptedText);
+        return Buffer.concat([decrypted, decipher.final()]);
+    }
+}
+//# sourceMappingURL=SdCryptoService.js.map