@lumina-cinema/contracts 1.1.3 → 1.1.5

package/gen/{account.ts → ts/account.ts}

@@ -10,94 +10,154 @@ import { Observable } from "rxjs";
 
 export const protobufPackage = "account.v1";
 
+/** Account roles enumerations. */
 export enum Role {
+  /** USER - Regular user account. */
   USER = 0,
+  /** ADMIN - Administrator account with elevated privileges. */
   ADMIN = 1,
   UNRECOGNIZED = -1,
 }
 
+/** Request to get account details for a specific user. */
 export interface GetAccountRequest {
+  /** The account's user identifier. */
   id: string;
 }
 
+/** Response containing basic account attributes and verification flags. */
 export interface GetAccountResponse {
+  /** User identifier. */
   id: string;
+  /** Account phone number (if any). */
   phone: string;
+  /** Account email address (if any). */
   email: string;
+  /** Whether the phone number has been verified. */
   isPhoneVerified: boolean;
+  /** Whether the email address has been verified. */
   isEmailVerified: boolean;
+  /** Account role (e.g. USER, ADMIN). */
   role: Role;
 }
 
+/** Request to initialize an email change flow. */
 export interface InitEmailChangeRequest {
+  /** New email address to set. */
   email: string;
+  /** User identifier for whom the change is requested. */
   userId: string;
 }
 
+/** Response for InitEmailChange indicating whether the initialization succeeded. */
 export interface InitEmailChangeResponse {
   ok: boolean;
 }
 
+/** Request to confirm an email change with a verification code. */
 export interface ConfirmEmailChangeRequest {
+  /** The email address being confirmed. */
   email: string;
+  /** Verification code sent to the email. */
   code: string;
+  /** Target user id for the email change. */
   userId: string;
 }
 
+/** Response for ConfirmEmailChange indicating success. */
 export interface ConfirmEmailChangeResponse {
   ok: boolean;
 }
 
+/** Request to initialize a phone change flow. */
 export interface InitPhoneChangeRequest {
+  /** New phone number to set (E.164 recommended). */
   phone: string;
+  /** User identifier for whom the change is requested. */
   userId: string;
 }
 
+/** Response for InitPhoneChange indicating whether the initialization succeeded. */
 export interface InitPhoneChangeResponse {
   ok: boolean;
 }
 
+/** Request to confirm a phone change with a verification code. */
 export interface ConfirmPhoneChangeRequest {
+  /** The phone number being confirmed. */
   phone: string;
+  /** Verification code sent to the phone. */
   code: string;
+  /** Target user id for the phone change. */
   userId: string;
 }
 
+/** Response for ConfirmPhoneChange indicating success. */
 export interface ConfirmPhoneChangeResponse {
   ok: boolean;
 }
 
 export const ACCOUNT_V1_PACKAGE_NAME = "account.v1";
 
+/**
+ * AccountService exposes methods to read account information and
+ * to manage verification flows when changing email or phone.
+ */
+
 export interface AccountServiceClient {
+  /** Retrieves account details by identifier. */
+
   getAccount(request: GetAccountRequest): Observable<GetAccountResponse>;
 
+  /** Starts the email change flow (sends a verification code to the new email). */
+
   initEmailChange(request: InitEmailChangeRequest): Observable<InitEmailChangeResponse>;
 
+  /** Confirms the email change using a verification code. */
+
   confirmEmailChange(request: ConfirmEmailChangeRequest): Observable<ConfirmEmailChangeResponse>;
 
+  /** Starts the phone change flow (sends a verification code to the new phone). */
+
   initPhoneChange(request: InitPhoneChangeRequest): Observable<InitPhoneChangeResponse>;
 
+  /** Confirms the phone change using a verification code. */
+
   confirmPhoneChange(request: ConfirmPhoneChangeRequest): Observable<ConfirmPhoneChangeResponse>;
 }
 
+/**
+ * AccountService exposes methods to read account information and
+ * to manage verification flows when changing email or phone.
+ */
+
 export interface AccountServiceController {
+  /** Retrieves account details by identifier. */
+
   getAccount(
     request: GetAccountRequest,
   ): Promise<GetAccountResponse> | Observable<GetAccountResponse> | GetAccountResponse;
 
+  /** Starts the email change flow (sends a verification code to the new email). */
+
   initEmailChange(
     request: InitEmailChangeRequest,
   ): Promise<InitEmailChangeResponse> | Observable<InitEmailChangeResponse> | InitEmailChangeResponse;
 
+  /** Confirms the email change using a verification code. */
+
   confirmEmailChange(
     request: ConfirmEmailChangeRequest,
   ): Promise<ConfirmEmailChangeResponse> | Observable<ConfirmEmailChangeResponse> | ConfirmEmailChangeResponse;
 
+  /** Starts the phone change flow (sends a verification code to the new phone). */
+
   initPhoneChange(
     request: InitPhoneChangeRequest,
   ): Promise<InitPhoneChangeResponse> | Observable<InitPhoneChangeResponse> | InitPhoneChangeResponse;
 
+  /** Confirms the phone change using a verification code. */
+
   confirmPhoneChange(
     request: ConfirmPhoneChangeRequest,
   ): Promise<ConfirmPhoneChangeResponse> | Observable<ConfirmPhoneChangeResponse> | ConfirmPhoneChangeResponse;

package/gen/ts/auth.ts

@@ -0,0 +1,290 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.10.1
+//   protoc               v3.21.12
+// source: auth.proto
+
+/* 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 or phone). */
+export interface SendOtpRequest {
+  /**
+   * Target identifier to deliver the OTP (for example "+31612345678" or
+   * "user@example.com").
+   */
+  identifier: string;
+  /** Delivery type for the identifier: commonly "phone" or "email". */
+  type: string;
+}
+
+/** Response for SendOtp request. */
+export interface SendOtpResponse {
+  /**
+   * True when the OTP request was accepted for delivery. This does not
+   * guarantee that the recipient has received the message.
+   */
+  ok: boolean;
+}
+
+/** Request to verify an OTP code for a previously targeted identifier. */
+export interface VerifyOtpRequest {
+  /** Identifier that originally received the OTP (must match SendOtp identifier). */
+  identifier: string;
+  /** Delivery type used when sending the OTP: "phone" or "email". */
+  type: string;
+  /** OTP code provided by the client. */
+  code: string;
+}
+
+/** Response returned when an OTP was successfully verified. */
+export interface VerifyOtpResponse {
+  /** Short-lived access token to authenticate future requests. */
+  accessToken: string;
+  /** Long-lived refresh token used to obtain new access tokens. */
+  refreshToken: string;
+}
+
+/** Request to refresh an access token using a refresh token. */
+export interface RefreshRequest {
+  /** The refresh token previously issued to the client. */
+  refreshToken: string;
+}
+
+/** Response containing a newly issued token pair. */
+export interface RefreshResponse {
+  /** Newly issued access token. */
+  accessToken: string;
+  /** Newly issued refresh token (may be rotated). */
+  refreshToken: string;
+}
+
+/** Response for Telegram initialization, containing an authorization URL. */
+export interface TelegramInitResponse {
+  /** HTTPS URL that the client should open for Telegram authorization. */
+  url: string;
+}
+
+/**
+ * Request carrying raw Telegram query parameters returned by Telegram
+ * during OAuth-style authentication. The service validates signature
+ * and freshness of the parameters.
+ */
+export interface TelegramVerifyRequest {
+  /** Raw query parameters returned by Telegram (must include `hash` and `auth_date`). */
+  query: { [key: string]: string };
+}
+
+export interface TelegramVerifyRequest_QueryEntry {
+  key: string;
+  value: string;
+}
+
+/**
+ * Result of Telegram verification. The oneof allows returning either a
+ * deep link instructing the client to continue the flow, or tokens when
+ * login can be completed immediately.
+ */
+export interface TelegramVerifyResponse {
+  /**
+   * Bot deep link URL to continue or complete the flow (for example
+   * to provide a phone number or 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 a Telegram login by supplying additional required data. */
+export interface TelegramCompleteRequest {
+  /** Session identifier created and returned by the Telegram bot flow. */
+  sessionId: string;
+  /** Optional phone number to bind to the Telegram session (E.164 recommended). */
+  phone: string;
+}
+
+/**
+ * Response returned after completing a Telegram session; the client can
+ * use the session id to exchange it for tokens.
+ */
+export interface TelegramCompleteResponse {
+  /** Session identifier that can be consumed to obtain tokens. */
+  sessionId: string;
+}
+
+/** Request to exchange a completed Telegram session for token pair. */
+export interface TelegramConsumeRequest {
+  /** Session identifier previously returned from TelegramCompleteResponse. */
+  sessionId: string;
+}
+
+/** Token pair returned when consuming a Telegram session. */
+export interface TelegramConsumeResponse {
+  /** Access token for authenticated requests. */
+  accessToken: string;
+  /** Refresh token to obtain new access tokens. */
+  refreshToken: string;
+}
+
+export const AUTH_V1_PACKAGE_NAME = "auth.v1";
+
+/**
+ * AuthService provides authentication-related operations such as sending
+ * and verifying OTPs, issuing and refreshing tokens, and handling the
+ * Telegram login flow.
+ */
+
+export interface AuthServiceClient {
+  /**
+   * Sends a one-time password (OTP) to the given identifier.
+   * The identifier typically represents either a phone number or an email
+   * address and `type` indicates which delivery channel to use.
+   */
+
+  sendOtp(request: SendOtpRequest): Observable<SendOtpResponse>;
+
+  /**
+   * Verifies the one-time password provided by a client. On success the
+   * service issues a new access and refresh token pair for the authenticated user.
+   */
+
+  verifyOtp(request: VerifyOtpRequest): Observable<VerifyOtpResponse>;
+
+  /**
+   * Exchanges a refresh token for a new access/refresh token pair. The
+   * service may rotate refresh tokens depending on policy.
+   */
+
+  refresh(request: RefreshRequest): Observable<RefreshResponse>;
+
+  /**
+   * Starts the Telegram login flow and returns an authorization URL that
+   * the client should open to continue the flow in Telegram.
+   */
+
+  telegramInit(request: Empty): Observable<TelegramInitResponse>;
+
+  /**
+   * Validates the Telegram login payload (signature and auth_date) and
+   * progresses the login flow. Depending on the account state this RPC
+   * may return immediate tokens or a bot deep link instructing the user
+   * how to complete signup.
+   */
+
+  telegramVerify(request: TelegramVerifyRequest): Observable<TelegramVerifyResponse>;
+
+  /**
+   * Completes Telegram-based login by binding additional data (for example,
+   * a phone number) to a previously started Telegram session.
+   */
+
+  telegramComplete(request: TelegramCompleteRequest): Observable<TelegramCompleteResponse>;
+
+  /**
+   * Consumes a completed Telegram session and issues an access/refresh
+   * token pair. This endpoint should be called once per session identifier.
+   */
+
+  telegramConsume(request: TelegramConsumeRequest): Observable<TelegramConsumeResponse>;
+}
+
+/**
+ * AuthService provides authentication-related operations such as sending
+ * and verifying OTPs, issuing and refreshing tokens, and handling the
+ * Telegram login flow.
+ */
+
+export interface AuthServiceController {
+  /**
+   * Sends a one-time password (OTP) to the given identifier.
+   * The identifier typically represents either a phone number or an email
+   * address and `type` indicates which delivery channel to use.
+   */
+
+  sendOtp(request: SendOtpRequest): Promise<SendOtpResponse> | Observable<SendOtpResponse> | SendOtpResponse;
+
+  /**
+   * Verifies the one-time password provided by a client. On success the
+   * service issues a new access and refresh token pair for the authenticated user.
+   */
+
+  verifyOtp(request: VerifyOtpRequest): Promise<VerifyOtpResponse> | Observable<VerifyOtpResponse> | VerifyOtpResponse;
+
+  /**
+   * Exchanges a refresh token for a new access/refresh token pair. The
+   * service may rotate refresh tokens depending on policy.
+   */
+
+  refresh(request: RefreshRequest): Promise<RefreshResponse> | Observable<RefreshResponse> | RefreshResponse;
+
+  /**
+   * Starts the Telegram login flow and returns an authorization URL that
+   * the client should open to continue the flow in Telegram.
+   */
+
+  telegramInit(request: Empty): Promise<TelegramInitResponse> | Observable<TelegramInitResponse> | TelegramInitResponse;
+
+  /**
+   * Validates the Telegram login payload (signature and auth_date) and
+   * progresses the login flow. Depending on the account state this RPC
+   * may return immediate tokens or a bot deep link instructing the user
+   * how to complete signup.
+   */
+
+  telegramVerify(
+    request: TelegramVerifyRequest,
+  ): Promise<TelegramVerifyResponse> | Observable<TelegramVerifyResponse> | TelegramVerifyResponse;
+
+  /**
+   * Completes Telegram-based login by binding additional data (for example,
+   * a phone number) to a previously started Telegram session.
+   */
+
+  telegramComplete(
+    request: TelegramCompleteRequest,
+  ): Promise<TelegramCompleteResponse> | Observable<TelegramCompleteResponse> | TelegramCompleteResponse;
+
+  /**
+   * Consumes a completed Telegram session and issues an access/refresh
+   * token pair. This endpoint should be called once per session identifier.
+   */
+
+  telegramConsume(
+    request: TelegramConsumeRequest,
+  ): Promise<TelegramConsumeResponse> | Observable<TelegramConsumeResponse> | TelegramConsumeResponse;
+}
+
+export function AuthServiceControllerMethods() {
+  return function (constructor: Function) {
+    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);
+    }
+    const grpcStreamMethods: string[] = [];
+    for (const method of grpcStreamMethods) {
+      const descriptor: any = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+      GrpcStreamMethod("AuthService", method)(constructor.prototype[method], method, descriptor);
+    }
+  };
+}
+
+export const AUTH_SERVICE_NAME = "AuthService";

package/gen/ts/media.ts

@@ -0,0 +1,76 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.10.1
+//   protoc               v3.21.12
+// source: media.proto
+
+/* eslint-disable */
+import { GrpcMethod, GrpcStreamMethod } from "@nestjs/microservices";
+import { Observable } from "rxjs";
+
+export const protobufPackage = "media.v1";
+
+export interface UploadRequest {
+  fileName: string;
+  folder: string;
+  contentType: string;
+  data: Uint8Array;
+  resizeWidth?: number | undefined;
+  resizeHeight?: number | undefined;
+}
+
+export interface UploadResponse {
+  key: string;
+}
+
+export interface GetRequest {
+  key: string;
+}
+
+export interface GetResponse {
+  data: Uint8Array;
+  contentType: string;
+}
+
+export interface DeleteRequest {
+  key: string;
+}
+
+export interface DeleteResponse {
+  ok: boolean;
+}
+
+export const MEDIA_V1_PACKAGE_NAME = "media.v1";
+
+export interface MediaServiceClient {
+  upload(request: UploadRequest): Observable<UploadResponse>;
+
+  get(request: GetRequest): Observable<GetResponse>;
+
+  delete(request: DeleteRequest): Observable<DeleteResponse>;
+}
+
+export interface MediaServiceController {
+  upload(request: UploadRequest): Promise<UploadResponse> | Observable<UploadResponse> | UploadResponse;
+
+  get(request: GetRequest): Promise<GetResponse> | Observable<GetResponse> | GetResponse;
+
+  delete(request: DeleteRequest): Promise<DeleteResponse> | Observable<DeleteResponse> | DeleteResponse;
+}
+
+export function MediaServiceControllerMethods() {
+  return function (constructor: Function) {
+    const grpcMethods: string[] = ["upload", "get", "delete"];
+    for (const method of grpcMethods) {
+      const descriptor: any = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+      GrpcMethod("MediaService", method)(constructor.prototype[method], method, descriptor);
+    }
+    const grpcStreamMethods: string[] = [];
+    for (const method of grpcStreamMethods) {
+      const descriptor: any = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+      GrpcStreamMethod("MediaService", method)(constructor.prototype[method], method, descriptor);
+    }
+  };
+}
+
+export const MEDIA_SERVICE_NAME = "MediaService";

package/gen/ts/users.ts

@@ -0,0 +1,126 @@
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.10.1
+//   protoc               v3.21.12
+// source: users.proto
+
+/* eslint-disable */
+import { GrpcMethod, GrpcStreamMethod } from "@nestjs/microservices";
+import { Observable } from "rxjs";
+
+export const protobufPackage = "users.v1";
+
+/** Request to get the current user's profile. */
+export interface GetMeRequest {
+  /** The identifier of the user to fetch (typically from auth token). */
+  id: string;
+}
+
+/** Response containing the requested user profile. */
+export interface GetMeResponse {
+  /** The user profile. */
+  user: User | undefined;
+}
+
+/** Request to create a user record. */
+export interface CreateUserRequest {
+  /** Unique identifier for the new user (typically assigned by auth). */
+  id: string;
+}
+
+/** Response for CreateUser operation. */
+export interface CreateUserResponse {
+  /** True when the user was created successfully. */
+  ok: boolean;
+}
+
+/** Request to update a user partially. Fields left unset are not modified. */
+export interface PatchUserRequest {
+  /** Target user id to patch. */
+  userId: string;
+  /** Optional new display name for the user. */
+  name?:
+    | string
+    | undefined;
+  /** Optional new avatar URL. */
+  avatar?: string | undefined;
+}
+
+/** Response for PatchUser operation. */
+export interface PatchUserResponse {
+  /** True when the patch operation succeeded. */
+  ok: boolean;
+}
+
+/** User profile representation. */
+export interface User {
+  /** Unique user identifier. */
+  id: string;
+  /** Optional display name. */
+  name?:
+    | string
+    | undefined;
+  /** Optional email address associated with the user. */
+  email?:
+    | string
+    | undefined;
+  /** Optional phone number (E.164 recommended). */
+  phone?:
+    | string
+    | undefined;
+  /** Optional avatar image URL. */
+  avatar?: string | undefined;
+}
+
+export const USERS_V1_PACKAGE_NAME = "users.v1";
+
+/** UsersService exposes endpoints for basic user profile operations. */
+
+export interface UsersServiceClient {
+  /** Retrieves the profile of the current user. */
+
+  getMe(request: GetMeRequest): Observable<GetMeResponse>;
+
+  /** Creates a new user record using the provided identifier. */
+
+  createUser(request: CreateUserRequest): Observable<CreateUserResponse>;
+
+  /** Partially updates user profile fields such as name and avatar. */
+
+  patchUser(request: PatchUserRequest): Observable<PatchUserResponse>;
+}
+
+/** UsersService exposes endpoints for basic user profile operations. */
+
+export interface UsersServiceController {
+  /** Retrieves the profile of the current user. */
+
+  getMe(request: GetMeRequest): Promise<GetMeResponse> | Observable<GetMeResponse> | GetMeResponse;
+
+  /** Creates a new user record using the provided identifier. */
+
+  createUser(
+    request: CreateUserRequest,
+  ): Promise<CreateUserResponse> | Observable<CreateUserResponse> | CreateUserResponse;
+
+  /** Partially updates user profile fields such as name and avatar. */
+
+  patchUser(request: PatchUserRequest): Promise<PatchUserResponse> | Observable<PatchUserResponse> | PatchUserResponse;
+}
+
+export function UsersServiceControllerMethods() {
+  return function (constructor: Function) {
+    const grpcMethods: string[] = ["getMe", "createUser", "patchUser"];
+    for (const method of grpcMethods) {
+      const descriptor: any = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+      GrpcMethod("UsersService", method)(constructor.prototype[method], method, descriptor);
+    }
+    const grpcStreamMethods: string[] = [];
+    for (const method of grpcStreamMethods) {
+      const descriptor: any = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+      GrpcStreamMethod("UsersService", method)(constructor.prototype[method], method, descriptor);
+    }
+  };
+}
+
+export const USERS_SERVICE_NAME = "UsersService";

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@lumina-cinema/contracts",
-  "version": "1.1.3",
+  "version": "1.1.5",
   "description": "Protobuf definitions and generated Typescript types",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "scripts": {
     "build": "tsc -p tsconfig.build.json",
-    "generate": "protoc -I ./proto ./proto/*.proto --ts_proto_out=./gen --ts_proto_opt=nestJs=true,package=omit "
+    "generate": "protoc -I ./proto ./proto/*.proto --ts_proto_out=./gen/ts --ts_proto_opt=nestJs=true,package=omit "
   },
   "files": [
     "proto",