@sa2-movie-ticket/contracts 1.0.12 → 1.0.13

package/gen/ts/auth.ts

@@ -18,6 +18,7 @@ import {
   type ServiceError,
   type UntypedServiceImplementation,
 } from "@grpc/grpc-js";
+import { Empty } from "./google/protobuf/empty";
 
 export const protobufPackage = "auth.v1";
 
@@ -50,6 +51,25 @@ export interface RefreshResponse {
   refreshToken: string;
 }
 
+export interface TelegramInitResponse {
+  url: string;
+}
+
+export interface TelegramVerifyRequest {
+  query: { [key: string]: string };
+}
+
+export interface TelegramVerifyRequest_QueryEntry {
+  key: string;
+  value: string;
+}
+
+export interface TelegramVerifyResponse {
+  url?: string | undefined;
+  accessToken?: string | undefined;
+  refreshToken?: string | undefined;
+}
+
 function createBaseSendOtpRequest(): SendOtpRequest {
   return { identifier: "", type: "" };
 }
@@ -508,6 +528,329 @@ export const RefreshResponse: MessageFns<RefreshResponse> = {
   },
 };
 
+function createBaseTelegramInitResponse(): TelegramInitResponse {
+  return { url: "" };
+}
+
+export const TelegramInitResponse: MessageFns<TelegramInitResponse> = {
+  encode(message: TelegramInitResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.url !== "") {
+      writer.uint32(10).string(message.url);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TelegramInitResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTelegramInitResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.url = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TelegramInitResponse {
+    return { url: isSet(object.url) ? globalThis.String(object.url) : "" };
+  },
+
+  toJSON(message: TelegramInitResponse): unknown {
+    const obj: any = {};
+    if (message.url !== "") {
+      obj.url = message.url;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TelegramInitResponse>, I>>(base?: I): TelegramInitResponse {
+    return TelegramInitResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TelegramInitResponse>, I>>(object: I): TelegramInitResponse {
+    const message = createBaseTelegramInitResponse();
+    message.url = object.url ?? "";
+    return message;
+  },
+};
+
+function createBaseTelegramVerifyRequest(): TelegramVerifyRequest {
+  return { query: {} };
+}
+
+export const TelegramVerifyRequest: MessageFns<TelegramVerifyRequest> = {
+  encode(message: TelegramVerifyRequest, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    globalThis.Object.entries(message.query).forEach(([key, value]: [string, string]) => {
+      TelegramVerifyRequest_QueryEntry.encode({ key: key as any, value }, writer.uint32(10).fork()).join();
+    });
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TelegramVerifyRequest {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTelegramVerifyRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          const entry1 = TelegramVerifyRequest_QueryEntry.decode(reader, reader.uint32());
+          if (entry1.value !== undefined) {
+            message.query[entry1.key] = entry1.value;
+          }
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TelegramVerifyRequest {
+    return {
+      query: isObject(object.query)
+        ? (globalThis.Object.entries(object.query) as [string, any][]).reduce(
+          (acc: { [key: string]: string }, [key, value]: [string, any]) => {
+            acc[key] = globalThis.String(value);
+            return acc;
+          },
+          {},
+        )
+        : {},
+    };
+  },
+
+  toJSON(message: TelegramVerifyRequest): unknown {
+    const obj: any = {};
+    if (message.query) {
+      const entries = globalThis.Object.entries(message.query) as [string, string][];
+      if (entries.length > 0) {
+        obj.query = {};
+        entries.forEach(([k, v]) => {
+          obj.query[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TelegramVerifyRequest>, I>>(base?: I): TelegramVerifyRequest {
+    return TelegramVerifyRequest.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TelegramVerifyRequest>, I>>(object: I): TelegramVerifyRequest {
+    const message = createBaseTelegramVerifyRequest();
+    message.query = (globalThis.Object.entries(object.query ?? {}) as [string, string][]).reduce(
+      (acc: { [key: string]: string }, [key, value]: [string, string]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBaseTelegramVerifyRequest_QueryEntry(): TelegramVerifyRequest_QueryEntry {
+  return { key: "", value: "" };
+}
+
+export const TelegramVerifyRequest_QueryEntry: MessageFns<TelegramVerifyRequest_QueryEntry> = {
+  encode(message: TelegramVerifyRequest_QueryEntry, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TelegramVerifyRequest_QueryEntry {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTelegramVerifyRequest_QueryEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TelegramVerifyRequest_QueryEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: TelegramVerifyRequest_QueryEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TelegramVerifyRequest_QueryEntry>, I>>(
+    base?: I,
+  ): TelegramVerifyRequest_QueryEntry {
+    return TelegramVerifyRequest_QueryEntry.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TelegramVerifyRequest_QueryEntry>, I>>(
+    object: I,
+  ): TelegramVerifyRequest_QueryEntry {
+    const message = createBaseTelegramVerifyRequest_QueryEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseTelegramVerifyResponse(): TelegramVerifyResponse {
+  return { url: undefined, accessToken: undefined, refreshToken: undefined };
+}
+
+export const TelegramVerifyResponse: MessageFns<TelegramVerifyResponse> = {
+  encode(message: TelegramVerifyResponse, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    if (message.url !== undefined) {
+      writer.uint32(10).string(message.url);
+    }
+    if (message.accessToken !== undefined) {
+      writer.uint32(18).string(message.accessToken);
+    }
+    if (message.refreshToken !== undefined) {
+      writer.uint32(26).string(message.refreshToken);
+    }
+    return writer;
+  },
+
+  decode(input: BinaryReader | Uint8Array, length?: number): TelegramVerifyResponse {
+    const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
+    const end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTelegramVerifyResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1: {
+          if (tag !== 10) {
+            break;
+          }
+
+          message.url = reader.string();
+          continue;
+        }
+        case 2: {
+          if (tag !== 18) {
+            break;
+          }
+
+          message.accessToken = reader.string();
+          continue;
+        }
+        case 3: {
+          if (tag !== 26) {
+            break;
+          }
+
+          message.refreshToken = reader.string();
+          continue;
+        }
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skip(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TelegramVerifyResponse {
+    return {
+      url: isSet(object.url) ? globalThis.String(object.url) : undefined,
+      accessToken: isSet(object.accessToken)
+        ? globalThis.String(object.accessToken)
+        : isSet(object.access_token)
+        ? globalThis.String(object.access_token)
+        : undefined,
+      refreshToken: isSet(object.refreshToken)
+        ? globalThis.String(object.refreshToken)
+        : isSet(object.refresh_token)
+        ? globalThis.String(object.refresh_token)
+        : undefined,
+    };
+  },
+
+  toJSON(message: TelegramVerifyResponse): unknown {
+    const obj: any = {};
+    if (message.url !== undefined) {
+      obj.url = message.url;
+    }
+    if (message.accessToken !== undefined) {
+      obj.accessToken = message.accessToken;
+    }
+    if (message.refreshToken !== undefined) {
+      obj.refreshToken = message.refreshToken;
+    }
+    return obj;
+  },
+
+  create<I extends Exact<DeepPartial<TelegramVerifyResponse>, I>>(base?: I): TelegramVerifyResponse {
+    return TelegramVerifyResponse.fromPartial(base ?? ({} as any));
+  },
+  fromPartial<I extends Exact<DeepPartial<TelegramVerifyResponse>, I>>(object: I): TelegramVerifyResponse {
+    const message = createBaseTelegramVerifyResponse();
+    message.url = object.url ?? undefined;
+    message.accessToken = object.accessToken ?? undefined;
+    message.refreshToken = object.refreshToken ?? undefined;
+    return message;
+  },
+};
+
 export type AuthServiceService = typeof AuthServiceService;
 export const AuthServiceService = {
   sendOtp: {
@@ -537,12 +880,35 @@ export const AuthServiceService = {
     responseSerialize: (value: RefreshResponse): Buffer => Buffer.from(RefreshResponse.encode(value).finish()),
     responseDeserialize: (value: Buffer): RefreshResponse => RefreshResponse.decode(value),
   },
+  telegramInit: {
+    path: "/auth.v1.AuthService/TelegramInit",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value: Empty): Buffer => Buffer.from(Empty.encode(value).finish()),
+    requestDeserialize: (value: Buffer): Empty => Empty.decode(value),
+    responseSerialize: (value: TelegramInitResponse): Buffer =>
+      Buffer.from(TelegramInitResponse.encode(value).finish()),
+    responseDeserialize: (value: Buffer): TelegramInitResponse => TelegramInitResponse.decode(value),
+  },
+  telegramVerify: {
+    path: "/auth.v1.AuthService/TelegramVerify",
+    requestStream: false,
+    responseStream: false,
+    requestSerialize: (value: TelegramVerifyRequest): Buffer =>
+      Buffer.from(TelegramVerifyRequest.encode(value).finish()),
+    requestDeserialize: (value: Buffer): TelegramVerifyRequest => TelegramVerifyRequest.decode(value),
+    responseSerialize: (value: TelegramVerifyResponse): Buffer =>
+      Buffer.from(TelegramVerifyResponse.encode(value).finish()),
+    responseDeserialize: (value: Buffer): TelegramVerifyResponse => TelegramVerifyResponse.decode(value),
+  },
 } as const;
 
 export interface AuthServiceServer extends UntypedServiceImplementation {
   sendOtp: handleUnaryCall<SendOtpRequest, SendOtpResponse>;
   verifyOtp: handleUnaryCall<VerifyOtpRequest, VerifyOtpResponse>;
   refresh: handleUnaryCall<RefreshRequest, RefreshResponse>;
+  telegramInit: handleUnaryCall<Empty, TelegramInitResponse>;
+  telegramVerify: handleUnaryCall<TelegramVerifyRequest, TelegramVerifyResponse>;
 }
 
 export interface AuthServiceClient extends Client {
@@ -591,6 +957,36 @@ export interface AuthServiceClient extends Client {
     options: Partial<CallOptions>,
     callback: (error: ServiceError | null, response: RefreshResponse) => void,
   ): ClientUnaryCall;
+  telegramInit(
+    request: Empty,
+    callback: (error: ServiceError | null, response: TelegramInitResponse) => void,
+  ): ClientUnaryCall;
+  telegramInit(
+    request: Empty,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: TelegramInitResponse) => void,
+  ): ClientUnaryCall;
+  telegramInit(
+    request: Empty,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: TelegramInitResponse) => void,
+  ): ClientUnaryCall;
+  telegramVerify(
+    request: TelegramVerifyRequest,
+    callback: (error: ServiceError | null, response: TelegramVerifyResponse) => void,
+  ): ClientUnaryCall;
+  telegramVerify(
+    request: TelegramVerifyRequest,
+    metadata: Metadata,
+    callback: (error: ServiceError | null, response: TelegramVerifyResponse) => void,
+  ): ClientUnaryCall;
+  telegramVerify(
+    request: TelegramVerifyRequest,
+    metadata: Metadata,
+    options: Partial<CallOptions>,
+    callback: (error: ServiceError | null, response: TelegramVerifyResponse) => void,
+  ): ClientUnaryCall;
 }
 
 export const AuthServiceClient = makeGenericClientConstructor(AuthServiceService, "auth.v1.AuthService") as unknown as {
@@ -611,6 +1007,10 @@ type KeysOfUnion<T> = T extends T ? keyof T : never;
 export type Exact<P, I extends P> = P extends Builtin ? P
   : P & { [K in keyof P]: Exact<P[K], I[K]> } & { [K in Exclude<keyof I, KeysOfUnion<P>>]: never };
 
+function isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
 function isSet(value: any): boolean {
   return value !== null && value !== undefined;
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@sa2-movie-ticket/contracts",
   "description": "Contracts for movie ticket microservices",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "license": "ISC",
   "type": "commonjs",
   "main": "dist/index.js",

package/proto/auth.proto

@@ -4,10 +4,15 @@ package auth.v1;
 
 option go_package = "github.com/sa2-movie-ticket/contracts/gen/go/auth";
 
+import "google/protobuf/empty.proto";
+
 service AuthService {
     rpc SendOtp (SendOtpRequest) returns (SendOtpResponse);
     rpc VerifyOtp (VerifyOtpRequest) returns (VerifyOtpResponse);
     rpc Refresh(RefreshRequest) returns (RefreshResponse);
+
+    rpc TelegramInit(google.protobuf.Empty) returns (TelegramInitResponse);
+    rpc TelegramVerify(TelegramVerifyRequest) returns (TelegramVerifyResponse);
 }
 
 message SendOtpRequest {
@@ -39,3 +44,18 @@ message RefreshResponse {
     string refresh_token = 2;
 }
 
+message TelegramInitResponse {
+    string url = 1;
+}
+
+message TelegramVerifyRequest {
+    map<string, string> query = 1;
+}
+
+message TelegramVerifyResponse {
+    oneof result {
+        string url = 1;
+        string access_token = 2;
+        string refresh_token = 3;
+    }
+}