wash-service-sdk 1.0.0

package/proto/payment.proto

@@ -0,0 +1,148 @@
+syntax = "proto3";
+
+package payment;
+
+// 서비스 데이터 추가
+message AddServiceRequest {
+    string serviceId = 1;
+    string name = 2;
+    string type = 3;
+}
+
+// 서비스 데이터 추가
+message AddServiceResponse {
+    bool result = 1;
+}
+
+// 결제 요청 메시지 정의
+message PaymentRequest {
+    string userId = 1;         // 사용자 ID
+    string serviceId = 2;         // 사용자 ID
+    string name = 3;
+    int32 amount = 4;          // 결제 금액
+    string data = 5;     // 결제 데이터
+    string type = 6;     // 결제 데이터
+    string storeId = 7;
+}
+
+message ConfirmPaymentRequest {
+    string orderId = 1;
+    string transactionId = 2;
+    int32 amount = 3;
+    string name = 4;
+    string type = 5;
+    string storeId = 6;
+    string paymentMethod = 7;
+    optional string paymentKey = 8;
+}
+
+message ConfirmPaymentResponse {
+    string paymentId = 1;  // 거래 ID
+    string orderId = 2;
+    string name = 3;
+    int32 amount = 4;          // 결제 금액
+    string type = 5;     // 결제 데이터
+    string status = 6;          // 결제 상태 (예: SUCCESS, FAILED)
+    string created_at = 7;
+    string updated_at = 8;
+    optional string paid_at = 9;
+}
+
+// 결제 요청 메시지 정의
+message PaymentPaymentKeyRequest {
+    string userId = 1;         // 사용자 ID
+    string serviceId = 2;         // 사용자 ID
+    string name = 3;
+    int32 amount = 4;          // 결제 금액
+    string data = 5;     // 결제 데이터
+    string type = 6;     // 결제 데이터
+    string storeId = 7;
+}
+
+// 결제 응답 메시지 정의
+message PaymentResponse {
+    string paymentId = 1;  // 거래 ID
+    string status = 2;          // 결제 상태 (예: SUCCESS, FAILED)
+    string message = 3;         // 상태 메시지
+}
+
+// 결제 요청 메시지 정의
+message CancelRequest {
+    string paymentId = 1;         // 서비스 ID
+    string reason = 2;
+}
+
+message GetRevenueSubscriptionRequest {
+    string storeId = 1;
+    int32 startTime = 2;
+    int32 endTime = 3;
+}
+
+// 결제 요청 메시지 정의
+message CancelResponse {
+    string serviceId = 1;         // 서비스 ID
+    string paymentId = 2;
+    string message = 3;
+}
+
+message IsRegisteredCardRequest {
+    string userId = 1;
+}
+
+message IsRegisteredCardResponse {
+    bool isRegistered = 1;
+}
+
+message GetPaymentFailuresRequest {
+    string userId = 1;
+}
+
+message GetPaymentFailuresResponse {
+    int32 count = 1;
+}
+
+message GetRevenueSubscriptionResponse {
+    string storeId = 1;
+    int32 totalSubscriptionRevenue = 2;
+    int32 subscriptionCount = 3;
+}
+
+message GetDailySubscriptionRevenue{
+    string date = 1;
+    int32 totalRevenue = 2;
+    int32 count = 3;
+}
+
+message GetDailySubscriptionRevenueResponse {
+    repeated GetDailySubscriptionRevenue revenues = 1;
+}
+
+message GetPaymentV1Request {
+    string transactionId = 1;
+}
+
+message GetPaymentV1Response {
+    string transactionId = 1;
+    optional string userId = 2;
+    int64 amount = 3;
+    string status = 4;
+    string method = 5;
+    string paymentMethod = 6;
+    string createdAt = 7;
+    string updatedAt = 8;
+}
+
+// 결제 서비스 정의
+service PaymentService {
+    rpc AddService(AddServiceRequest) returns (AddServiceResponse);
+    rpc ProcessPayment(PaymentRequest) returns (PaymentResponse);
+    rpc RetryPayment(PaymentRequest) returns (PaymentResponse);
+    rpc CancelPayment(CancelRequest) returns (PaymentResponse);
+    rpc IsRegisteredCard(IsRegisteredCardRequest) returns (IsRegisteredCardResponse);
+    rpc GetPaymentFailures(GetPaymentFailuresRequest) returns (GetPaymentFailuresResponse);
+    rpc ProcessPaymentBilling(PaymentPaymentKeyRequest) returns (PaymentResponse);
+    rpc GetRevenueSubscription(GetRevenueSubscriptionRequest) returns (GetRevenueSubscriptionResponse);
+    rpc GetDailyRevenueSubscription(GetRevenueSubscriptionRequest) returns (GetDailySubscriptionRevenueResponse);
+    rpc ConfirmPayment(ConfirmPaymentRequest) returns (ConfirmPaymentResponse);
+    rpc GetPayment(GetPaymentV1Request) returns (GetPaymentV1Response);
+}

package/proto/user.proto

@@ -0,0 +1,57 @@
+syntax = "proto3";
+
+package user;
+
+message RegisterV1Request {
+    string phone = 1;
+    repeated int32 termIds = 2;
+}
+
+// 결제 요청 메시지 정의
+message PutRequest {
+    string userId = 1;
+    string name = 2;
+    string phone = 3;
+    bool marketingTerm = 4;
+    bool serviceTerm = 5;
+}
+
+message WithdrawRequest {
+    string userId = 1;
+}
+
+message WithdrawResponse {
+    string message = 1;
+}
+
+// 결제 응답 메시지 정의
+message RegisterResponse {
+    string id = 1;
+}
+
+// 결제 요청 메시지 정의
+message RequestFCMToken {
+    string userId = 1;
+}
+
+// 결제 응답 메시지 정의
+message ResponseFCMToken {
+    string token = 1;
+}
+
+message RegisterV1Response {
+    string id = 1;
+    string name = 2;
+    string phone = 3;
+    bool marketingTerm = 4;
+    bool serviceTerm = 5;
+    string createdAt = 6;
+    string updatedAt = 7;
+}
+
+service UserService {
+    rpc PutUser(PutRequest) returns (RegisterResponse);
+    rpc WithdrawUser(WithdrawRequest) returns (WithdrawResponse);
+    rpc RequestFcmToken(RequestFCMToken) returns (ResponseFCMToken);
+    rpc Register(RegisterV1Request) returns (RegisterV1Response);
+}

package/src/clients/payment.client.ts

@@ -0,0 +1,233 @@
+import { PaymentServiceClient } from '../generated/payment.grpc-client';
+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 class PaymentClientWrapper {
+    private readonly client: PaymentServiceClient;
+    private readonly metadata: grpc.Metadata;
+
+    constructor(
+        address: string,
+        credentials: grpc.ChannelCredentials,
+        token?: string,
+    ) {
+        this.client = new PaymentServiceClient(address, credentials);
+
+        // 2. 인증 토큰용 메타데이터 준비
+        this.metadata = new grpc.Metadata();
+        if (token) {
+            this.metadata.set('Authorization', `Bearer ${token}`);
+        }
+    }
+
+    public async addService(
+        request: AddServiceRequest,
+    ): Promise<AddServiceResponse> {
+        return new Promise<AddServiceResponse>((resolve, reject) => {
+            this.client.addService(
+                request,
+                this.metadata,
+                (error, response) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(response as AddServiceResponse);
+                },
+            );
+        });
+    }
+
+    public async processPayment(
+        request: PaymentRequest,
+    ): Promise<PaymentResponse> {
+        return new Promise<PaymentResponse>((resolve, reject) => {
+            this.client.processPayment(
+                request,
+                this.metadata,
+                (error, response) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(response as PaymentResponse);
+                },
+            );
+        });
+    }
+
+    public async confirmPayment(
+        request: ConfirmPaymentRequest,
+    ): Promise<ConfirmPaymentResponse> {
+        return new Promise<ConfirmPaymentResponse>((resolve, reject) => {
+            this.client.confirmPayment(
+                request,
+                this.metadata,
+                (error, response) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(response as ConfirmPaymentResponse);
+                },
+            );
+        });
+    }
+
+    public async processAutoPayment(
+        request: PaymentPaymentKeyRequest,
+    ): Promise<PaymentResponse> {
+        return new Promise<PaymentResponse>((resolve, reject) => {
+            this.client.processPaymentBilling(
+                request,
+                this.metadata,
+                (error, response) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(response as PaymentResponse);
+                },
+            );
+        });
+    }
+
+    public async retryPayment(
+        request: PaymentRequest,
+    ): Promise<PaymentResponse> {
+        return new Promise<PaymentResponse>((resolve, reject) => {
+            this.client.retryPayment(
+                request,
+                this.metadata,
+                (error, response) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(response as PaymentResponse);
+                },
+            );
+        });
+    }
+
+    public async cancelPayment(
+        request: CancelRequest,
+    ): Promise<PaymentResponse> {
+        return new Promise<PaymentResponse>((resolve, reject) => {
+            this.client.cancelPayment(
+                request,
+                this.metadata,
+                (error, response) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(response as PaymentResponse);
+                },
+            );
+        });
+    }
+
+    public async isRegisteredCard(
+        request: IsRegisteredCardRequest,
+    ): Promise<IsRegisteredCardResponse> {
+        return new Promise<IsRegisteredCardResponse>((resolve, reject) => {
+            this.client.isRegisteredCard(
+                request,
+                this.metadata,
+                (error, response) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(response as IsRegisteredCardResponse);
+                },
+            );
+        });
+    }
+
+    public async getPaymentFailure(
+        request: GetPaymentFailuresRequest,
+    ): Promise<GetPaymentFailuresResponse> {
+        return new Promise<GetPaymentFailuresResponse>((resolve, reject) => {
+            this.client.getPaymentFailures(
+                request,
+                this.metadata,
+                (error, response) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(response as GetPaymentFailuresResponse);
+                },
+            );
+        });
+    }
+
+    public async getRevenueSubscription(
+        request: GetRevenueSubscriptionRequest,
+    ): Promise<GetRevenueSubscriptionResponse> {
+        return new Promise<GetRevenueSubscriptionResponse>(
+            (resolve, reject) => {
+                this.client.getRevenueSubscription(
+                    request,
+                    this.metadata,
+                    (error, response) => {
+                        if (error) {
+                            return reject(error);
+                        }
+                        resolve(response as GetRevenueSubscriptionResponse);
+                    },
+                );
+            },
+        );
+    }
+
+    public getDailyRevenueSubscription(
+        request: GetRevenueSubscriptionRequest,
+    ): Promise<GetDailySubscriptionRevenueResponse> {
+        return new Promise<GetDailySubscriptionRevenueResponse>(
+            (resolve, reject) => {
+                this.client.getDailyRevenueSubscription(
+                    request,
+                    this.metadata,
+                    (error, response) => {
+                        if (error) {
+                            return reject(error);
+                        }
+                        resolve(
+                            response as GetDailySubscriptionRevenueResponse,
+                        );
+                    },
+                );
+            },
+        );
+    }
+
+    public getPayment(
+        request: GetPaymentV1Request,
+    ): Promise<GetPaymentV1Response> {
+        return new Promise<GetPaymentV1Response>((resolve, reject) => {
+            this.client.getPayment(
+                request,
+                this.metadata,
+                (error, response) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(response as GetPaymentV1Response);
+                },
+            );
+        });
+    }
+}

package/src/clients/user.client.ts

@@ -0,0 +1,57 @@
+import * as grpc from '@grpc/grpc-js';
+import { UserServiceClient } from '../generated/user.grpc-client';
+import {
+    type RegisterV1Request,
+    type RegisterV1Response,
+    RequestFCMToken,
+    ResponseFCMToken,
+} from '../generated/user';
+
+export class UserClientWrapper {
+    private readonly client: UserServiceClient;
+    private readonly metadata: grpc.Metadata;
+
+    constructor(
+        address: string,
+        credentials: grpc.ChannelCredentials,
+        token?: string,
+    ) {
+        this.client = new UserServiceClient(address, credentials);
+
+        // 2. 인증 토큰용 메타데이터 준비
+        this.metadata = new grpc.Metadata();
+        if (token) {
+            this.metadata.set('Authorization', `Bearer ${token}`);
+        }
+    }
+
+    public async getFcmToken(
+        request: RequestFCMToken,
+    ): Promise<ResponseFCMToken> {
+        return new Promise<ResponseFCMToken>((resolve, reject) => {
+            this.client.requestFcmToken(
+                request,
+                this.metadata,
+                (error, response) => {
+                    if (error) {
+                        return reject(error);
+                    }
+                    resolve(response as ResponseFCMToken);
+                },
+            );
+        });
+    }
+
+    public async signUp(
+        request: RegisterV1Request,
+    ): Promise<RegisterV1Response> {
+        return new Promise<RegisterV1Response>((resolve, reject) => {
+            this.client.register(request, this.metadata, (error, response) => {
+                if (error) {
+                    return reject(error);
+                }
+                resolve(response as RegisterV1Response);
+            });
+        });
+    }
+}

package/src/generated/auth.grpc-client.ts

@@ -0,0 +1,38 @@
+// @generated by protobuf-ts 2.11.1 with parameter client_grpc1
+// @generated from protobuf file "auth.proto" (package "auth", syntax proto3)
+// tslint:disable
+import { AuthService } from "./auth";
+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 class AuthServiceClient extends grpc.Client implements IAuthServiceClient {
+    private readonly _binaryOptions: Partial<BinaryReadOptions & BinaryWriteOptions>;
+    constructor(address: string, credentials: grpc.ChannelCredentials, options: grpc.ClientOptions = {}, binaryOptions: Partial<BinaryReadOptions & BinaryWriteOptions> = {}) {
+        super(address, credentials, options);
+        this._binaryOptions = binaryOptions;
+    }
+    /**
+     * @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 {
+        const method = AuthService.methods[0];
+        return this.makeUnaryRequest<AuthRequest, AuthResponse>(`/${AuthService.typeName}/${method.name}`, (value: AuthRequest): Buffer => Buffer.from(method.I.toBinary(value, this._binaryOptions)), (value: Buffer): AuthResponse => method.O.fromBinary(value, this._binaryOptions), input, (metadata as any), (options as any), (callback as any));
+    }
+}

package/src/generated/auth.ts

@@ -0,0 +1,159 @@
+// @generated by protobuf-ts 2.11.1 with parameter client_grpc1
+// @generated from protobuf file "auth.proto" (package "auth", syntax proto3)
+// tslint:disable
+import { ServiceType } from "@protobuf-ts/runtime-rpc";
+import type { BinaryWriteOptions } from "@protobuf-ts/runtime";
+import type { IBinaryWriter } from "@protobuf-ts/runtime";
+import { WireType } from "@protobuf-ts/runtime";
+import type { BinaryReadOptions } from "@protobuf-ts/runtime";
+import type { IBinaryReader } from "@protobuf-ts/runtime";
+import { UnknownFieldHandler } from "@protobuf-ts/runtime";
+import type { PartialMessage } from "@protobuf-ts/runtime";
+import { reflectionMergePartial } 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; // 거래 ID
+    /**
+     * @generated from protobuf field: string type = 3
+     */
+    type: string; // 거래 ID
+}
+// @generated message type with reflection information, may provide speed optimized methods
+class AuthRequest$Type extends MessageType<AuthRequest> {
+    constructor() {
+        super("auth.AuthRequest", [
+            { no: 1, name: "token", kind: "scalar", T: 9 /*ScalarType.STRING*/ }
+        ]);
+    }
+    create(value?: PartialMessage<AuthRequest>): AuthRequest {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.token = "";
+        if (value !== undefined)
+            reflectionMergePartial<AuthRequest>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AuthRequest): AuthRequest {
+        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 ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: AuthRequest, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string token = 1; */
+        if (message.token !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.token);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message auth.AuthRequest
+ */
+export const AuthRequest = new AuthRequest$Type();
+// @generated message type with reflection information, may provide speed optimized methods
+class AuthResponse$Type extends MessageType<AuthResponse> {
+    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?: PartialMessage<AuthResponse>): AuthResponse {
+        const message = globalThis.Object.create((this.messagePrototype!));
+        message.id = "";
+        message.service = "";
+        message.type = "";
+        if (value !== undefined)
+            reflectionMergePartial<AuthResponse>(this, message, value);
+        return message;
+    }
+    internalBinaryRead(reader: IBinaryReader, length: number, options: BinaryReadOptions, target?: AuthResponse): AuthResponse {
+        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 ? UnknownFieldHandler.onRead : u)(this.typeName, message, fieldNo, wireType, d);
+            }
+        }
+        return message;
+    }
+    internalBinaryWrite(message: AuthResponse, writer: IBinaryWriter, options: BinaryWriteOptions): IBinaryWriter {
+        /* string id = 1; */
+        if (message.id !== "")
+            writer.tag(1, WireType.LengthDelimited).string(message.id);
+        /* string service = 2; */
+        if (message.service !== "")
+            writer.tag(2, WireType.LengthDelimited).string(message.service);
+        /* string type = 3; */
+        if (message.type !== "")
+            writer.tag(3, WireType.LengthDelimited).string(message.type);
+        let u = options.writeUnknownFields;
+        if (u !== false)
+            (u == true ? UnknownFieldHandler.onWrite : u)(this.typeName, message, writer);
+        return writer;
+    }
+}
+/**
+ * @generated MessageType for protobuf message auth.AuthResponse
+ */
+export const AuthResponse = new AuthResponse$Type();
+/**
+ * @generated ServiceType for protobuf service auth.AuthService
+ */
+export const AuthService = new ServiceType("auth.AuthService", [
+    { name: "ValidToken", options: {}, I: AuthRequest, O: AuthResponse }
+]);