geniebox-shared-lib 2.5.3 → 2.5.5

package/dist/chat.interface.d.ts

@@ -32,6 +32,15 @@ export interface CreateChatRequest {
         [key: string]: any;
     } | undefined;
 }
+export interface UpdateChatRequest {
+    id: string;
+    /** For authorization check */
+    userId: string;
+    title?: string | undefined;
+    metadata?: {
+        [key: string]: any;
+    } | undefined;
+}
 export interface GetChatRequest {
     id: string;
     /** For authorization check */
@@ -77,6 +86,7 @@ export declare const CHAT_PACKAGE_NAME = "chat";
 export declare const Chat: MessageFns<Chat>;
 export declare const ChatMessage: MessageFns<ChatMessage>;
 export declare const CreateChatRequest: MessageFns<CreateChatRequest>;
+export declare const UpdateChatRequest: MessageFns<UpdateChatRequest>;
 export declare const GetChatRequest: MessageFns<GetChatRequest>;
 export declare const ListChatsRequest: MessageFns<ListChatsRequest>;
 export declare const DeleteChatRequest: MessageFns<DeleteChatRequest>;
@@ -89,6 +99,7 @@ export interface ChatServiceClient {
     getChat(request: GetChatRequest, metadata?: Metadata): Observable<Chat>;
     listChats(request: ListChatsRequest, metadata?: Metadata): Observable<ChatsResponse>;
     deleteChat(request: DeleteChatRequest, metadata?: Metadata): Observable<Empty>;
+    updateChat(request: UpdateChatRequest, metadata?: Metadata): Observable<Chat>;
     addMessage(request: AddMessageRequest, metadata?: Metadata): Observable<ChatMessage>;
     getMessages(request: GetMessagesRequest, metadata?: Metadata): Observable<MessagesResponse>;
 }
@@ -97,6 +108,7 @@ export interface ChatServiceController {
     getChat(request: GetChatRequest, metadata?: Metadata): Promise<Chat> | Observable<Chat> | Chat;
     listChats(request: ListChatsRequest, metadata?: Metadata): Promise<ChatsResponse> | Observable<ChatsResponse> | ChatsResponse;
     deleteChat(request: DeleteChatRequest, metadata?: Metadata): void;
+    updateChat(request: UpdateChatRequest, metadata?: Metadata): Promise<Chat> | Observable<Chat> | Chat;
     addMessage(request: AddMessageRequest, metadata?: Metadata): Promise<ChatMessage> | Observable<ChatMessage> | ChatMessage;
     getMessages(request: GetMessagesRequest, metadata?: Metadata): Promise<MessagesResponse> | Observable<MessagesResponse> | MessagesResponse;
 }
@@ -140,6 +152,15 @@ export declare const ChatServiceService: {
         readonly responseSerialize: (value: Empty) => Buffer;
         readonly responseDeserialize: (value: Buffer) => Empty;
     };
+    readonly updateChat: {
+        readonly path: "/chat.ChatService/updateChat";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UpdateChatRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => UpdateChatRequest;
+        readonly responseSerialize: (value: Chat) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => Chat;
+    };
     readonly addMessage: {
         readonly path: "/chat.ChatService/addMessage";
         readonly requestStream: false;
@@ -164,6 +185,7 @@ export interface ChatServiceServer extends UntypedServiceImplementation {
     getChat: handleUnaryCall<GetChatRequest, Chat>;
     listChats: handleUnaryCall<ListChatsRequest, ChatsResponse>;
     deleteChat: handleUnaryCall<DeleteChatRequest, Empty>;
+    updateChat: handleUnaryCall<UpdateChatRequest, Chat>;
     addMessage: handleUnaryCall<AddMessageRequest, ChatMessage>;
     getMessages: handleUnaryCall<GetMessagesRequest, MessagesResponse>;
 }

package/dist/chat.interface.js

@@ -5,7 +5,7 @@
 //   protoc               v5.28.2
 // source: chat.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ChatServiceService = exports.CHAT_SERVICE_NAME = exports.MessagesResponse = exports.ChatsResponse = exports.GetMessagesRequest = exports.AddMessageRequest = exports.DeleteChatRequest = exports.ListChatsRequest = exports.GetChatRequest = exports.CreateChatRequest = exports.ChatMessage = exports.Chat = exports.CHAT_PACKAGE_NAME = exports.protobufPackage = void 0;
+exports.ChatServiceService = exports.CHAT_SERVICE_NAME = exports.MessagesResponse = exports.ChatsResponse = exports.GetMessagesRequest = exports.AddMessageRequest = exports.DeleteChatRequest = exports.ListChatsRequest = exports.GetChatRequest = exports.UpdateChatRequest = exports.CreateChatRequest = exports.ChatMessage = exports.Chat = exports.CHAT_PACKAGE_NAME = exports.protobufPackage = void 0;
 exports.ChatServiceControllerMethods = ChatServiceControllerMethods;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
@@ -234,6 +234,69 @@ exports.CreateChatRequest = {
         return message;
     },
 };
+function createBaseUpdateChatRequest() {
+    return { id: "", userId: "" };
+}
+exports.UpdateChatRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.id !== "") {
+            writer.uint32(10).string(message.id);
+        }
+        if (message.userId !== "") {
+            writer.uint32(18).string(message.userId);
+        }
+        if (message.title !== undefined) {
+            writer.uint32(26).string(message.title);
+        }
+        if (message.metadata !== undefined) {
+            struct_interface_1.Struct.encode(struct_interface_1.Struct.wrap(message.metadata), writer.uint32(34).fork()).join();
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseUpdateChatRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.id = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.userId = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.title = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.metadata = struct_interface_1.Struct.unwrap(struct_interface_1.Struct.decode(reader, reader.uint32()));
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
 function createBaseGetChatRequest() {
     return { id: "", userId: "" };
 }
@@ -598,7 +661,15 @@ exports.MessagesResponse = {
 protobufjs_1.wrappers[".google.protobuf.Struct"] = { fromObject: struct_interface_1.Struct.wrap, toObject: struct_interface_1.Struct.unwrap };
 function ChatServiceControllerMethods() {
     return function (constructor) {
-        const grpcMethods = ["createChat", "getChat", "listChats", "deleteChat", "addMessage", "getMessages"];
+        const grpcMethods = [
+            "createChat",
+            "getChat",
+            "listChats",
+            "deleteChat",
+            "updateChat",
+            "addMessage",
+            "getMessages",
+        ];
         for (const method of grpcMethods) {
             const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
             (0, microservices_1.GrpcMethod)("ChatService", method)(constructor.prototype[method], method, descriptor);
@@ -648,6 +719,15 @@ exports.ChatServiceService = {
         responseSerialize: (value) => Buffer.from(empty_interface_1.Empty.encode(value).finish()),
         responseDeserialize: (value) => empty_interface_1.Empty.decode(value),
     },
+    updateChat: {
+        path: "/chat.ChatService/updateChat",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(exports.UpdateChatRequest.encode(value).finish()),
+        requestDeserialize: (value) => exports.UpdateChatRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(exports.Chat.encode(value).finish()),
+        responseDeserialize: (value) => exports.Chat.decode(value),
+    },
     addMessage: {
         path: "/chat.ChatService/addMessage",
         requestStream: false,

package/dist/event.interface.d.ts

@@ -1,5 +1,5 @@
 import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
-import type { handleServerStreamingCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
+import type { handleServerStreamingCall, handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
 import { Observable } from "rxjs";
 export declare const protobufPackage = "event";
 export interface SubscribeRequest {
@@ -10,14 +10,35 @@ export interface EventMessage {
     data: string;
     requestId: string;
 }
+export interface EmitToUserRequest {
+    userId: string;
+    channel: string;
+    data: string;
+    requestId: string;
+}
+export interface BroadcastRequest {
+    channel: string;
+    data: string;
+    requestId: string;
+}
+export interface EmitResponse {
+    success: boolean;
+}
 export declare const EVENT_PACKAGE_NAME = "event";
 export declare const SubscribeRequest: MessageFns<SubscribeRequest>;
 export declare const EventMessage: MessageFns<EventMessage>;
+export declare const EmitToUserRequest: MessageFns<EmitToUserRequest>;
+export declare const BroadcastRequest: MessageFns<BroadcastRequest>;
+export declare const EmitResponse: MessageFns<EmitResponse>;
 export interface EventServiceClient {
     subscribe(request: SubscribeRequest, metadata?: Metadata): Observable<EventMessage>;
+    emitToUser(request: EmitToUserRequest, metadata?: Metadata): Observable<EmitResponse>;
+    broadcast(request: BroadcastRequest, metadata?: Metadata): Observable<EmitResponse>;
 }
 export interface EventServiceController {
     subscribe(request: SubscribeRequest, metadata?: Metadata): Observable<EventMessage>;
+    emitToUser(request: EmitToUserRequest, metadata?: Metadata): Promise<EmitResponse> | Observable<EmitResponse> | EmitResponse;
+    broadcast(request: BroadcastRequest, metadata?: Metadata): Promise<EmitResponse> | Observable<EmitResponse> | EmitResponse;
 }
 export declare function EventServiceControllerMethods(): (constructor: Function) => void;
 export declare const EVENT_SERVICE_NAME = "EventService";
@@ -32,9 +53,29 @@ export declare const EventServiceService: {
         readonly responseSerialize: (value: EventMessage) => Buffer;
         readonly responseDeserialize: (value: Buffer) => EventMessage;
     };
+    readonly emitToUser: {
+        readonly path: "/event.EventService/emitToUser";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: EmitToUserRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => EmitToUserRequest;
+        readonly responseSerialize: (value: EmitResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => EmitResponse;
+    };
+    readonly broadcast: {
+        readonly path: "/event.EventService/broadcast";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: BroadcastRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => BroadcastRequest;
+        readonly responseSerialize: (value: EmitResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => EmitResponse;
+    };
 };
 export interface EventServiceServer extends UntypedServiceImplementation {
     subscribe: handleServerStreamingCall<SubscribeRequest, EventMessage>;
+    emitToUser: handleUnaryCall<EmitToUserRequest, EmitResponse>;
+    broadcast: handleUnaryCall<BroadcastRequest, EmitResponse>;
 }
 export interface MessageFns<T> {
     encode(message: T, writer?: BinaryWriter): BinaryWriter;

package/dist/event.interface.js

@@ -5,7 +5,7 @@
 //   protoc               v5.28.2
 // source: event.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.EventServiceService = exports.EVENT_SERVICE_NAME = exports.EventMessage = exports.SubscribeRequest = exports.EVENT_PACKAGE_NAME = exports.protobufPackage = void 0;
+exports.EventServiceService = exports.EVENT_SERVICE_NAME = exports.EmitResponse = exports.BroadcastRequest = exports.EmitToUserRequest = exports.EventMessage = exports.SubscribeRequest = exports.EVENT_PACKAGE_NAME = exports.protobufPackage = void 0;
 exports.EventServiceControllerMethods = EventServiceControllerMethods;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
@@ -98,9 +98,158 @@ exports.EventMessage = {
         return message;
     },
 };
+function createBaseEmitToUserRequest() {
+    return { userId: "", channel: "", data: "", requestId: "" };
+}
+exports.EmitToUserRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.userId !== "") {
+            writer.uint32(10).string(message.userId);
+        }
+        if (message.channel !== "") {
+            writer.uint32(18).string(message.channel);
+        }
+        if (message.data !== "") {
+            writer.uint32(26).string(message.data);
+        }
+        if (message.requestId !== "") {
+            writer.uint32(34).string(message.requestId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEmitToUserRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.userId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.channel = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.data = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 34) {
+                        break;
+                    }
+                    message.requestId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseBroadcastRequest() {
+    return { channel: "", data: "", requestId: "" };
+}
+exports.BroadcastRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.channel !== "") {
+            writer.uint32(10).string(message.channel);
+        }
+        if (message.data !== "") {
+            writer.uint32(18).string(message.data);
+        }
+        if (message.requestId !== "") {
+            writer.uint32(26).string(message.requestId);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseBroadcastRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.channel = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.data = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.requestId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseEmitResponse() {
+    return { success: false };
+}
+exports.EmitResponse = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.success !== false) {
+            writer.uint32(8).bool(message.success);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof wire_1.BinaryReader ? input : new wire_1.BinaryReader(input);
+        const end = length === undefined ? reader.len : reader.pos + length;
+        const message = createBaseEmitResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.success = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
 function EventServiceControllerMethods() {
     return function (constructor) {
-        const grpcMethods = ["subscribe"];
+        const grpcMethods = ["subscribe", "emitToUser", "broadcast"];
         for (const method of grpcMethods) {
             const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
             (0, microservices_1.GrpcMethod)("EventService", method)(constructor.prototype[method], method, descriptor);
@@ -123,4 +272,22 @@ exports.EventServiceService = {
         responseSerialize: (value) => Buffer.from(exports.EventMessage.encode(value).finish()),
         responseDeserialize: (value) => exports.EventMessage.decode(value),
     },
+    emitToUser: {
+        path: "/event.EventService/emitToUser",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(exports.EmitToUserRequest.encode(value).finish()),
+        requestDeserialize: (value) => exports.EmitToUserRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(exports.EmitResponse.encode(value).finish()),
+        responseDeserialize: (value) => exports.EmitResponse.decode(value),
+    },
+    broadcast: {
+        path: "/event.EventService/broadcast",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(exports.BroadcastRequest.encode(value).finish()),
+        requestDeserialize: (value) => exports.BroadcastRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(exports.EmitResponse.encode(value).finish()),
+        responseDeserialize: (value) => exports.EmitResponse.decode(value),
+    },
 };

package/dist/generation.client.js

@@ -21,8 +21,7 @@ let GenerationClient = GenerationClient_1 = class GenerationClient {
         this.logger = new common_1.Logger(GenerationClient_1.name);
     }
     onModuleInit() {
-        this.generationClient =
-            this.client.getService("GenerationService");
+        this.generationClient = this.client.getService("GenerationService");
         this.logger.log("GenerationServiceClient initialized");
     }
     get service() {