@ingestkorea/client-sens 1.7.0 → 1.9.0

package/dist-es/commands/GetSMSResultCommand.js

@@ -1,26 +1,16 @@
-import { SensCommand } from "../models";
-import { serializeIngestkorea_restJson_GetSMSResultCommand, deserializeIngestkorea_restJson_GetSMSResultCommand, } from "../protocols/GetSMSResult";
-import { IngestkoreaError } from "@ingestkorea/util-error-handler";
-export class GetSMSResultCommand extends SensCommand {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSMSResultCommand = void 0;
+const index_js_1 = require("../models/index.js");
+const GetSMSResult_js_1 = require("../protocols/GetSMSResult.js");
+class GetSMSResultCommand extends index_js_1.SensCommand {
     constructor(input) {
         super(input);
         this.input = {
-            ...input,
+            messageId: input.messageId,
         };
-    }
-    async serialize(input, config) {
-        if (!config.serviceId.sms)
-            throw new IngestkoreaError({
-                code: 400,
-                type: "Bad Request",
-                message: "Invalid Params",
-                description: "Please Check SMS ServiceId",
-            });
-        let request = await serializeIngestkorea_restJson_GetSMSResultCommand(input, config);
-        return request;
-    }
-    async deserialize(response) {
-        let output = await deserializeIngestkorea_restJson_GetSMSResultCommand(response);
-        return output;
+        this.serializer = GetSMSResult_js_1.se_GetSMSResultCommand;
+        this.deserializer = GetSMSResult_js_1.de_GetSMSResultCommand;
     }
 }
+exports.GetSMSResultCommand = GetSMSResultCommand;

package/dist-es/commands/GetSMSStatusCommand.js

@@ -1,26 +1,19 @@
-import { SensCommand } from "../models";
-import { serializeIngestkorea_restJson_GetSMSStatusCommand, deserializeIngestkorea_restJson_GetSMSStatusCommand, } from "../protocols/GetSMSStatus";
-import { IngestkoreaError } from "@ingestkorea/util-error-handler";
-export class GetSMSStatusCommand extends SensCommand {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetSMSStatusCommand = void 0;
+const index_js_1 = require("../models/index.js");
+const GetSMSStatus_js_1 = require("../protocols/GetSMSStatus.js");
+const MAX_LIMIT = 100;
+class GetSMSStatusCommand extends index_js_1.SensCommand {
     constructor(input) {
         super(input);
         this.input = {
-            ...input,
+            requestId: input.requestId,
+            pageSize: input.pageSize ? Math.min(MAX_LIMIT, Math.max(1, input.pageSize)) : MAX_LIMIT,
+            ...(input.nextToken && { nextToken: input.nextToken }),
         };
-    }
-    async serialize(input, config) {
-        if (!config.serviceId.sms)
-            throw new IngestkoreaError({
-                code: 400,
-                type: "Bad Request",
-                message: "Invalid Params",
-                description: "Please Check SMS ServiceId",
-            });
-        let request = await serializeIngestkorea_restJson_GetSMSStatusCommand(input, config);
-        return request;
-    }
-    async deserialize(response) {
-        let output = await deserializeIngestkorea_restJson_GetSMSStatusCommand(response);
-        return output;
+        this.serializer = GetSMSStatus_js_1.se_GetSMSStatusCommand;
+        this.deserializer = GetSMSStatus_js_1.de_GetSMSStatusCommand;
     }
 }
+exports.GetSMSStatusCommand = GetSMSStatusCommand;

package/dist-es/commands/ListAlimtalkChannelsCommand.js

@@ -1,26 +1,14 @@
-import { SensCommand } from "../models";
-import { serializeIngestkorea_restJson_ListAlimtalkChannelsCommand, deserializeIngestkorea_restJson_ListAlimtalkChannelsCommand, } from "../protocols/ListAlimtalkChannels";
-import { IngestkoreaError } from "@ingestkorea/util-error-handler";
-export class ListAlimtalkChannelsCommand extends SensCommand {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListAlimtalkChannelsCommand = void 0;
+const index_js_1 = require("../models/index.js");
+const ListAlimtalkChannels_js_1 = require("../protocols/ListAlimtalkChannels.js");
+class ListAlimtalkChannelsCommand extends index_js_1.SensCommand {
     constructor(input) {
         super(input);
-        this.input = {
-            ...input,
-        };
-    }
-    async serialize(input, config) {
-        if (!config.serviceId.kakao)
-            throw new IngestkoreaError({
-                code: 400,
-                type: "Bad Request",
-                message: "Invalid Params",
-                description: "Please Check Kakao ServiceId",
-            });
-        let request = await serializeIngestkorea_restJson_ListAlimtalkChannelsCommand(input, config);
-        return request;
-    }
-    async deserialize(response) {
-        let output = await deserializeIngestkorea_restJson_ListAlimtalkChannelsCommand(response);
-        return output;
+        this.input = {};
+        this.serializer = ListAlimtalkChannels_js_1.se_ListAlimtalkChannelsCommand;
+        this.deserializer = ListAlimtalkChannels_js_1.de_ListAlimtalkChannelsCommand;
     }
 }
+exports.ListAlimtalkChannelsCommand = ListAlimtalkChannelsCommand;

package/dist-es/commands/ListAlimtalkStatusCommand.js

@@ -1,38 +1,49 @@
-import { SensCommand } from "../models";
-import { serializeIngestkorea_restJson_ListAlimtalkStatusCommand, deserializeIngestkorea_restJson_ListAlimtalkStatusCommand, } from "../protocols/ListAlimtalkStatus";
-import { IngestkoreaError } from "@ingestkorea/util-error-handler";
-import { getRequestDuration } from "./constants";
-export class ListAlimtalkStatusCommand extends SensCommand {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListAlimtalkStatusCommand = void 0;
+const index_js_1 = require("../models/index.js");
+const ListAlimtalkStatus_js_1 = require("../protocols/ListAlimtalkStatus.js");
+const constants_js_1 = require("./constants.js");
+const DURATION_LIMIT_MS = 30 * 24 * 3600000; // 30일 이내만 조회 가능
+const MAX_LIMIT = 100;
+const DEFAULT_LIMIT = 20;
+class ListAlimtalkStatusCommand extends index_js_1.SensCommand {
     constructor(input) {
+        var _a;
         super(input);
-        const { startTime, endTime } = getRequestDuration();
+        if (input.nextToken && (!input.requestStartTime || !input.requestEndTime)) {
+            throw new index_js_1.SensError({
+                code: 400,
+                type: "Bad Request",
+                message: "페이지네이션 검색 조건 불일치",
+                invalidInputs: [
+                    {
+                        type: "not-valid.args",
+                        message: "nextToken 사용 시 데이터 일관성을 위해 최초 요청 시의 옵션(requestStartTime, requestEndTime, pageSize 등)이 모두 동일하게 유지되어야 합니다.",
+                    },
+                ],
+            });
+        }
+        const defaultDuration = (0, constants_js_1.getDefaultRequestDuration)({ durationLimitMs: DURATION_LIMIT_MS });
+        const { startTimeMs, endTimeMs } = (0, constants_js_1.resolveRequestDuration)({
+            startTime: input.requestStartTime ? (0, constants_js_1.convertToUtc)(input.requestStartTime) : defaultDuration.startTime,
+            endTime: input.requestEndTime ? (0, constants_js_1.convertToUtc)(input.requestEndTime) : defaultDuration.endTime,
+        }, { durationLimitMs: DURATION_LIMIT_MS });
         this.input = {
             plusFriendId: input.plusFriendId,
-            ...(input.requestId && { requestId: input.requestId }),
-            ...(input.messageId && { messageId: input.messageId }),
+            requestStartTime: (0, constants_js_1.convertToKst)(startTimeMs),
+            requestEndTime: (0, constants_js_1.convertToKst)(endTimeMs),
+            pageSize: Math.min(MAX_LIMIT, Math.max(1, (_a = input.pageSize) !== null && _a !== void 0 ? _a : DEFAULT_LIMIT)),
             ...(input.requestStatusName && { requestStatusName: input.requestStatusName }),
             ...(input.messageStatusName && { messageStatusName: input.messageStatusName }),
+            ...(input.requestId && { requestId: input.requestId, pageSize: MAX_LIMIT }),
+            ...(input.messageId && { messageId: input.messageId }),
             ...(input.templateCode && { templateCode: input.templateCode }),
-            ...(input.to && { to: input.to.replace(/\-/gi, "") }),
-            requestStartTime: input.requestStartTime ? input.requestStartTime : startTime,
-            requestEndTime: input.requestEndTime ? input.requestEndTime : endTime,
-            pageIndex: input.pageIndex ? input.pageIndex : 0,
-            pageSize: input.pageSize && input.pageSize <= 100 ? input.pageSize : 20,
+            ...(input.to && { to: (0, constants_js_1.prettyPhoneNum)(input.to) }),
+            ...(input.nextToken && { nextToken: input.nextToken }),
         };
-    }
-    async serialize(input, config) {
-        if (!config.serviceId.kakao)
-            throw new IngestkoreaError({
-                code: 400,
-                type: "Bad Request",
-                message: "Invalid Params",
-                description: "Please Check Kakao ServiceId",
-            });
-        let request = await serializeIngestkorea_restJson_ListAlimtalkStatusCommand(input, config);
-        return request;
-    }
-    async deserialize(response) {
-        let output = await deserializeIngestkorea_restJson_ListAlimtalkStatusCommand(response);
-        return output;
+        this.serializer = ListAlimtalkStatus_js_1.se_ListAlimtalkStatusCommand;
+        this.deserializer = ListAlimtalkStatus_js_1.de_ListAlimtalkStatusCommand;
     }
 }
+exports.ListAlimtalkStatusCommand = ListAlimtalkStatusCommand;

package/dist-es/commands/ListAlimtalkTemplatesCommand.js

@@ -1,26 +1,16 @@
-import { SensCommand } from "../models";
-import { serializeIngestkorea_restJson_ListAlimtalkTemplatesCommand, deserializeIngestkorea_restJson_ListAlimtalkTemplatesCommand, } from "../protocols/ListAlimtalkTemplates";
-import { IngestkoreaError } from "@ingestkorea/util-error-handler";
-export class ListAlimtalkTemplatesCommand extends SensCommand {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListAlimtalkTemplatesCommand = void 0;
+const index_js_1 = require("../models/index.js");
+const ListAlimtalkTemplates_js_1 = require("../protocols/ListAlimtalkTemplates.js");
+class ListAlimtalkTemplatesCommand extends index_js_1.SensCommand {
     constructor(input) {
         super(input);
         this.input = {
             channelId: input.channelId,
         };
-    }
-    async serialize(input, config) {
-        if (!config.serviceId.kakao)
-            throw new IngestkoreaError({
-                code: 400,
-                type: "Bad Request",
-                message: "Invalid Params",
-                description: "Please Check Kakao ServiceId",
-            });
-        let request = await serializeIngestkorea_restJson_ListAlimtalkTemplatesCommand(input, config);
-        return request;
-    }
-    async deserialize(response) {
-        let output = await deserializeIngestkorea_restJson_ListAlimtalkTemplatesCommand(response);
-        return output;
+        this.serializer = ListAlimtalkTemplates_js_1.se_ListAlimtalkTemplatesCommand;
+        this.deserializer = ListAlimtalkTemplates_js_1.de_ListAlimtalkTemplatesCommand;
     }
 }
+exports.ListAlimtalkTemplatesCommand = ListAlimtalkTemplatesCommand;

package/dist-es/commands/ListSMSStatusCommand.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ListSMSStatusCommand = void 0;
+const index_js_1 = require("../models/index.js");
+const ListSMSStatus_js_1 = require("../protocols/ListSMSStatus.js");
+const constants_js_1 = require("./constants.js");
+const DURATION_LIMIT_MS = 30 * 24 * 3600000; // 30일 이내만 조회 가능
+const MAX_LIMIT = 100;
+const DEFAULT_LIMIT = 20;
+class ListSMSStatusCommand extends index_js_1.SensCommand {
+    constructor(input) {
+        var _a;
+        super(input);
+        if (input.nextToken && (!input.requestStartTime || !input.requestEndTime)) {
+            throw new index_js_1.SensError({
+                code: 400,
+                type: "Bad Request",
+                message: "페이지네이션 검색 조건 불일치",
+                invalidInputs: [
+                    {
+                        type: "not-valid.args",
+                        message: "nextToken 사용 시 데이터 일관성을 위해 최초 요청 시의 옵션(requestStartTime, requestEndTime, pageSize 등)이 모두 동일하게 유지되어야 합니다.",
+                    },
+                ],
+            });
+        }
+        const defaultDuration = (0, constants_js_1.getDefaultRequestDuration)({ durationLimitMs: DURATION_LIMIT_MS });
+        const { startTimeMs, endTimeMs } = (0, constants_js_1.resolveRequestDuration)({
+            startTime: input.requestStartTime ? (0, constants_js_1.convertToUtc)(input.requestStartTime) : defaultDuration.startTime,
+            endTime: input.requestEndTime ? (0, constants_js_1.convertToUtc)(input.requestEndTime) : defaultDuration.endTime,
+        }, { durationLimitMs: DURATION_LIMIT_MS });
+        this.input = {
+            requestStartTime: (0, constants_js_1.convertToKst)(startTimeMs),
+            requestEndTime: (0, constants_js_1.convertToKst)(endTimeMs),
+            pageSize: Math.min(MAX_LIMIT, Math.max(1, (_a = input.pageSize) !== null && _a !== void 0 ? _a : DEFAULT_LIMIT)),
+            ...(input.type && { type: input.type }),
+            ...(input.contentType && { contentType: input.contentType }),
+            ...(input.status && { status: input.status }),
+            ...(input.from && { from: (0, constants_js_1.prettyPhoneNum)(input.from) }),
+            ...(input.to && { to: (0, constants_js_1.prettyPhoneNum)(input.to) }),
+            ...(input.statusName && { statusName: input.statusName }),
+            ...(input.nextToken && { nextToken: input.nextToken }),
+        };
+        this.serializer = ListSMSStatus_js_1.se_ListSMSStatusCommand;
+        this.deserializer = ListSMSStatus_js_1.de_ListSMSStatusCommand;
+    }
+}
+exports.ListSMSStatusCommand = ListSMSStatusCommand;

package/dist-es/commands/SendAlimtalkCommand.js

@@ -1,46 +1,51 @@
-import { SensCommand } from "../models";
-import { serializeIngestkorea_restJson_SendAlimtalkCommand, deserializeIngestkorea_restJson_SendAlimtalkCommand, } from "../protocols/SendAlimtalk";
-import { IngestkoreaError } from "@ingestkorea/util-error-handler";
-export class SendAlimtalkCommand extends SensCommand {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendAlimtalkCommand = void 0;
+const index_js_1 = require("../models/index.js");
+const SendAlimtalk_js_1 = require("../protocols/SendAlimtalk.js");
+class SendAlimtalkCommand extends index_js_1.SensCommand {
     constructor(input) {
         super(input);
         this.input = {
-            ...input,
             plusFriendId: input.plusFriendId,
             templateCode: input.templateCode,
-            messages: resolveAlimtalkMessage(input.messages),
+            messages: resolveAlimtalkMessages(input.messages, {
+                maxRecipients: index_js_1.ALIMTALK_MAX_RECIPIENTS,
+                maxContentLength: index_js_1.ALIMTALK_MAX_CONTENT_LENGTH,
+            }),
         };
+        this.serializer = SendAlimtalk_js_1.se_SendAlimtalkCommand;
+        this.deserializer = SendAlimtalk_js_1.de_SendAlimtalkCommand;
     }
-    async serialize(input, config) {
-        if (!config.serviceId.kakao)
-            throw new IngestkoreaError({
+}
+exports.SendAlimtalkCommand = SendAlimtalkCommand;
+const resolveAlimtalkMessages = (messages, config) => {
+    if (!messages.length || messages.length > config.maxRecipients) {
+        throw new index_js_1.SensError({
+            code: 400,
+            type: "Bad Request",
+            message: "알림톡 동시 발송 범위 오류",
+            invalidInputs: [
+                {
+                    type: "not-valid.args",
+                    message: `메세지 동시 발송은 최소 1명, 최대 ${config.maxRecipients}명까지 가능합니다.`,
+                },
+            ],
+        });
+    }
+    const result = messages.map((message) => {
+        if (message.content.length > config.maxContentLength) {
+            throw new index_js_1.SensError({
                 code: 400,
                 type: "Bad Request",
-                message: "Invalid Params",
-                description: "Please Check Kakao ServiceId",
+                message: "알림톡 최대 길이 초과",
+                invalidInputs: [{ type: "not-valid.args", message: `메세지 최대 길이는 ${config.maxContentLength}글자입니다` }],
             });
-        let request = await serializeIngestkorea_restJson_SendAlimtalkCommand(input, config);
-        return request;
-    }
-    async deserialize(response) {
-        let output = await deserializeIngestkorea_restJson_SendAlimtalkCommand(response);
-        return output;
-    }
-}
-const resolveAlimtalkMessage = (messages) => {
-    const ALIMTALK_MAX = 1000;
-    const lastError = new IngestkoreaError({
-        code: 400,
-        type: "Bad Request",
-        message: "Invalid Params",
-        description: `Maximum message length is ${ALIMTALK_MAX}`,
-    });
-    const result = messages.map((message) => {
-        if (message.content.length > ALIMTALK_MAX)
-            throw lastError;
+        }
         return {
             to: message.to.replace(/\-/gi, ""),
             content: message.content,
+            useSmsFailover: message.useSmsFailover != undefined ? message.useSmsFailover : false,
             ...(message.buttons && message.buttons.length && { buttons: message.buttons }),
         };
     });

package/dist-es/commands/SendMMSCommand.js

@@ -1,119 +1,89 @@
-import { SensCommand } from "../models";
-import { serializeIngestkorea_restJson_SendMMSCommand, deserializeIngestkorea_restJson_SendMMSCommand, } from "../protocols/SendMMS";
-import { IngestkoreaError } from "@ingestkorea/util-error-handler";
-import { LMS_MAX, MMS_FILE_MAX, trimText, prettyPhoneNum, getContentLength } from "./constants";
-import { parse } from "node:path";
-import { randomUUID } from "node:crypto";
-import { readFileSync, existsSync } from "node:fs";
-export class SendMMSCommand extends SensCommand {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SendMMSCommand = void 0;
+const node_path_1 = require("node:path");
+const node_crypto_1 = require("node:crypto");
+const node_fs_1 = require("node:fs");
+const index_js_1 = require("../models/index.js");
+const SendMMS_js_1 = require("../protocols/SendMMS.js");
+const constants_1 = require("./constants");
+const SendSMSCommand_js_1 = require("./SendSMSCommand.js");
+class SendMMSCommand extends index_js_1.SensCommand {
     constructor(input) {
         super(input);
+        const content = input.content ? (0, constants_1.trimText)(input.content) : "내용없음";
+        const subject = input.subject ? (0, constants_1.trimText)(input.subject) : "제목없음";
+        const messages = (0, SendSMSCommand_js_1.resolveInputMessages)(input.messages, { defaultContent: content, defaultSubject: subject });
         this.input = {
-            ...input,
-            from: prettyPhoneNum(input.from),
-            content: resolveInputContent(input.content),
-            type: resolveInputMessageType(input.type),
-            messages: resolveInputMessages(input.messages),
-            files: resolveInputFiles(input.files),
+            from: (0, constants_1.prettyPhoneNum)(input.from),
+            content,
+            messages,
+            type: "MMS",
+            contentType: input.contentType ? input.contentType : "COMM",
+            countryCode: input.countryCode ? input.countryCode : "82",
+            subject,
+            files: (input.files || []).map((file) => {
+                return resolveSendFile(file, { maxKiB: index_js_1.MMS_MAX_SUPPORT_FILE_SIZE, supportExt: index_js_1.MMS_SUPPORT_FILE_EXTENSION });
+            }),
         };
-    }
-    async serialize(input, config) {
-        if (!config.serviceId.sms)
-            throw new IngestkoreaError({
-                code: 400,
-                type: "Bad Request",
-                message: "Invalid Params",
-                description: "Please Check SMS ServiceId",
-            });
-        let request = await serializeIngestkorea_restJson_SendMMSCommand(input, config);
-        return request;
-    }
-    async deserialize(response) {
-        let output = await deserializeIngestkorea_restJson_SendMMSCommand(response);
-        return output;
+        this.serializer = SendMMS_js_1.se_SendMMSCommand;
+        this.deserializer = SendMMS_js_1.de_SendMMSCommand;
     }
 }
-const resolveInputContent = (content) => {
-    const resolvedContent = trimText(content);
-    const contentLength = getContentLength(resolvedContent);
-    if (!contentLength)
-        throw new IngestkoreaError({
+exports.SendMMSCommand = SendMMSCommand;
+const resolveSendFile = (file, options) => {
+    const parsed = (0, node_path_1.parse)(file.name); // { dir, name, ext, base }
+    const ext = parsed.ext.toLocaleLowerCase();
+    if (!options.supportExt.includes(ext)) {
+        throw new index_js_1.SensError({
             code: 400,
             type: "Bad Request",
-            message: "Invalid Request",
-            description: `Please check input message`,
+            message: "지원하지 않는 확장자입니다.",
+            invalidInputs: [
+                { type: "not-valid.args", message: `${options.supportExt.join(", ")} 형식의 첨부파일만 지원합니다.` },
+            ],
         });
-    if (contentLength > LMS_MAX)
-        throw new IngestkoreaError({
+    }
+    if (file.body) {
+        const buffer = Buffer.from(file.body, "base64");
+        checkSizeLimit(buffer, options.maxKiB);
+        const hash = (0, node_crypto_1.createHash)("md5").update(buffer).digest("hex");
+        return {
+            name: (0, node_path_1.format)({ name: hash, ext }),
+            body: file.body,
+        };
+    }
+    if (!(0, node_fs_1.existsSync)(file.name)) {
+        throw new index_js_1.SensError({
             code: 400,
             type: "Bad Request",
-            message: "Invalid Request",
-            description: `Maximum message length is ${LMS_MAX}bytes`,
+            message: "파일이 존재하지 않습니다.",
+            invalidInputs: [{ type: "not-valid.args", message: `${file.name} 파일이 존재하지 않습니다.` }],
         });
-    return resolvedContent;
-};
-const resolveInputMessages = (messages) => messages.map((message) => {
+    }
+    const buffer = (0, node_fs_1.readFileSync)(file.name);
+    checkSizeLimit(buffer, options.maxKiB);
+    const hash = (0, node_crypto_1.createHash)("md5").update(buffer).digest("hex");
     return {
-        to: prettyPhoneNum(message.to),
-        ...(message.content != undefined && { content: resolveInputContent(message.content) }),
-        ...(message.subject != undefined && { subject: trimText(message.subject) }),
+        name: (0, node_path_1.format)({ name: hash, ext }),
+        body: buffer.toString("base64"),
     };
-});
-const resolveInputMessageType = (type) => {
-    if (type == "SMS" || type == "LMS")
-        throw new IngestkoreaError({
-            code: 400,
-            type: "Bad Request",
-            message: "Invalid Request",
-            description: `Please Call SendSMSCommand`,
-        });
-    return "MMS";
 };
-const resolveInputFiles = (files) => {
-    if (!files.length)
-        throw new IngestkoreaError({
+const checkSizeLimit = (buffer, maxKiB) => {
+    const byteSize = buffer.length;
+    const kibSize = Math.ceil(byteSize / 1024);
+    if (kibSize > maxKiB) {
+        throw new index_js_1.SensError({
             code: 400,
             type: "Bad Request",
-            message: "Invalid Request",
-            description: `Please Check Input Files`,
+            message: `최대 첨부가능 용량이 초과되었습니다.`,
+            invalidInputs: [
+                {
+                    type: "not-valid.args",
+                    message: `최대 ${maxKiB}KiB까지 전송 가능합니다. 현재 ${kibSize}KiB`,
+                },
+            ],
         });
-    const output = files.map((file) => {
-        const resolvedFileName = verifyFileName(file.name);
-        const resolvedFileBody = file.body != undefined ? file.body : getFileBody(file.name);
-        let byte = Buffer.from(resolvedFileBody, "base64").length;
-        let kib = Math.ceil(byte / 1024);
-        if (kib > MMS_FILE_MAX)
-            throw new IngestkoreaError({
-                code: 400,
-                type: "Bad Request",
-                message: "Invalid Request",
-                description: `Input File is ${kib}KiByte. Maximum File Size is ${MMS_FILE_MAX}Kibyte`,
-            });
-        return { name: resolvedFileName, body: resolvedFileBody };
-    });
-    return output;
-};
-const verifyFileName = (fileName) => {
-    let { ext } = parse(fileName);
-    const uuid = randomUUID();
-    const extension = ext.replace(/jpeg|jpg/gi, "jpg");
-    if (extension != ".jpg")
-        throw new IngestkoreaError({
-            code: 400,
-            type: "Bad Request",
-            message: "Invalid Request",
-            description: `File Extension is not .jpg or .jpeg`,
-        });
-    return [uuid, extension].join("");
-};
-/** @returns base64 */
-const getFileBody = (fileName) => {
-    if (!existsSync(fileName))
-        throw new IngestkoreaError({
-            code: 400,
-            type: "Bad Request",
-            message: "Invalid Request",
-            description: `${fileName} does not exist.`,
-        });
-    return readFileSync(fileName, { encoding: "base64" });
+    }
+    return;
 };