wash-service-sdk 1.0.0

package/dist/clients/payment.client.d.ts

@@ -0,0 +1,18 @@
+import * as grpc from '@grpc/grpc-js';
+import { AddServiceRequest, AddServiceResponse, CancelRequest, ConfirmPaymentRequest, ConfirmPaymentResponse, GetDailySubscriptionRevenueResponse, GetPaymentFailuresRequest, GetPaymentFailuresResponse, GetPaymentV1Request, GetPaymentV1Response, GetRevenueSubscriptionRequest, GetRevenueSubscriptionResponse, IsRegisteredCardRequest, IsRegisteredCardResponse, PaymentPaymentKeyRequest, PaymentRequest, PaymentResponse } from '../generated/payment';
+export declare class PaymentClientWrapper {
+    private readonly client;
+    private readonly metadata;
+    constructor(address: string, credentials: grpc.ChannelCredentials, token?: string);
+    addService(request: AddServiceRequest): Promise<AddServiceResponse>;
+    processPayment(request: PaymentRequest): Promise<PaymentResponse>;
+    confirmPayment(request: ConfirmPaymentRequest): Promise<ConfirmPaymentResponse>;
+    processAutoPayment(request: PaymentPaymentKeyRequest): Promise<PaymentResponse>;
+    retryPayment(request: PaymentRequest): Promise<PaymentResponse>;
+    cancelPayment(request: CancelRequest): Promise<PaymentResponse>;
+    isRegisteredCard(request: IsRegisteredCardRequest): Promise<IsRegisteredCardResponse>;
+    getPaymentFailure(request: GetPaymentFailuresRequest): Promise<GetPaymentFailuresResponse>;
+    getRevenueSubscription(request: GetRevenueSubscriptionRequest): Promise<GetRevenueSubscriptionResponse>;
+    getDailyRevenueSubscription(request: GetRevenueSubscriptionRequest): Promise<GetDailySubscriptionRevenueResponse>;
+    getPayment(request: GetPaymentV1Request): Promise<GetPaymentV1Response>;
+}

package/dist/clients/payment.client.js

@@ -0,0 +1,145 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PaymentClientWrapper = void 0;
+const payment_grpc_client_1 = require("../generated/payment.grpc-client");
+const grpc = __importStar(require("@grpc/grpc-js"));
+class PaymentClientWrapper {
+    constructor(address, credentials, token) {
+        this.client = new payment_grpc_client_1.PaymentServiceClient(address, credentials);
+        // 2. 인증 토큰용 메타데이터 준비
+        this.metadata = new grpc.Metadata();
+        if (token) {
+            this.metadata.set('Authorization', `Bearer ${token}`);
+        }
+    }
+    async addService(request) {
+        return new Promise((resolve, reject) => {
+            this.client.addService(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    async processPayment(request) {
+        return new Promise((resolve, reject) => {
+            this.client.processPayment(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    async confirmPayment(request) {
+        return new Promise((resolve, reject) => {
+            this.client.confirmPayment(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    async processAutoPayment(request) {
+        return new Promise((resolve, reject) => {
+            this.client.processPaymentBilling(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    async retryPayment(request) {
+        return new Promise((resolve, reject) => {
+            this.client.retryPayment(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    async cancelPayment(request) {
+        return new Promise((resolve, reject) => {
+            this.client.cancelPayment(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    async isRegisteredCard(request) {
+        return new Promise((resolve, reject) => {
+            this.client.isRegisteredCard(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    async getPaymentFailure(request) {
+        return new Promise((resolve, reject) => {
+            this.client.getPaymentFailures(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    async getRevenueSubscription(request) {
+        return new Promise((resolve, reject) => {
+            this.client.getRevenueSubscription(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    getDailyRevenueSubscription(request) {
+        return new Promise((resolve, reject) => {
+            this.client.getDailyRevenueSubscription(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    getPayment(request) {
+        return new Promise((resolve, reject) => {
+            this.client.getPayment(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+}
+exports.PaymentClientWrapper = PaymentClientWrapper;

package/dist/clients/user.client.d.ts

@@ -0,0 +1,9 @@
+import * as grpc from '@grpc/grpc-js';
+import { RegisterV1Request, RegisterV1Response, RequestFCMToken, ResponseFCMToken } from '../generated/user';
+export declare class UserClientWrapper {
+    private readonly client;
+    private readonly metadata;
+    constructor(address: string, credentials: grpc.ChannelCredentials, token?: string);
+    getFcmToken(request: RequestFCMToken): Promise<ResponseFCMToken>;
+    signUp(request: RegisterV1Request): Promise<RegisterV1Response>;
+}

package/dist/clients/user.client.js

@@ -0,0 +1,55 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UserClientWrapper = void 0;
+const grpc = __importStar(require("@grpc/grpc-js"));
+const user_grpc_client_1 = require("../generated/user.grpc-client");
+class UserClientWrapper {
+    constructor(address, credentials, token) {
+        this.client = new user_grpc_client_1.UserServiceClient(address, credentials);
+        // 2. 인증 토큰용 메타데이터 준비
+        this.metadata = new grpc.Metadata();
+        if (token) {
+            this.metadata.set('Authorization', `Bearer ${token}`);
+        }
+    }
+    async getFcmToken(request) {
+        return new Promise((resolve, reject) => {
+            this.client.requestFcmToken(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+    async signUp(request) {
+        return new Promise((resolve, reject) => {
+            this.client.register(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response);
+            });
+        });
+    }
+}
+exports.UserClientWrapper = UserClientWrapper;

package/dist/generated/auth.d.ts

@@ -0,0 +1,62 @@
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { MessageType } from "@protobuf-ts/runtime";
+/**
+ * 결제 요청 메시지 정의
+ *
+ * @generated from protobuf message auth.AuthRequest
+ */
+export interface AuthRequest {
+    /**
+     * @generated from protobuf field: string token = 1
+     */
+    token: string;
+}
+/**
+ * 결제 응답 메시지 정의
+ *
+ * @generated from protobuf message auth.AuthResponse
+ */
+export interface AuthResponse {
+    /**
+     * @generated from protobuf field: string id = 1
+     */
+    id: string;
+    /**
+     * @generated from protobuf field: string service = 2
+     */
+    service: string;
+    /**
+     * @generated from protobuf field: string type = 3
+     */
+    type: string;
+}
+declare class AuthRequest$Type extends MessageType<AuthRequest> {
+    constructor();
+    create(value?: PartialMessage<AuthRequest>): AuthRequest;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AuthRequest): AuthRequest;
+    internalBinaryWrite(message: AuthRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message auth.AuthRequest
+ */
+export declare const AuthRequest: AuthRequest$Type;
+declare class AuthResponse$Type extends MessageType<AuthResponse> {
+    constructor();
+    create(value?: PartialMessage<AuthResponse>): AuthResponse;
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AuthResponse): AuthResponse;
+    internalBinaryWrite(message: AuthResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter;
+}
+/**
+ * @generated MessageType for protobuf message auth.AuthResponse
+ */
+export declare const AuthResponse: AuthResponse$Type;
+/**
+ * @generated ServiceType for protobuf service auth.AuthService
+ */
+export declare const AuthService: ServiceType;
+export {};

package/dist/generated/auth.grpc-client.d.ts

@@ -0,0 +1,28 @@
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { AuthResponse } from "./auth";
+import type { AuthRequest } from "./auth";
+import * as grpc from "@grpc/grpc-js";
+/**
+ * @generated from protobuf service auth.AuthService
+ */
+export interface IAuthServiceClient {
+    /**
+     * @generated from protobuf rpc: ValidToken
+     */
+    validToken(input: AuthRequest, metadata: grpc.Metadata, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: AuthResponse) => void): grpc.ClientUnaryCall;
+    validToken(input: AuthRequest, metadata: grpc.Metadata, callback: (err: grpc.ServiceError | null, value?: AuthResponse) => void): grpc.ClientUnaryCall;
+    validToken(input: AuthRequest, options: grpc.CallOptions, callback: (err: grpc.ServiceError | null, value?: AuthResponse) => void): grpc.ClientUnaryCall;
+    validToken(input: AuthRequest, callback: (err: grpc.ServiceError | null, value?: AuthResponse) => void): grpc.ClientUnaryCall;
+}
+/**
+ * @generated from protobuf service auth.AuthService
+ */
+export declare class AuthServiceClient extends grpc.Client implements IAuthServiceClient {
+    private readonly _binaryOptions;
+    constructor(address: string, credentials: grpc.ChannelCredentials, options?: grpc.ClientOptions, binaryOptions?: Partial<BinaryReadOptions & BinaryWriteOptions>);
+    /**
+     * @generated from protobuf rpc: ValidToken
+     */
+    validToken(input: AuthRequest, metadata: grpc.Metadata | grpc.CallOptions | ((err: grpc.ServiceError | null, value?: AuthResponse) => void), options?: grpc.CallOptions | ((err: grpc.ServiceError | null, value?: AuthResponse) => void), callback?: ((err: grpc.ServiceError | null, value?: AuthResponse) => void)): grpc.ClientUnaryCall;
+}

package/dist/generated/auth.grpc-client.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthServiceClient = void 0;
+// @generated by protobuf-ts 2.11.1 with parameter client_grpc1
+// @generated from protobuf file "auth.proto" (package "auth", syntax proto3)
+// tslint:disable
+const auth_1 = require("./auth");
+const grpc = __importStar(require("@grpc/grpc-js"));
+/**
+ * @generated from protobuf service auth.AuthService
+ */
+class AuthServiceClient extends grpc.Client {
+    constructor(address, credentials, options = {}, binaryOptions = {}) {
+        super(address, credentials, options);
+        this._binaryOptions = binaryOptions;
+    }
+    /**
+     * @generated from protobuf rpc: ValidToken
+     */
+    validToken(input, metadata, options, callback) {
+        const method = auth_1.AuthService.methods[0];
+        return this.makeUnaryRequest(`/${auth_1.AuthService.typeName}/${method.name}`, (value) => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value) => method.O.fromBinary(value, this._binaryOptions), input, metadata, options, callback);
+    }
+}
+exports.AuthServiceClient = AuthServiceClient;

package/dist/generated/auth.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthService = exports.AuthResponse = exports.AuthRequest = void 0;
+// @generated by protobuf-ts 2.11.1 with parameter client_grpc1
+// @generated from protobuf file "auth.proto" (package "auth", syntax proto3)
+// tslint:disable
+const runtime_rpc_1 = require("@protobuf-ts/runtime-rpc");
+const runtime_1 = require("@protobuf-ts/runtime");
+const runtime_2 = require("@protobuf-ts/runtime");
+const runtime_3 = require("@protobuf-ts/runtime");
+const runtime_4 = require("@protobuf-ts/runtime");
+// @generated message type with reflection information, may provide speed optimized methods
+class AuthRequest$Type extends runtime_4.MessageType {
+    constructor() {
+        super("auth.AuthRequest", [
+            { no: 1, name: "token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.token = "";
+        if (value !== undefined)
+            runtime_3.reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string token */ 1:
+                    message.token = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string token = 1; */
+        if (message.token !== "")
+            writer.tag(1, runtime_1.WireType.LengthDelimited).string(message.token);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message auth.AuthRequest
+ */
+exports.AuthRequest = new AuthRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AuthResponse$Type extends runtime_4.MessageType {
+    constructor() {
+        super("auth.AuthResponse", [
+            { no: 1, name: "id", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 2, name: "service", kind: "scalar", T: 9 /*ScalarType.STRING*/ },
+            { no: 3, name: "type", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value) {
+        const message = globalThis.Object.create((this.messagePrototype));
+        message.id = "";
+        message.service = "";
+        message.type = "";
+        if (value !== undefined)
+            runtime_3.reflectionMergePartial(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader, length, options, target) {
+        let message = target ?? this.create(), end = reader.pos + length;
+        while (reader.pos < end) {
+            let [fieldNo, wireType] = reader.tag();
+            switch (fieldNo) {
+                case /* string id */ 1:
+                    message.id = reader.string();
+                    break;
+                case /* string service */ 2:
+                    message.service = reader.string();
+                    break;
+                case /* string type */ 3:
+                    message.type = reader.string();
+                    break;
+                default:
+                    let u = options.readUnknownField;
+                    if (u === "throw")
+                        throw new globalThis.Error(`Unknown field ${fieldNo} (wire type ${wireType}) for ${this.typeName}`);
+                    let d = reader.skip(wireType);
+                    if (u !== false)
+                        (u === true ? runtime_2.UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message, writer, options) {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, runtime_1.WireType.LengthDelimited).string(message.id);
+        /* string service = 2; */
+        if (message.service !== "")
+            writer.tag(2, runtime_1.WireType.LengthDelimited).string(message.service);
+        /* string type = 3; */
+        if (message.type !== "")
+            writer.tag(3, runtime_1.WireType.LengthDelimited).string(message.type);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? runtime_2.UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message auth.AuthResponse
+ */
+exports.AuthResponse = new AuthResponse$Type();
+/**
+ * @generated ServiceType for protobuf service auth.AuthService
+ */
+exports.AuthService = new runtime_rpc_1.ServiceType("auth.AuthService", [
+    { name: "ValidToken", options: {}, I: exports.AuthRequest, O: exports.AuthResponse }
+]);