@ingestkorea/client-sens 1.0.0

package/dist-es/protocols/SendAlimtalk.js

@@ -0,0 +1,59 @@
+import { HttpRequest } from '@ingestkorea/util-http-handler';
+import { parseBody, parseErrorBody } from './constants';
+export const serializeIngestkorea_restJson_SendAlimtalkCommand = async (input, config) => {
+    const hostname = "sens.apigw.ntruss.com";
+    const path = "/alimtalk/v2/services/" + config.serviceId + "/messages";
+    const headers = {
+        "content-type": "application/json; charset=utf-8",
+        "host": hostname
+    };
+    const body = JSON.stringify({
+        plusFriendId: input.plusFriendId,
+        templateCode: input.templateCode,
+        messages: input.messages
+    });
+    return new HttpRequest({
+        protocol: 'https:',
+        method: 'POST',
+        hostname: hostname,
+        path: path,
+        headers: headers,
+        body: body
+    });
+};
+export const deserializeIngestkorea_restJson_SendAlimtalkCommand = async (output) => {
+    if (output.statusCode > 300)
+        await parseErrorBody(output);
+    const data = await parseBody(output); // SendAlimtalkCommandOutput
+    let contents = {};
+    contents = await deserializeIngestkorea_restJson_SendMessageOutput(data);
+    const response = {
+        ...contents
+    };
+    return response;
+};
+export const deserializeIngestkorea_restJson_SendMessageOutput = async (output) => {
+    return {
+        requestId: output.requestId != undefined ? output.requestId : undefined,
+        requestTime: output.requestTime != undefined ? output.requestTime : undefined,
+        statusCode: output.statusCode != undefined ? output.statusCode : undefined,
+        statusName: output.statusName != undefined ? output.statusName : undefined,
+        messages: output.messages != undefined ?
+            deserializeIngestkorea_restJson_ReceivedMessages(output.messages) : undefined,
+    };
+};
+export const deserializeIngestkorea_restJson_ReceivedMessages = (outputs) => {
+    const result = outputs.map(output => {
+        return {
+            messageId: output.messageId != undefined ? output.messageId : undefined,
+            to: output.to != undefined ? output.to : undefined,
+            countryCode: output.countryCode != undefined ? output.countryCode : undefined,
+            content: output.content != undefined ? output.content : undefined,
+            requestStatusCode: output.requestStatusCode != undefined ? output.requestStatusCode : undefined,
+            requestStatusName: output.requestStatusName != undefined ? output.requestStatusName : undefined,
+            requestStatusDesc: output.requestStatusDesc != undefined ? output.requestStatusDesc : undefined,
+            useSmsFailover: output.useSmsFailover != undefined ? output.useSmsFailover : undefined,
+        };
+    });
+    return result;
+};

package/dist-es/protocols/constants.js

@@ -0,0 +1,41 @@
+import { IngestkoreaError, ingestkoreaErrorCodeChecker } from '@ingestkorea/util-error-handler';
+import { collectBodyString, destroyStream } from '@ingestkorea/util-http-handler';
+export const parseBody = async (output) => {
+    const { statusCode, headers, body: streamBody } = output;
+    const isValid = await verifyJsonHeader(headers['content-type']);
+    if (!isValid) {
+        await destroyStream(streamBody);
+        let customError = new IngestkoreaError({
+            code: 400, type: 'Bad Request',
+            message: 'Invalid Request', description: 'content-type is not application/json'
+        });
+        if (ingestkoreaErrorCodeChecker(statusCode))
+            customError.error.code = statusCode;
+        throw customError;
+    }
+    ;
+    const data = await collectBodyString(streamBody);
+    if (data.length)
+        return JSON.parse(data);
+    return {};
+};
+export const parseErrorBody = async (output) => {
+    const { statusCode, headers, body: streamBody } = output;
+    const isValid = await verifyJsonHeader(headers['content-type']);
+    await destroyStream(streamBody);
+    let customError = new IngestkoreaError({
+        code: 400, type: 'Bad Request',
+        message: 'Invalid Request', description: 'content-type is not application/json'
+    });
+    if (ingestkoreaErrorCodeChecker(statusCode))
+        customError.error.code = statusCode;
+    if (!isValid)
+        throw customError;
+    const data = await collectBodyString(streamBody);
+    if (data.length)
+        customError.error.description = JSON.parse(data);
+    throw customError;
+};
+const verifyJsonHeader = async (contentType) => {
+    return /application\/json/gi.exec(contentType) ? true : false;
+};

package/dist-es/protocols/index.js

@@ -0,0 +1,4 @@
+export * from './SendAlimtalk';
+export * from './GetRequestStatus';
+export * from './GetRequestResult';
+export * from './ListChannels';

package/dist-types/SensClient.d.ts

@@ -0,0 +1,21 @@
+import { NodeHttpHandler } from '@ingestkorea/util-http-handler';
+import { SensCommand } from './models';
+export type Credentials = {
+    accessKey: string;
+    secretKey: string;
+};
+export type ServiceId = string;
+export interface SensClientConfig {
+    credentials?: Credentials;
+    serviceId?: ServiceId;
+}
+export interface SensClientResolvedConfig {
+    credentials: Credentials;
+    serviceId: ServiceId;
+}
+export declare class SensClient {
+    config: SensClientResolvedConfig;
+    httpHandler: NodeHttpHandler;
+    constructor(config: SensClientConfig);
+    send<T, P>(command: SensCommand<T, P, SensClientResolvedConfig>): Promise<P>;
+}

package/dist-types/commands/GetRequestResultCommand.d.ts

@@ -0,0 +1,13 @@
+import { HttpRequest, HttpResponse } from '@ingestkorea/util-http-handler';
+import { SensCommand, GetRequestResultInput, GetRequestResultOutput } from '../models';
+import { SensClientResolvedConfig } from '../SensClient';
+export interface GetRequestResultCommandInput extends GetRequestResultInput {
+}
+export interface GetRequestResultCommandOutput extends GetRequestResultOutput {
+}
+export declare class GetRequestResultCommand extends SensCommand<GetRequestResultCommandInput, GetRequestResultCommandOutput, SensClientResolvedConfig> {
+    input: GetRequestResultCommandInput;
+    constructor(input: GetRequestResultCommandInput);
+    serialize(input: GetRequestResultCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
+    deserialize(response: HttpResponse): Promise<GetRequestResultCommandOutput>;
+}

package/dist-types/commands/GetRequestStatusCommand.d.ts

@@ -0,0 +1,13 @@
+import { HttpRequest, HttpResponse } from '@ingestkorea/util-http-handler';
+import { SensCommand, GetRequestStatusInput, GetRequestStatusOutput } from '../models';
+import { SensClientResolvedConfig } from '../SensClient';
+export interface GetRequestStatusCommandInput extends GetRequestStatusInput {
+}
+export interface GetRequestStatusCommandOutput extends GetRequestStatusOutput {
+}
+export declare class GetRequestStatusCommand extends SensCommand<GetRequestStatusCommandInput, GetRequestStatusCommandOutput, SensClientResolvedConfig> {
+    input: GetRequestStatusCommandInput;
+    constructor(input: GetRequestStatusCommandInput);
+    serialize(input: GetRequestStatusCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
+    deserialize(response: HttpResponse): Promise<GetRequestStatusCommandOutput>;
+}

package/dist-types/commands/ListChannelsCommand.d.ts

@@ -0,0 +1,13 @@
+import { HttpRequest, HttpResponse } from '@ingestkorea/util-http-handler';
+import { SensCommand, ListChannelsInput, ListChannelsOutput } from '../models';
+import { SensClientResolvedConfig } from '../SensClient';
+export interface ListChannelsCommandInput extends ListChannelsInput {
+}
+export interface ListChannelsCommandOutput extends ListChannelsOutput {
+}
+export declare class ListChannelsCommand extends SensCommand<ListChannelsCommandInput, ListChannelsCommandOutput, SensClientResolvedConfig> {
+    input: ListChannelsCommandInput;
+    constructor(input: ListChannelsCommandInput);
+    serialize(input: ListChannelsCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
+    deserialize(response: HttpResponse): Promise<ListChannelsCommandOutput>;
+}

package/dist-types/commands/SendAlimtalkCommand.d.ts

@@ -0,0 +1,13 @@
+import { HttpRequest, HttpResponse } from '@ingestkorea/util-http-handler';
+import { SensCommand, SendAlimtalkInput, SendAlimtalkOutput } from '../models';
+import { SensClientResolvedConfig } from '../SensClient';
+export interface SendAlimtalkCommandInput extends SendAlimtalkInput {
+}
+export interface SendAlimtalkCommandOutput extends SendAlimtalkOutput {
+}
+export declare class SendAlimtalkCommand extends SensCommand<SendAlimtalkCommandInput, SendAlimtalkCommandOutput, SensClientResolvedConfig> {
+    input: SendAlimtalkCommandInput;
+    constructor(input: SendAlimtalkCommandInput);
+    serialize(input: SendAlimtalkCommandInput, config: SensClientResolvedConfig): Promise<HttpRequest>;
+    deserialize(response: HttpResponse): Promise<SendAlimtalkCommandOutput>;
+}

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

@@ -0,0 +1,4 @@
+export * from './SendAlimtalkCommand';
+export * from './GetRequestStatusCommand';
+export * from './GetRequestResultCommand';
+export * from './ListChannelsCommand';

package/dist-types/index.d.ts

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

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

@@ -0,0 +1 @@
+export * from './signer';

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

@@ -0,0 +1,3 @@
+import { HttpRequest } from '@ingestkorea/util-http-handler';
+import { SensClientResolvedConfig } from '../SensClient';
+export declare const middlewareSigner: (request: HttpRequest, config: SensClientResolvedConfig) => Promise<HttpRequest>;

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

@@ -0,0 +1,20 @@
+import { StatusMessage } from './GetRequestStatus';
+export interface GetRequestResultInput {
+    messageId: string;
+}
+export interface GetRequestResultOutput extends StatusMessage {
+    requestId?: string;
+    failover?: Failover;
+}
+export interface Failover {
+    smsServiceId?: string;
+    requestId?: string;
+    requestStatusCode?: string;
+    requestStatusName?: string;
+    requestStatusDesc?: string;
+    messageId?: string;
+    messageStatus?: string;
+    messageStatusCode?: string;
+    messageStatusName?: string;
+    messageStatusDesc?: string;
+}

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

@@ -0,0 +1,19 @@
+import { ReceivedMessage } from './SendAlimtalk';
+export interface GetRequestStatusInput {
+    requestId: string;
+}
+export interface GetRequestStatusOutput {
+    requestId?: string;
+    statusCode?: string;
+    statusName?: string;
+    messages?: StatusMessage[];
+}
+export interface StatusMessage extends ReceivedMessage {
+    requestTime?: string;
+    plusFriendId?: string;
+    templateCode?: string;
+    completeTime?: string;
+    messageStatusCode?: string;
+    messageStatusName?: string;
+    messageStatusDesc?: string;
+}

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

@@ -0,0 +1,14 @@
+export interface ListChannelsInput {
+}
+export interface ListChannelsOutput {
+    channels: Channel[];
+}
+export interface Channel {
+    createTime?: string;
+    updateTime?: string;
+    serviceId?: string;
+    channelId?: string;
+    channelName?: string;
+    channelStatus?: string;
+    useSmsFailover?: string;
+}

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

@@ -0,0 +1,33 @@
+export interface SendAlimtalkInput {
+    plusFriendId: string;
+    templateCode: string;
+    messages: SendMessage[];
+}
+export interface SendAlimtalkOutput {
+    requestId?: string;
+    requestTime?: string;
+    statusCode?: string;
+    statusName?: string;
+    messages?: ReceivedMessage[];
+}
+export interface SendMessage {
+    to: string;
+    content: string;
+    buttons?: Buttons[];
+}
+export interface Buttons {
+    type: string;
+    name: string;
+    linkMobile: string;
+    linkPc: string;
+}
+export interface ReceivedMessage {
+    messageId?: string;
+    to?: string;
+    countryCode?: string;
+    content?: string;
+    requestStatusCode?: string;
+    requestStatusName?: string;
+    requestStatusDesc?: string;
+    useSmsFailover?: boolean;
+}

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

@@ -0,0 +1,7 @@
+import { HttpRequest, HttpResponse } from '@ingestkorea/util-http-handler';
+export declare abstract class SensCommand<ClientInput, ClientOutput, ClientResolvedConfig> {
+    input: ClientInput;
+    constructor(input: ClientInput);
+    abstract serialize(input: ClientInput, config: ClientResolvedConfig): Promise<HttpRequest>;
+    abstract deserialize(response: HttpResponse): Promise<ClientOutput>;
+}

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

@@ -0,0 +1,5 @@
+export * from './SensCommand';
+export * from './SendAlimtalk';
+export * from './GetRequestStatus';
+export * from './GetRequestResult';
+export * from './ListChannels';

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

@@ -0,0 +1,8 @@
+import { HttpRequest, HttpResponse } from '@ingestkorea/util-http-handler';
+import { GetRequestResultOutput, Failover } from '../models/GetRequestResult';
+import { SensClientResolvedConfig } from '../SensClient';
+import { GetRequestResultCommandInput, GetRequestResultCommandOutput } from '../commands/GetRequestResultCommand';
+export declare const serializeIngestkorea_restJson_GetRequestResultCommand: (input: GetRequestResultCommandInput, config: SensClientResolvedConfig) => Promise<HttpRequest>;
+export declare const deserializeIngestkorea_restJson_GetRequestResultCommand: (output: HttpResponse) => Promise<GetRequestResultCommandOutput>;
+export declare const deserializeIngestkorea_restJson_GetRequestResultOutput: (output: any) => Promise<GetRequestResultOutput>;
+export declare const deserializeIngestkorea_restJson_GetRequestResultFailover: (output: any) => Failover;

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

@@ -0,0 +1,8 @@
+import { HttpRequest, HttpResponse } from '@ingestkorea/util-http-handler';
+import { GetRequestStatusOutput, StatusMessage } from '../models/GetRequestStatus';
+import { SensClientResolvedConfig } from '../SensClient';
+import { GetRequestStatusCommandInput, GetRequestStatusCommandOutput } from '../commands/GetRequestStatusCommand';
+export declare const serializeIngestkorea_restJson_GetRequestStatusCommand: (input: GetRequestStatusCommandInput, config: SensClientResolvedConfig) => Promise<HttpRequest>;
+export declare const deserializeIngestkorea_restJson_GetRequestStatusCommand: (output: HttpResponse) => Promise<GetRequestStatusCommandOutput>;
+export declare const deserializeIngestkorea_restJson_GetRequestStatusOutput: (output: any) => Promise<GetRequestStatusOutput>;
+export declare const deserializeIngestkorea_restJson_GetRequestStatusMessages: (outputs: any[]) => StatusMessage[];

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

@@ -0,0 +1,8 @@
+import { HttpRequest, HttpResponse } from '@ingestkorea/util-http-handler';
+import { ListChannelsOutput, Channel } from '../models/ListChannels';
+import { SensClientResolvedConfig } from '../SensClient';
+import { ListChannelsCommandInput, ListChannelsCommandOutput } from '../commands/ListChannelsCommand';
+export declare const serializeIngestkorea_restJson_ListChannelsCommand: (input: ListChannelsCommandInput, config: SensClientResolvedConfig) => Promise<HttpRequest>;
+export declare const deserializeIngestkorea_restJson_ListChannelsCommand: (output: HttpResponse) => Promise<ListChannelsCommandOutput>;
+export declare const deserializeIngestkorea_restJson_ListChannelsOutput: (outputs: any[]) => Promise<ListChannelsOutput>;
+export declare const deserializeIngestkorea_restJson_ListChannelsChannelInfo: (outputs: any[]) => Channel[];

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

@@ -0,0 +1,8 @@
+import { HttpRequest, HttpResponse } from '@ingestkorea/util-http-handler';
+import { SendAlimtalkOutput, ReceivedMessage } from '../models/SendAlimtalk';
+import { SensClientResolvedConfig } from '../SensClient';
+import { SendAlimtalkCommandInput, SendAlimtalkCommandOutput } from '../commands/SendAlimtalkCommand';
+export declare const serializeIngestkorea_restJson_SendAlimtalkCommand: (input: SendAlimtalkCommandInput, config: SensClientResolvedConfig) => Promise<HttpRequest>;
+export declare const deserializeIngestkorea_restJson_SendAlimtalkCommand: (output: HttpResponse) => Promise<SendAlimtalkCommandOutput>;
+export declare const deserializeIngestkorea_restJson_SendMessageOutput: (output: any) => Promise<SendAlimtalkOutput>;
+export declare const deserializeIngestkorea_restJson_ReceivedMessages: (outputs: any[]) => ReceivedMessage[];

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

@@ -0,0 +1,3 @@
+import { HttpResponse } from '@ingestkorea/util-http-handler';
+export declare const parseBody: (output: HttpResponse) => Promise<any>;
+export declare const parseErrorBody: (output: HttpResponse) => Promise<void>;

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

@@ -0,0 +1,4 @@
+export * from './SendAlimtalk';
+export * from './GetRequestStatus';
+export * from './GetRequestResult';
+export * from './ListChannels';

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@ingestkorea/client-sens",
+  "version": "1.0.0",
+  "description": "INGESTKOREA SDK NCP SENS Client for Node.js.",
+  "main": "./dist-cjs/index.js",
+  "module": "./dist-es/index.js",
+  "types": "./dist-types/index.d.ts",
+  "scripts": {
+    "build": "npm run clean && npm run build:cjs && npm run build:es && npm run build:types",
+    "build:cjs": "tsc -p tsconfig.cjs.json",
+    "build:es": "tsc -p tsconfig.es.json",
+    "build:types": "tsc -p tsconfig.types.json",
+    "clean": "rm -rf ./dist-*"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/ingestkorea/client-sens.git"
+  },
+  "author": "ingestkorea",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/ingestkorea/client-sens/issues"
+  },
+  "homepage": "https://github.com/ingestkorea/client-sens#readme",
+  "devDependencies": {
+    "@types/node": "^18.11.0"
+  },
+  "dependencies": {
+    "@ingestkorea/util-error-handler": "^1.0.3",
+    "@ingestkorea/util-http-handler": "^1.0.0",
+    "@ingestkorea/util-simple-logger": "^1.0.3"
+  }
+}