@ingestkorea/client-sens 1.9.0 → 1.11.0

package/dist-es/protocols/constants.js

@@ -1,91 +1,104 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.convertToUtc = exports.compact = exports.parseErrorBody = exports.parseBody = exports.deserializeMetadata = void 0;
-const util_http_handler_1 = require("@ingestkorea/util-http-handler");
-const index_js_1 = require("../models/index.js");
-const constants_js_1 = require("../middleware/constants.js");
-const deserializeMetadata = (response) => {
-    const attempts = response.headers[constants_js_1.INGESTKOREA_RETRY] || "1";
-    const totalRetryDelay = response.headers[constants_js_1.INGESTKOREA_RETRY_DELAY] || "0";
+import { collectBodyString, destroyStream } from "@ingestkorea/util-http-handler";
+import { SensError, SENS_ERROR_CODE_SPEC, NCLOUD_ERROR_CODE_SPEC, } from "../models/index.js";
+import { INGESTKOREA_RETRY, INGESTKOREA_RETRY_DELAY, NCP_TRACE_ID } from "../middleware/constants.js";
+const ALLOWED_CONTENT_TYPES = ["application/json"];
+const SENS_ERROR_BODY_SPEC = [
+    ["status", "number", true],
+    ["errorMessage", "string", false],
+    ["errors", "object", false],
+];
+const NCLOUD_ERROR_BODY_SPEC = [
+    ["errorCode", "string", true],
+    ["message", "string", false],
+    ["details", "string", false],
+];
+export const deserializeMetadata = (response) => {
+    const attempts = response.headers[INGESTKOREA_RETRY] || "1";
+    const totalRetryDelay = response.headers[INGESTKOREA_RETRY_DELAY] || "0";
+    const traceId = response.headers[NCP_TRACE_ID] || undefined;
     return {
         httpStatusCode: response.statusCode,
         attempts: Number(attempts),
         totalRetryDelay: Number(totalRetryDelay),
+        ...(traceId && { traceId }),
     };
 };
-exports.deserializeMetadata = deserializeMetadata;
-const parseBody = async (output) => {
+export const parseBody = async (output) => {
+    const { statusCode, headers, body: streamBody } = output;
+    if (!isSupportContentType(ALLOWED_CONTENT_TYPES, headers["content-type"])) {
+        await destroyStream(streamBody);
+        throw new SensError({
+            code: statusCode,
+            type: "SDK.REQUEST_ERROR",
+            message: `response content-type is not ${ALLOWED_CONTENT_TYPES.join(" or ")}`,
+        });
+    }
+    try {
+        const data = await collectBodyString(streamBody);
+        return data.length ? JSON.parse(data) : {};
+    }
+    catch (e) {
+        throw new SensError({
+            code: -1,
+            type: "SDK.REQUEST_ERROR",
+            message: "parse response body error",
+        });
+    }
+};
+export const parseErrorBody = async (output) => {
     const { statusCode, headers, body: streamBody } = output;
-    if (!isJsonResponse(headers["content-type"])) {
-        await (0, util_http_handler_1.destroyStream)(streamBody);
-        throw new index_js_1.SensError({
-            code: statusCode !== null && statusCode !== void 0 ? statusCode : 400,
-            type: "Bad Request",
-            message: "response content-type is not application/json",
+    if (!isSupportContentType(ALLOWED_CONTENT_TYPES, headers["content-type"])) {
+        await destroyStream(streamBody);
+        throw new SensError({
+            code: -1,
+            type: "SDK.REQUEST_ERROR",
+            message: `response content-type is not ${ALLOWED_CONTENT_TYPES.join(" or ")}`,
         });
     }
-    const data = await (0, util_http_handler_1.collectBodyString)(streamBody);
-    if (data.length) {
-        try {
-            return JSON.parse(data);
+    try {
+        const data = await collectBodyString(streamBody);
+        const sensContent = isSensErrorResponse(data);
+        const nCloudContent = isNCloudErrorResponse(data);
+        if (sensContent) {
+            throw handleSensError(sensContent, statusCode);
         }
-        catch (e) {
-            await (0, util_http_handler_1.destroyStream)(streamBody);
-            throw new index_js_1.SensError({
-                code: statusCode !== null && statusCode !== void 0 ? statusCode : 400,
-                type: "Bad Request",
-                message: "parse response body error",
-            });
+        if (nCloudContent) {
+            throw handleNCloudError(nCloudContent, statusCode);
         }
+        const summary = data ? data.slice(0, 100).trim() : "empty response";
+        throw new SensError({
+            code: -1,
+            type: "SDK.UNKNOWN_ERROR",
+            message: "Invalid Naver Cloud Platform response format",
+            errors: [`HTTP ${statusCode} - ${summary}...`],
+        });
+    }
+    catch (e) {
+        await destroyStream(streamBody);
+        throw e;
     }
-    return {};
 };
-exports.parseBody = parseBody;
-const parseErrorBody = async (output) => {
-    const { statusCode, headers, body: streamBody } = output;
-    const error = new index_js_1.SensError({
-        code: statusCode !== null && statusCode !== void 0 ? statusCode : 400,
-        type: "Bad Request",
-        message: "something wrong",
-    });
-    if (!isJsonResponse(headers["content-type"])) {
-        await (0, util_http_handler_1.destroyStream)(streamBody);
-        error.message = "response content-type is not application/json";
-        throw error;
+export const compact = (obj) => {
+    if (Array.isArray(obj)) {
+        return obj.map((item) => compact(item));
     }
-    const data = await (0, util_http_handler_1.collectBodyString)(streamBody);
-    await (0, util_http_handler_1.destroyStream)(streamBody);
-    const sensErrorBody = isSensErrorBody(data);
-    if (!sensErrorBody) {
-        throw error;
+    if (typeof obj === "object" && obj !== null) {
+        return Object.fromEntries(Object.entries(obj)
+            .filter(([_, value]) => value !== undefined) // undefined 필드 제거
+            .map(([key, value]) => [key, compact(value)]) // 내부 값 재귀 처리
+        );
     }
-    throw new index_js_1.SensError({
-        code: sensErrorBody.status,
-        type: SENS_ERROR_CODE_SPEC[sensErrorBody.status] || "Unknown Error",
-        message: sensErrorBody.errorMessage || "Something wrong",
-        ...(sensErrorBody.errors &&
-            Array.isArray(sensErrorBody.errors) && {
-            invalidInputs: sensErrorBody.errors.map((msg) => {
-                return { type: "not-valid.args", message: msg };
-            }),
-        }),
-    });
+    return obj;
 };
-exports.parseErrorBody = parseErrorBody;
-const SENS_ERROR_CODE_SPEC = {
-    400: "Bad Request",
-    401: "Unauthorized",
-    403: "Forbidden",
-    404: "Not Found",
-    429: "Too Many Requests",
-    500: "Internal Server Error",
+export const convertToUtc = (input) => {
+    const utcRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
+    return utcRegex.test(input) ? input : new Date(input.replace(" ", "T") + "+09:00").toISOString();
 };
-const SENS_ERROR_BODY_SPEC = [
-    ["status", "number", true],
-    ["errorMessage", "string", false],
-    ["errors", "object", false],
-];
-const isSensErrorBody = (input) => {
+const isSupportContentType = (allowedTypes, contentType) => {
+    const matchedType = allowedTypes.find((type) => contentType?.toLowerCase().includes(type));
+    return !!matchedType;
+};
+const isSensErrorResponse = (input) => {
     if (typeof input !== "string")
         return null;
     try {
@@ -102,28 +115,53 @@ const isSensErrorBody = (input) => {
         });
         return isValid ? data : null;
     }
-    catch (_a) {
+    catch {
         return null;
     }
 };
-const compact = (obj) => {
-    if (Array.isArray(obj)) {
-        return obj.map((item) => (0, exports.compact)(item));
+const isNCloudErrorResponse = (input) => {
+    if (typeof input !== "string")
+        return null;
+    try {
+        const data = JSON.parse(input);
+        if (!(data && typeof data == "object" && typeof data.error == "object"))
+            return null;
+        const isValid = NCLOUD_ERROR_BODY_SPEC.every(([key, type, required]) => {
+            const value = data.error[key];
+            if (required && (value === undefined || value === null))
+                return false;
+            if (value !== undefined && typeof value !== type)
+                return false;
+            return true;
+        });
+        return isValid ? data : null;
     }
-    if (typeof obj === "object" && obj !== null) {
-        return Object.fromEntries(Object.entries(obj)
-            .filter(([_, value]) => value !== undefined) // undefined 필드 제거
-            .map(([key, value]) => [key, (0, exports.compact)(value)]) // 내부 값 재귀 처리
-        );
+    catch {
+        return null;
     }
-    return obj;
 };
-exports.compact = compact;
-const convertToUtc = (input) => {
-    const utcRegex = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?Z$/;
-    return utcRegex.test(input) ? input : new Date(input.replace(" ", "T") + "+09:00").toISOString();
+const isSensErrorCode = (code) => {
+    return code in SENS_ERROR_CODE_SPEC;
 };
-exports.convertToUtc = convertToUtc;
-const isJsonResponse = (contentType) => {
-    return /application\/json/gi.exec(contentType || "") ? true : false;
+const isNCloudErrorCode = (code) => {
+    return code in NCLOUD_ERROR_CODE_SPEC;
+};
+const handleSensError = (data, httpStatusCode) => {
+    return new SensError({
+        code: httpStatusCode,
+        type: isSensErrorCode(data.status) ? SENS_ERROR_CODE_SPEC[data.status] : "SDK.UNKNOWN_ERROR",
+        message: data.errorMessage || "something wrong",
+        ...(Array.isArray(data?.errors) && {
+            errors: data.errors.filter((d) => !!d).map((d) => String(d)),
+        }),
+    });
+};
+const handleNCloudError = (data, httpStatusCode) => {
+    const { errorCode, message, details } = data.error;
+    throw new SensError({
+        code: httpStatusCode,
+        type: isNCloudErrorCode(errorCode) ? NCLOUD_ERROR_CODE_SPEC[errorCode].type : "SDK.UNKNOWN_ERROR",
+        message: message || "something wrong",
+        ...(typeof details == "string" && { errors: [details] }),
+    });
 };

package/dist-types/SensClient.d.ts

@@ -2,7 +2,6 @@ import { SensClientConfig, SensClientResolvedConfig, SensCommand } from "./model
 export declare class SensClient {
     config: SensClientResolvedConfig;
     private httpHandler;
-    private requestHandler;
     constructor(config: SensClientConfig);
     send<T, P>(command: SensCommand<T, P, SensClientResolvedConfig>): Promise<P>;
 }

package/dist-types/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./commands/index.js";
 export * from "./SensClient.js";
+export * from "./models/SensClientError.js";

package/dist-types/middleware/constants.d.ts

@@ -5,3 +5,4 @@ export declare const INGESTKOREA_RETRY_DELAY = "x-ingestkorea-total-retry-delay"
 export declare const NCP_ACCESS_KEY = "x-ncp-iam-access-key";
 export declare const NCP_TIMESTAMP = "x-ncp-apigw-timestamp";
 export declare const NCP_SIGNATURE = "x-ncp-apigw-signature-v2";
+export declare const NCP_TRACE_ID = "x-ncp-trace-id";

package/dist-types/models/MetadataBearer.d.ts

@@ -5,4 +5,5 @@ export interface ResponseMetadata {
     httpStatusCode: number;
     attempts: number;
     totalRetryDelay: number;
+    traceId?: string;
 }

package/dist-types/models/SensApiError.d.ts

@@ -0,0 +1,55 @@
+export declare const SENS_ERROR_CODE_SPEC: {
+    readonly 400: "Bad Request";
+    readonly 401: "Unauthorized";
+    readonly 403: "Forbidden";
+    readonly 404: "Not Found";
+    readonly 429: "Too Many Requests";
+    readonly 500: "Internal Server Error";
+};
+export declare const NCLOUD_ERROR_CODE_SPEC: {
+    readonly "100": {
+        readonly status: 400;
+        readonly type: "Bad Request";
+    };
+    readonly "200": {
+        readonly status: 401;
+        readonly type: "Unauthorized";
+    };
+    readonly "210": {
+        readonly status: 403;
+        readonly type: "Forbidden";
+    };
+    readonly "300": {
+        readonly status: 404;
+        readonly type: "Not Found";
+    };
+    readonly "400": {
+        readonly status: 429;
+        readonly type: "Too Many Requests";
+    };
+    readonly "410": {
+        readonly status: 429;
+        readonly type: "Too Many Requests";
+    };
+    readonly "420": {
+        readonly status: 429;
+        readonly type: "Too Many Requests";
+    };
+    readonly "900": {
+        readonly status: 500;
+        readonly type: "Internal Server Error";
+    };
+};
+export type SesnResponseErrorType = (typeof SENS_ERROR_CODE_SPEC)[keyof typeof SENS_ERROR_CODE_SPEC];
+export interface SensErrorResponse {
+    status: number;
+    errorMessage?: string;
+    errors?: object;
+}
+export interface NCloudErrorResponse {
+    error: {
+        errorCode: string;
+        message?: string;
+        details?: string;
+    };
+}

package/dist-types/models/SensClient.d.ts

@@ -4,14 +4,21 @@ export type Credentials = {
 };
 export type ServiceId = {
     kakao: string;
-    push: string;
     sms: string;
 };
+export type HttpHandlerOptions = {
+    connectionTimeout: number;
+    socketTimeout: number;
+    keepAlive: boolean;
+    family: 4;
+};
 export interface SensClientConfig {
     credentials?: Partial<Credentials>;
     serviceId?: Partial<ServiceId>;
+    httpHandler?: Partial<HttpHandlerOptions>;
 }
 export interface SensClientResolvedConfig {
     credentials: Credentials;
     serviceId: ServiceId;
+    httpHandler: HttpHandlerOptions;
 }

package/dist-types/models/SensClientError.d.ts

@@ -0,0 +1,18 @@
+import { HttpHandlerErrorCode } from "@ingestkorea/util-http-handler";
+import { SesnResponseErrorType } from "./SensApiError.js";
+type SensClientErrorType = "SDK.AUTH_ERROR" | "SDK.GENERAL_ERROR" | "SDK.REQUEST_ERROR" | "SDK.UNKNOWN_ERROR";
+export type SensErrorType = SesnResponseErrorType | SensClientErrorType | HttpHandlerErrorCode;
+export interface SensErrorInput {
+    code: number;
+    type: SensErrorType;
+    message: string;
+    errors?: string[];
+}
+export declare class SensError extends Error {
+    readonly code: number;
+    readonly type: SensErrorType;
+    readonly errors: string[];
+    readonly timestamp: string;
+    constructor(info: SensErrorInput);
+}
+export {};

package/dist-types/models/index.d.ts

@@ -11,7 +11,8 @@ export * from "./MetadataBearer.js";
 export * from "./SendAlimtalk.js";
 export * from "./SendMMS.js";
 export * from "./SendSMS.js";
+export * from "./SensApiError.js";
 export * from "./SensClient.js";
+export * from "./SensClientError.js";
 export * from "./SensCommand.js";
-export * from "./SensErrorInfo.js";
 export * from "./SensMiddleware.js";

package/dist-types/protocols/constants.d.ts

@@ -2,6 +2,6 @@ import { HttpResponse } from "@ingestkorea/util-http-handler";
 import { ResponseMetadata } from "../models/index.js";
 export declare const deserializeMetadata: (response: HttpResponse) => ResponseMetadata;
 export declare const parseBody: (output: HttpResponse) => Promise<any>;
-export declare const parseErrorBody: (output: HttpResponse) => Promise<void>;
+export declare const parseErrorBody: (output: HttpResponse) => Promise<never>;
 export declare const compact: <T>(obj: T) => T;
 export declare const convertToUtc: (input: string) => string;

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@ingestkorea/client-sens",
-  "version": "1.9.0",
+  "version": "1.11.0",
   "description": "INGESTKOREA SDK Naver Cloud Platform SENS Client for Node.js.",
   "exports": {
     ".": {
+      "types": "./dist-types/index.d.ts",
       "import": "./dist-es/index.js",
-      "require": "./dist-cjs/index.js",
-      "types": "./dist-types/index.d.ts"
+      "require": "./dist-cjs/index.js"
     }
   },
   "main": "./dist-cjs/index.js",
@@ -43,8 +43,7 @@
     "typescript": "^5"
   },
   "dependencies": {
-    "@ingestkorea/util-error-handler": "^1.0.3",
-    "@ingestkorea/util-http-handler": "^1.1.2"
+    "@ingestkorea/util-http-handler": "^1.4.0"
   },
   "keywords": [
     "sens",

package/dist-es/models/SensErrorInfo.js

@@ -1,13 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SensError = void 0;
-class SensError extends Error {
-    constructor(info) {
-        super(info.message);
-        this.name = "SensError";
-        this.code = info.code;
-        this.type = info.type;
-        this.invalidInputs = info.invalidInputs || [];
-    }
-}
-exports.SensError = SensError;

package/dist-types/models/SensErrorInfo.d.ts

@@ -1,21 +0,0 @@
-export interface SensErrorResponse {
-    status: number;
-    errorMessage?: string;
-    errors?: object;
-}
-export interface SensErrorInput {
-    code: number;
-    type: string;
-    message: string;
-    invalidInputs?: InvalidInputs[];
-}
-export type InvalidInputs = {
-    type: string;
-    message: string;
-};
-export declare class SensError extends Error {
-    readonly code: number;
-    readonly type: string;
-    readonly invalidInputs: InvalidInputs[];
-    constructor(info: SensErrorInput);
-}