@ingestkorea/client-sens 1.5.2 → 1.6.0

package/dist-es/commands/GetAlimtalkTemplateCommand.js

@@ -1,29 +1,26 @@
-import { SensCommand } from '../models';
-import { serializeIngestkorea_restJson_GetAlimtalkTemplateCommand, deserializeIngestkorea_restJson_GetAlimtalkTemplateCommand } from '../protocols/GetAlimtalkTemplate';
-import { IngestkoreaError } from '@ingestkorea/util-error-handler';
-;
-;
+import { SensCommand } from "../models";
+import { serializeIngestkorea_restJson_GetAlimtalkTemplateCommand, deserializeIngestkorea_restJson_GetAlimtalkTemplateCommand, } from "../protocols/GetAlimtalkTemplate";
+import { IngestkoreaError } from "@ingestkorea/util-error-handler";
 export class GetAlimtalkTemplateCommand extends SensCommand {
     constructor(input) {
         super(input);
         this.input = {
-            ...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'
+                code: 400,
+                type: "Bad Request",
+                message: "Invalid Params",
+                description: "Please Check Kakao ServiceId",
             });
         let request = await serializeIngestkorea_restJson_GetAlimtalkTemplateCommand(input, config);
         return request;
     }
-    ;
     async deserialize(response) {
         let output = await deserializeIngestkorea_restJson_GetAlimtalkTemplateCommand(response);
         return output;
     }
-    ;
 }
-;

package/dist-es/commands/GetSMSResultCommand.js

@@ -1,28 +1,26 @@
-import { SensCommand } from '../models';
-import { serializeIngestkorea_restJson_GetSMSResultCommand, deserializeIngestkorea_restJson_GetSMSResultCommand } from '../protocols/GetSMSResult';
-import { IngestkoreaError } from '@ingestkorea/util-error-handler';
-;
-;
+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 {
     constructor(input) {
         super(input);
         this.input = {
-            ...input
+            ...input,
         };
     }
-    ;
     async serialize(input, config) {
         if (!config.serviceId.sms)
             throw new IngestkoreaError({
-                code: 400, type: 'Bad Request', message: 'Invalid Params', description: 'Please Check SMS ServiceId'
+                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;
     }
-    ;
 }

package/dist-es/commands/GetSMSStatusCommand.js

@@ -1,28 +1,26 @@
-import { SensCommand } from '../models';
-import { serializeIngestkorea_restJson_GetSMSStatusCommand, deserializeIngestkorea_restJson_GetSMSStatusCommand } from '../protocols/GetSMSStatus';
-import { IngestkoreaError } from '@ingestkorea/util-error-handler';
-;
-;
+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 {
     constructor(input) {
         super(input);
         this.input = {
-            ...input
+            ...input,
         };
     }
-    ;
     async serialize(input, config) {
         if (!config.serviceId.sms)
             throw new IngestkoreaError({
-                code: 400, type: 'Bad Request', message: 'Invalid Params', description: 'Please Check SMS ServiceId'
+                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;
     }
-    ;
 }

package/dist-es/commands/ListAlimtalkChannelsCommand.js

@@ -1,29 +1,26 @@
-import { SensCommand } from '../models';
-import { serializeIngestkorea_restJson_ListAlimtalkChannelsCommand, deserializeIngestkorea_restJson_ListAlimtalkChannelsCommand, } from '../protocols/ListAlimtalkChannels';
-import { IngestkoreaError } from '@ingestkorea/util-error-handler';
-;
-;
+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 {
     constructor(input) {
         super(input);
         this.input = {
-            ...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'
+                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;
     }
-    ;
 }
-;

package/dist-es/commands/ListAlimtalkTemplatesCommand.js

@@ -1,29 +1,26 @@
-import { SensCommand } from '../models';
-import { serializeIngestkorea_restJson_ListAlimtalkTemplatesCommand, deserializeIngestkorea_restJson_ListAlimtalkTemplatesCommand } from '../protocols/ListAlimtalkTemplates';
-import { IngestkoreaError } from '@ingestkorea/util-error-handler';
-;
-;
+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 {
     constructor(input) {
         super(input);
         this.input = {
-            ...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'
+                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;
     }
-    ;
 }
-;

package/dist-es/commands/SendAlimtalkCommand.js

@@ -1,8 +1,6 @@
-import { SensCommand } from '../models';
-import { serializeIngestkorea_restJson_SendAlimtalkCommand, deserializeIngestkorea_restJson_SendAlimtalkCommand } from '../protocols/SendAlimtalk';
-import { IngestkoreaError } from '@ingestkorea/util-error-handler';
-;
-;
+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 {
     constructor(input) {
         super(input);
@@ -10,36 +8,37 @@ export class SendAlimtalkCommand extends SensCommand {
             ...input,
             plusFriendId: input.plusFriendId,
             templateCode: input.templateCode,
-            messages: input.messages.map(resolveAlimtalkMessage)
+            messages: input.messages.map(resolveAlimtalkMessage),
         };
     }
-    ;
     async serialize(input, config) {
         if (!config.serviceId.kakao)
             throw new IngestkoreaError({
-                code: 400, type: 'Bad Request', message: 'Invalid Params', description: 'Please Check Kakao ServiceId'
+                code: 400,
+                type: "Bad Request",
+                message: "Invalid Params",
+                description: "Please Check Kakao ServiceId",
             });
         let request = await serializeIngestkorea_restJson_SendAlimtalkCommand(input, config);
         return request;
     }
-    ;
     async deserialize(response) {
         let output = await deserializeIngestkorea_restJson_SendAlimtalkCommand(response);
         return output;
     }
-    ;
 }
-;
 const resolveAlimtalkMessage = (message) => {
     const ALIMTALK_MAX = 1000;
     if (message.content.length > ALIMTALK_MAX)
         throw new IngestkoreaError({
-            code: 400, type: 'Bad Request',
-            message: 'Invalid Params', description: `Maximum message length is ${ALIMTALK_MAX}`
+            code: 400,
+            type: "Bad Request",
+            message: "Invalid Params",
+            description: `Maximum message length is ${ALIMTALK_MAX}`,
         });
     return {
         to: message.to.replace(/\-/gi, ""),
         content: message.content,
-        ...(message.buttons != undefined && { buttons: message.buttons })
+        ...(message.buttons != undefined && { buttons: message.buttons }),
     };
 };

package/dist-es/commands/SendMMSCommand.js

@@ -1,12 +1,10 @@
-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';
-;
-;
+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 {
     constructor(input) {
         super(input);
@@ -16,42 +14,45 @@ export class SendMMSCommand extends SensCommand {
             content: resolveInputContent(input.content),
             type: resolveInputMessageType(input.type),
             messages: resolveInputMessages(input.messages),
-            files: resolveInputFiles(input.files)
+            files: resolveInputFiles(input.files),
         };
     }
-    ;
     async serialize(input, config) {
         if (!config.serviceId.sms)
             throw new IngestkoreaError({
-                code: 400, type: 'Bad Request', message: 'Invalid Params', description: 'Please Check SMS ServiceId'
+                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;
     }
-    ;
 }
-;
 const resolveInputContent = (content) => {
     const resolvedContent = trimText(content);
     const contentLength = getContentLength(resolvedContent);
     if (!contentLength)
         throw new IngestkoreaError({
-            code: 400, type: 'Bad Request',
-            message: 'Invalid Request', description: `Please check input message`
+            code: 400,
+            type: "Bad Request",
+            message: "Invalid Request",
+            description: `Please check input message`,
         });
     if (contentLength > LMS_MAX)
         throw new IngestkoreaError({
-            code: 400, type: 'Bad Request',
-            message: 'Invalid Request', description: `Maximum message length is ${LMS_MAX}bytes`
+            code: 400,
+            type: "Bad Request",
+            message: "Invalid Request",
+            description: `Maximum message length is ${LMS_MAX}bytes`,
         });
     return resolvedContent;
 };
-const resolveInputMessages = (messages) => messages.map(message => {
+const resolveInputMessages = (messages) => messages.map((message) => {
     return {
         to: prettyPhoneNum(message.to),
         ...(message.content != undefined && { content: resolveInputContent(message.content) }),
@@ -59,29 +60,34 @@ const resolveInputMessages = (messages) => messages.map(message => {
     };
 });
 const resolveInputMessageType = (type) => {
-    if (type == 'SMS' || type == 'LMS')
+    if (type == "SMS" || type == "LMS")
         throw new IngestkoreaError({
-            code: 400, type: 'Bad Request',
-            message: 'Invalid Request', description: `Please Call SendSMSCommand`
+            code: 400,
+            type: "Bad Request",
+            message: "Invalid Request",
+            description: `Please Call SendSMSCommand`,
         });
-    return 'MMS';
+    return "MMS";
 };
 const resolveInputFiles = (files) => {
     if (!files.length)
         throw new IngestkoreaError({
-            code: 400, type: 'Bad Request',
-            message: 'Invalid Request', description: `Please Check Input Files`
+            code: 400,
+            type: "Bad Request",
+            message: "Invalid Request",
+            description: `Please Check Input Files`,
         });
-    const output = files.map(file => {
+    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 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`
+                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 };
     });
@@ -91,19 +97,23 @@ const verifyFileName = (fileName) => {
     let { ext } = parse(fileName);
     const uuid = randomUUID();
     const extension = ext.replace(/jpeg|jpg/gi, "jpg");
-    if (extension != '.jpg')
+    if (extension != ".jpg")
         throw new IngestkoreaError({
-            code: 400, type: 'Bad Request',
-            message: 'Invalid Request', description: `File Extension is not .jpg or .jpeg`
+            code: 400,
+            type: "Bad Request",
+            message: "Invalid Request",
+            description: `File Extension is not .jpg or .jpeg`,
         });
-    return [uuid, extension].join('');
+    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.`
+            code: 400,
+            type: "Bad Request",
+            message: "Invalid Request",
+            description: `${fileName} does not exist.`,
         });
-    return readFileSync(fileName, { encoding: 'base64' });
+    return readFileSync(fileName, { encoding: "base64" });
 };

package/dist-es/commands/SendSMSCommand.js

@@ -1,9 +1,7 @@
-import { SensCommand } from '../models';
-import { serializeIngestkorea_restJson_SendSMSCommand, deserializeIngestkorea_restJson_SendSMSCommand } from '../protocols/SendSMS';
-import { IngestkoreaError } from '@ingestkorea/util-error-handler';
-import { SMS_MAX, LMS_MAX, trimText, prettyPhoneNum, getContentLength } from './constants';
-;
-;
+import { SensCommand } from "../models";
+import { serializeIngestkorea_restJson_SendSMSCommand, deserializeIngestkorea_restJson_SendSMSCommand, } from "../protocols/SendSMS";
+import { IngestkoreaError } from "@ingestkorea/util-error-handler";
+import { SMS_MAX, LMS_MAX, trimText, prettyPhoneNum, getContentLength } from "./constants";
 export class SendSMSCommand extends SensCommand {
     constructor(input) {
         super(input);
@@ -13,65 +11,68 @@ export class SendSMSCommand extends SensCommand {
             ...input,
             from: prettyPhoneNum(input.from),
             content: content,
-            type: defaultMessageType === childMessageType ? defaultMessageType : 'LMS',
+            type: defaultMessageType === childMessageType ? defaultMessageType : "LMS",
             messages: messages,
         };
     }
-    ;
     async serialize(input, config) {
         if (!config.serviceId.sms)
             throw new IngestkoreaError({
-                code: 400, type: 'Bad Request', message: 'Invalid Params', description: 'Please Check SMS ServiceId'
+                code: 400,
+                type: "Bad Request",
+                message: "Invalid Params",
+                description: "Please Check SMS ServiceId",
             });
         let request = await serializeIngestkorea_restJson_SendSMSCommand(input, config);
         return request;
     }
-    ;
     async deserialize(response) {
         let output = await deserializeIngestkorea_restJson_SendSMSCommand(response);
         return output;
     }
-    ;
 }
-;
 const getMessageType = (input) => {
     const contentLength = getContentLength(input);
     if (!contentLength)
         throw new IngestkoreaError({
-            code: 400, type: 'Bad Request',
-            message: 'Invalid Request', description: `Please check input message`
+            code: 400,
+            type: "Bad Request",
+            message: "Invalid Request",
+            description: `Please check input message`,
         });
     if (contentLength > LMS_MAX)
         throw new IngestkoreaError({
-            code: 400, type: 'Bad Request',
-            message: 'Invalid Request', description: `Maximum message length is ${LMS_MAX}bytes`
+            code: 400,
+            type: "Bad Request",
+            message: "Invalid Request",
+            description: `Maximum message length is ${LMS_MAX}bytes`,
         });
-    return contentLength > SMS_MAX ? 'LMS' : 'SMS';
+    return contentLength > SMS_MAX ? "LMS" : "SMS";
 };
 const resolveInputContent = (content) => {
     const resolvedContent = trimText(content);
     const messageType = getMessageType(resolvedContent);
     return {
         content: resolvedContent,
-        messageType: messageType
+        messageType: messageType,
     };
 };
 const resolveInputMessages = (messages) => {
     let init = {
         messages: [],
-        messageType: 'SMS'
+        messageType: "SMS",
     };
     const output = messages.reduce((acc, message) => {
         const to = prettyPhoneNum(message.to);
         const content = message.content != undefined ? trimText(message.content) : undefined;
         const subject = message.subject != undefined ? trimText(message.subject) : undefined;
-        const messageType = content != undefined ? getMessageType(content) : 'SMS';
-        if (messageType == 'LMS')
+        const messageType = content != undefined ? getMessageType(content) : "SMS";
+        if (messageType == "LMS")
             acc.messageType = messageType;
         acc.messages.push({
             to: to,
             ...(content != undefined && { content: content }),
-            ...(subject != undefined && acc.messageType === 'LMS' && { subject: subject }),
+            ...(subject != undefined && acc.messageType === "LMS" && { subject: subject }),
         });
         return acc;
     }, init);

package/dist-es/commands/constants.js

@@ -5,10 +5,10 @@ export const trimText = (input) => input.trim();
 export const prettyPhoneNum = (input) => input.replace(/\-/gi, "");
 /** @returns content-length(euc-kr) */
 export const getContentLength = (input) => {
-    return input.split('').reduce((acc, text) => {
+    return input.split("").reduce((acc, text) => {
         let byte = Buffer.from(text).length;
         let modulo = byte % 3;
-        modulo ? acc += 1 : acc += 2;
+        modulo ? (acc += 1) : (acc += 2);
         return acc;
     }, 0);
 };

package/dist-es/commands/index.js

@@ -1,10 +1,10 @@
-export * from './SendAlimtalkCommand';
-export * from './GetAlimtalkStatusCommand';
-export * from './GetAlimtalkResultCommand';
-export * from './GetAlimtalkTemplateCommand';
-export * from './ListAlimtalkTemplatesCommand';
-export * from './ListAlimtalkChannelsCommand';
-export * from './SendSMSCommand';
-export * from './SendMMSCommand';
-export * from './GetSMSStatusCommand';
-export * from './GetSMSResultCommand';
+export * from "./SendAlimtalkCommand";
+export * from "./GetAlimtalkStatusCommand";
+export * from "./GetAlimtalkResultCommand";
+export * from "./GetAlimtalkTemplateCommand";
+export * from "./ListAlimtalkTemplatesCommand";
+export * from "./ListAlimtalkChannelsCommand";
+export * from "./SendSMSCommand";
+export * from "./SendMMSCommand";
+export * from "./GetSMSStatusCommand";
+export * from "./GetSMSResultCommand";

package/dist-es/index.js

@@ -1,2 +1,2 @@
-export * from './commands';
-export * from './SensClient';
+export * from "./commands";
+export * from "./SensClient";

package/dist-es/middleware/index.js

@@ -1,2 +1,4 @@
-export * from './signer-ncp';
-export * from './metadata-ingestkorea';
+export * from "./middleware-sign";
+export * from "./middleware-metadata";
+export * from "./middleware-retry";
+export * from "./middleware-sort-headers";

package/dist-es/middleware/middleware-metadata.js

@@ -0,0 +1,6 @@
+const REQUEST_HEADER = "x-ingestkorea-request";
+export const middlewareIngestkoreaMetadata = async (request, config) => {
+    request.headers["x-ingestkorea-user-agent"] = "@ingestkorea/client-sens/1.6.x";
+    request.headers[REQUEST_HEADER] = "attempt=1";
+    return request;
+};

package/dist-es/middleware/middleware-retry.js

@@ -0,0 +1,51 @@
+import { IngestkoreaError } from "@ingestkorea/util-error-handler";
+const REQUEST_HEADER = "x-ingestkorea-request";
+export const middlewareRetry = async (request, config, handler) => {
+    const maxAttempts = 3;
+    let attempts = 0;
+    let totalRetryDelay = 0;
+    let lastError = new IngestkoreaError({
+        code: 400,
+        type: "Bad Request",
+        message: "Invalid Request",
+        description: { attempts, maxAttempts, totalRetryDelay },
+    });
+    while (true) {
+        try {
+            request.headers[REQUEST_HEADER] = `attempt=${attempts + 1}; max=${maxAttempts}; totalRetryDelay=${totalRetryDelay}`;
+            let { response } = await handler.handle(request);
+            return {
+                output: {
+                    $metadata: {
+                        attempts: attempts + 1,
+                        totalRetryDelay: totalRetryDelay,
+                    },
+                },
+                response,
+            };
+        }
+        catch (err) {
+            attempts++;
+            if (attempts == maxAttempts) {
+                lastError.error.description.attempts = attempts;
+                throw lastError;
+            }
+            const delay = attempts * 1000;
+            totalRetryDelay += delay;
+            lastError.error.description = { attempts, maxAttempts, totalRetryDelay };
+            if (err instanceof IngestkoreaError) {
+                lastError.error.description = {
+                    ...lastError.error.description,
+                    detail: err.error.description,
+                };
+            }
+            if (err instanceof Error) {
+                lastError.error.description = {
+                    ...lastError.error.description,
+                    detail: err.message,
+                };
+            }
+            await new Promise((resolve) => setTimeout(resolve, delay));
+        }
+    }
+};

package/dist-es/middleware/{signer-ncp.js → middleware-sign.js}

@@ -1,5 +1,5 @@
-import { createHmac } from 'crypto';
-import { buildQueryString } from '@ingestkorea/util-http-handler';
+import { createHmac } from "crypto";
+import { buildQueryString } from "@ingestkorea/util-http-handler";
 export const middlewareNcpSigner = async (request, config) => {
     const { accessKey, secretKey } = config.credentials;
     const method = request.method;
@@ -8,17 +8,13 @@ export const middlewareNcpSigner = async (request, config) => {
     const space = " ";
     const newLine = "\n";
     const timestamp = new Date().getTime().toString();
-    const stringToSign = [
-        method + space + path,
-        timestamp,
-        accessKey
-    ].join(newLine);
-    const signature = createHmac("sha256", secretKey).update(stringToSign).digest('base64');
+    const stringToSign = [method + space + path, timestamp, accessKey].join(newLine);
+    const signature = createHmac("sha256", secretKey).update(stringToSign).digest("base64");
     request.headers = {
         ...request.headers,
-        ['x-ncp-iam-access-key']: accessKey,
-        ['x-ncp-apigw-timestamp']: timestamp,
-        ['x-ncp-apigw-signature-v2']: signature
+        ["x-ncp-iam-access-key"]: accessKey,
+        ["x-ncp-apigw-timestamp"]: timestamp,
+        ["x-ncp-apigw-signature-v2"]: signature,
     };
     return request;
 };