@lumina-cinema/contracts 1.0.7 → 1.0.9

package/gen/auth.ts

@@ -7,59 +7,224 @@
 /* eslint-disable */
 import { GrpcMethod, GrpcStreamMethod } from "@nestjs/microservices";
 import { Observable } from "rxjs";
+import { Empty } from "./google/protobuf/empty";
 
 export const protobufPackage = "auth.v1";
 
+/** / Request to send an OTP to an identifier (email/phone). */
 export interface SendOtpRequest {
+  /** / Target identifier to deliver OTP to (e.g. "+31612345678" or "user@example.com"). */
   identifier: string;
+  /** / Identifier/delivery type. Recommended values: "phone" or "email". */
   type: string;
 }
 
+/** / Send OTP result. */
 export interface SendOtpResponse {
+  /** / True if the OTP was accepted for delivery (does not necessarily guarantee delivery). */
   ok: boolean;
 }
 
+/** / Request to verify an OTP for an identifier. */
 export interface VerifyOtpRequest {
+  /** / Identifier that received the OTP (must match the identifier used in SendOtp). */
   identifier: string;
+  /** / Identifier type used for delivery. Recommended values: "phone" or "email". */
   type: string;
+  /** / OTP code entered by the user. */
   code: string;
 }
 
+/** / Successful OTP verification response. */
 export interface VerifyOtpResponse {
+  /** / Short-lived access token. */
   accessToken: string;
+  /** / Long-lived refresh token used to obtain new access tokens. */
   refreshToken: string;
 }
 
+/** / Request to refresh tokens. */
 export interface RefreshRequest {
+  /** / Refresh token previously issued by the service. */
   refreshToken: string;
 }
 
+/** / Response containing a new token pair. */
 export interface RefreshResponse {
+  /** / New access token. */
   accessToken: string;
+  /** / New refresh token (may be rotated on each refresh). */
+  refreshToken: string;
+}
+
+/** / Telegram initialization response. */
+export interface TelegramInitResponse {
+  /** / Telegram OAuth authorization URL to open in the client. */
+  url: string;
+}
+
+/** / Telegram verification request. */
+export interface TelegramVerifyRequest {
+  /**
+   * / Raw query parameters returned by Telegram (must include `hash` and `auth_date`).
+   * / The service validates signature and freshness.
+   */
+  query: { [key: string]: string };
+}
+
+export interface TelegramVerifyRequest_QueryEntry {
+  key: string;
+  value: string;
+}
+
+/**
+ * / Telegram verification result.
+ * / The response depends on whether the account is fully linked.
+ */
+export interface TelegramVerifyResponse {
+  /** / Bot deep link to continue/complete the flow (e.g. provide phone, confirm consent). */
+  url?:
+    | string
+    | undefined;
+  /** / Access token issued when Telegram login can be completed immediately. */
+  accessToken?:
+    | string
+    | undefined;
+  /** / Refresh token issued when Telegram login can be completed immediately. */
+  refreshToken?: string | undefined;
+}
+
+/** / Request to complete Telegram login by providing additional data. */
+export interface TelegramCompleteRequest {
+  /** / Telegram session identifier obtained from the bot deep link. */
+  sessionId: string;
+  /** / Phone number to bind to the Telegram session (recommended E.164 format). */
+  phone: string;
+}
+
+/** / Telegram completion response. */
+export interface TelegramCompleteResponse {
+  /** / Session identifier that can be consumed to exchange for tokens. */
+  sessionId: string;
+}
+
+/** / Request to exchange a completed Telegram session for tokens. */
+export interface TelegramConsumeRequest {
+  /** / Session identifier from TelegramCompleteResponse. */
+  sessionId: string;
+}
+
+/** / Token pair returned after consuming a Telegram session. */
+export interface TelegramConsumeResponse {
+  /** / Access token. */
+  accessToken: string;
+  /** / Refresh token. */
   refreshToken: string;
 }
 
 export const AUTH_V1_PACKAGE_NAME = "auth.v1";
 
 export interface AuthServiceClient {
+  /**
+   * / Sends a one-time password (OTP) to the specified identifier (email/phone).
+   * / The identifier format and delivery channel are defined by `type`.
+   */
+
   sendOtp(request: SendOtpRequest): Observable<SendOtpResponse>;
 
+  /**
+   * / Verifies the OTP provided by the user.
+   * / On success returns a new access/refresh token pair.
+   */
+
   verifyOtp(request: VerifyOtpRequest): Observable<VerifyOtpResponse>;
 
+  /** / Exchanges a valid refresh token for a new access/refresh token pair. */
+
   refresh(request: RefreshRequest): Observable<RefreshResponse>;
+
+  /** / Initializes Telegram login flow and returns a Telegram authorization URL. */
+
+  telegramInit(request: Empty): Observable<TelegramInitResponse>;
+
+  /**
+   * / Verifies Telegram login payload (signature + auth_date) and starts/continues the flow.
+   * / Depending on the user state, may return tokens immediately or a bot deep link to complete signup.
+   */
+
+  telegramVerify(request: TelegramVerifyRequest): Observable<TelegramVerifyResponse>;
+
+  /** / Completes Telegram login flow by binding a phone number to the Telegram session. */
+
+  telegramComplete(request: TelegramCompleteRequest): Observable<TelegramCompleteResponse>;
+
+  /**
+   * / Consumes a completed Telegram session and returns access/refresh tokens.
+   * / Intended to be called once per session_id.
+   */
+
+  telegramConsume(request: TelegramConsumeRequest): Observable<TelegramConsumeResponse>;
 }
 
 export interface AuthServiceController {
+  /**
+   * / Sends a one-time password (OTP) to the specified identifier (email/phone).
+   * / The identifier format and delivery channel are defined by `type`.
+   */
+
   sendOtp(request: SendOtpRequest): Promise<SendOtpResponse> | Observable<SendOtpResponse> | SendOtpResponse;
 
+  /**
+   * / Verifies the OTP provided by the user.
+   * / On success returns a new access/refresh token pair.
+   */
+
   verifyOtp(request: VerifyOtpRequest): Promise<VerifyOtpResponse> | Observable<VerifyOtpResponse> | VerifyOtpResponse;
 
+  /** / Exchanges a valid refresh token for a new access/refresh token pair. */
+
   refresh(request: RefreshRequest): Promise<RefreshResponse> | Observable<RefreshResponse> | RefreshResponse;
+
+  /** / Initializes Telegram login flow and returns a Telegram authorization URL. */
+
+  telegramInit(request: Empty): Promise<TelegramInitResponse> | Observable<TelegramInitResponse> | TelegramInitResponse;
+
+  /**
+   * / Verifies Telegram login payload (signature + auth_date) and starts/continues the flow.
+   * / Depending on the user state, may return tokens immediately or a bot deep link to complete signup.
+   */
+
+  telegramVerify(
+    request: TelegramVerifyRequest,
+  ): Promise<TelegramVerifyResponse> | Observable<TelegramVerifyResponse> | TelegramVerifyResponse;
+
+  /** / Completes Telegram login flow by binding a phone number to the Telegram session. */
+
+  telegramComplete(
+    request: TelegramCompleteRequest,
+  ): Promise<TelegramCompleteResponse> | Observable<TelegramCompleteResponse> | TelegramCompleteResponse;
+
+  /**
+   * / Consumes a completed Telegram session and returns access/refresh tokens.
+   * / Intended to be called once per session_id.
+   */
+
+  telegramConsume(
+    request: TelegramConsumeRequest,
+  ): Promise<TelegramConsumeResponse> | Observable<TelegramConsumeResponse> | TelegramConsumeResponse;
 }
 
 export function AuthServiceControllerMethods() {
   return function (constructor: Function) {
-    const grpcMethods: string[] = ["sendOtp", "verifyOtp", "refresh"];
+    const grpcMethods: string[] = [
+      "sendOtp",
+      "verifyOtp",
+      "refresh",
+      "telegramInit",
+      "telegramVerify",
+      "telegramComplete",
+      "telegramConsume",
+    ];
     for (const method of grpcMethods) {
       const descriptor: any = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
       GrpcMethod("AuthService", method)(constructor.prototype[method], method, descriptor);

package/gen/google/protobuf/empty.ts

@@ -0,0 +1,23 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.10.1
+//   protoc               v3.21.12
+// source: google/protobuf/empty.proto
+
+/* eslint-disable */
+
+export const protobufPackage = "google.protobuf";
+
+/**
+ * A generic empty message that you can re-use to avoid defining duplicated
+ * empty messages in your APIs. A typical example is to use it as the request
+ * or the response type of an API method. For instance:
+ *
+ *     service Foo {
+ *       rpc Bar(google.protobuf.Empty) returns (google.protobuf.Empty);
+ *     }
+ */
+export interface Empty {
+}
+
+export const GOOGLE_PROTOBUF_PACKAGE_NAME = "google.protobuf";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lumina-cinema/contracts",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Protobuf definitions and generated Typescript types",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",

package/proto/auth.proto

@@ -2,37 +2,140 @@ syntax = "proto3";
 
 package auth.v1;
 
+import "google/protobuf/empty.proto";
+
 service AuthService {
+  /// Sends a one-time password (OTP) to the specified identifier (email/phone).
+  /// The identifier format and delivery channel are defined by `type`.
   rpc SendOtp (SendOtpRequest) returns (SendOtpResponse);
+
+  /// Verifies the OTP provided by the user.
+  /// On success returns a new access/refresh token pair.
   rpc VerifyOtp(VerifyOtpRequest) returns (VerifyOtpResponse);
+
+  /// Exchanges a valid refresh token for a new access/refresh token pair.
   rpc Refresh(RefreshRequest) returns (RefreshResponse);
+
+  /// Initializes Telegram login flow and returns a Telegram authorization URL.
+  rpc TelegramInit (google.protobuf.Empty) returns (TelegramInitResponse);
+
+  /// Verifies Telegram login payload (signature + auth_date) and starts/continues the flow.
+  /// Depending on the user state, may return tokens immediately or a bot deep link to complete signup.
+  rpc TelegramVerify (TelegramVerifyRequest) returns (TelegramVerifyResponse);
+
+  /// Completes Telegram login flow by binding a phone number to the Telegram session.
+  rpc TelegramComplete (TelegramCompleteRequest) returns (TelegramCompleteResponse);
+
+  /// Consumes a completed Telegram session and returns access/refresh tokens.
+  /// Intended to be called once per session_id.
+  rpc TelegramConsume (TelegramConsumeRequest) returns (TelegramConsumeResponse);
 }
 
+/// Request to send an OTP to an identifier (email/phone).
 message SendOtpRequest {
+  /// Target identifier to deliver OTP to (e.g. "+31612345678" or "user@example.com").
   string identifier = 1;
-  string type       = 2;
+
+  /// Identifier/delivery type. Recommended values: "phone" or "email".
+  string type = 2;
 }
 
+/// Send OTP result.
 message SendOtpResponse {
+  /// True if the OTP was accepted for delivery (does not necessarily guarantee delivery).
   bool ok = 1;
 }
 
+/// Request to verify an OTP for an identifier.
 message VerifyOtpRequest {
+  /// Identifier that received the OTP (must match the identifier used in SendOtp).
   string identifier = 1;
-  string type       = 2;
-  string code       = 3;
+
+  /// Identifier type used for delivery. Recommended values: "phone" or "email".
+  string type = 2;
+
+  /// OTP code entered by the user.
+  string code = 3;
 }
 
+/// Successful OTP verification response.
 message VerifyOtpResponse {
-  string access_token  = 1;
+  /// Short-lived access token.
+  string access_token = 1;
+
+  /// Long-lived refresh token used to obtain new access tokens.
   string refresh_token = 2;
 }
 
+/// Request to refresh tokens.
 message RefreshRequest {
+  /// Refresh token previously issued by the service.
   string refresh_token = 1;
 }
 
+/// Response containing a new token pair.
 message RefreshResponse {
-  string access_token  = 1;
+  /// New access token.
+  string access_token = 1;
+
+  /// New refresh token (may be rotated on each refresh).
+  string refresh_token = 2;
+}
+
+/// Telegram initialization response.
+message TelegramInitResponse {
+  /// Telegram OAuth authorization URL to open in the client.
+  string url = 1;
+}
+
+/// Telegram verification request.
+message TelegramVerifyRequest {
+  /// Raw query parameters returned by Telegram (must include `hash` and `auth_date`).
+  /// The service validates signature and freshness.
+  map<string, string> query = 1;
+}
+
+/// Telegram verification result.
+/// The response depends on whether the account is fully linked.
+message TelegramVerifyResponse {
+  oneof result {
+    /// Bot deep link to continue/complete the flow (e.g. provide phone, confirm consent).
+    string url = 1;
+
+    /// Access token issued when Telegram login can be completed immediately.
+    string access_token = 2;
+
+    /// Refresh token issued when Telegram login can be completed immediately.
+    string refresh_token = 3;
+  }
+}
+
+/// Request to complete Telegram login by providing additional data.
+message TelegramCompleteRequest {
+  /// Telegram session identifier obtained from the bot deep link.
+  string session_id = 1;
+
+  /// Phone number to bind to the Telegram session (recommended E.164 format).
+  string phone = 2;
+}
+
+/// Telegram completion response.
+message TelegramCompleteResponse {
+  /// Session identifier that can be consumed to exchange for tokens.
+  string session_id = 1;
+}
+
+/// Request to exchange a completed Telegram session for tokens.
+message TelegramConsumeRequest {
+  /// Session identifier from TelegramCompleteResponse.
+  string session_id = 1;
+}
+
+/// Token pair returned after consuming a Telegram session.
+message TelegramConsumeResponse {
+  /// Access token.
+  string access_token = 1;
+
+  /// Refresh token.
   string refresh_token = 2;
-}
+}