geniebox-shared-lib 2.0.3 → 2.1.1

package/dist/response.client.js

@@ -0,0 +1,43 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ResponseClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseClient = void 0;
+const common_1 = require("@nestjs/common");
+let ResponseClient = ResponseClient_1 = class ResponseClient {
+    constructor(client) {
+        this.client = client;
+        this.logger = new common_1.Logger(ResponseClient_1.name);
+    }
+    onModuleInit() {
+        this.responseClient =
+            this.client.getService("ResponseService");
+        this.logger.log("ResponseServiceClient initialized");
+    }
+    get service() {
+        if (!this.responseClient) {
+            throw new common_1.InternalServerErrorException("ResponseService is not initialized yet");
+        }
+        return this.responseClient;
+    }
+    isReady() {
+        return !!this.responseClient;
+    }
+};
+exports.ResponseClient = ResponseClient;
+exports.ResponseClient = ResponseClient = ResponseClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)("RESPONSE_PACKAGE")),
+    __metadata("design:paramtypes", [Object])
+], ResponseClient);

package/dist/response.interface.d.ts

@@ -0,0 +1,75 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { handleServerStreamingCall, handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Observable } from "rxjs";
+export declare const protobufPackage = "response";
+export interface StreamUpdate {
+    requestId: string;
+    /** start, data, done, error */
+    type: string;
+    /** JSON data */
+    data: string;
+    /** chunk number */
+    chunk: number;
+    timestamp: string;
+}
+export interface ProcessResponseRequest {
+    /** ID from RabbitMQ */
+    correlationId: string;
+    /** JSON response data */
+    data: string;
+    /** error, if any */
+    error: string;
+    /** this is a stream chunk */
+    isStreamChunk: boolean;
+}
+export interface StreamUpdatesRequest {
+    requestId: string;
+}
+export interface ProcessResponseResponse {
+    success: boolean;
+    error: string;
+}
+export declare const RESPONSE_PACKAGE_NAME = "response";
+export declare const StreamUpdate: MessageFns<StreamUpdate>;
+export declare const ProcessResponseRequest: MessageFns<ProcessResponseRequest>;
+export declare const StreamUpdatesRequest: MessageFns<StreamUpdatesRequest>;
+export declare const ProcessResponseResponse: MessageFns<ProcessResponseResponse>;
+export interface ResponseServiceClient {
+    processResponse(request: ProcessResponseRequest, metadata?: Metadata): Observable<ProcessResponseResponse>;
+    getStreamUpdates(request: StreamUpdatesRequest, metadata?: Metadata): Observable<StreamUpdate>;
+}
+export interface ResponseServiceController {
+    processResponse(request: ProcessResponseRequest, metadata?: Metadata): Promise<ProcessResponseResponse> | Observable<ProcessResponseResponse> | ProcessResponseResponse;
+    getStreamUpdates(request: StreamUpdatesRequest, metadata?: Metadata): Observable<StreamUpdate>;
+}
+export declare function ResponseServiceControllerMethods(): (constructor: Function) => void;
+export declare const RESPONSE_SERVICE_NAME = "ResponseService";
+export type ResponseServiceService = typeof ResponseServiceService;
+export declare const ResponseServiceService: {
+    readonly processResponse: {
+        readonly path: "/response.ResponseService/ProcessResponse";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: ProcessResponseRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => ProcessResponseRequest;
+        readonly responseSerialize: (value: ProcessResponseResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => ProcessResponseResponse;
+    };
+    readonly getStreamUpdates: {
+        readonly path: "/response.ResponseService/GetStreamUpdates";
+        readonly requestStream: false;
+        readonly responseStream: true;
+        readonly requestSerialize: (value: StreamUpdatesRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => StreamUpdatesRequest;
+        readonly responseSerialize: (value: StreamUpdate) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => StreamUpdate;
+    };
+};
+export interface ResponseServiceServer extends UntypedServiceImplementation {
+    processResponse: handleUnaryCall<ProcessResponseRequest, ProcessResponseResponse>;
+    getStreamUpdates: handleServerStreamingCall<StreamUpdatesRequest, StreamUpdate>;
+}
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}

package/dist/response.interface.js

@@ -0,0 +1,261 @@
+"use strict";
+// Code generated by protoc-gen-ts_proto. DO NOT EDIT.
+// versions:
+//   protoc-gen-ts_proto  v2.7.7
+//   protoc               v5.28.2
+// source: response.proto
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResponseServiceService = exports.RESPONSE_SERVICE_NAME = exports.ProcessResponseResponse = exports.StreamUpdatesRequest = exports.ProcessResponseRequest = exports.StreamUpdate = exports.RESPONSE_PACKAGE_NAME = exports.protobufPackage = void 0;
+exports.ResponseServiceControllerMethods = ResponseServiceControllerMethods;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const microservices_1 = require("@nestjs/microservices");
+exports.protobufPackage = "response";
+exports.RESPONSE_PACKAGE_NAME = "response";
+function createBaseStreamUpdate() {
+    return { requestId: "", type: "", data: "", chunk: 0, timestamp: "" };
+}
+exports.StreamUpdate = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.requestId !== "") {
+            writer.uint32(10).string(message.requestId);
+        }
+        if (message.type !== "") {
+            writer.uint32(18).string(message.type);
+        }
+        if (message.data !== "") {
+            writer.uint32(26).string(message.data);
+        }
+        if (message.chunk !== 0) {
+            writer.uint32(32).int32(message.chunk);
+        }
+        if (message.timestamp !== "") {
+            writer.uint32(42).string(message.timestamp);
+        }
+        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 = createBaseStreamUpdate();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.requestId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.type = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.data = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.chunk = reader.int32();
+                    continue;
+                }
+                case 5: {
+                    if (tag !== 42) {
+                        break;
+                    }
+                    message.timestamp = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseProcessResponseRequest() {
+    return { correlationId: "", data: "", error: "", isStreamChunk: false };
+}
+exports.ProcessResponseRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.correlationId !== "") {
+            writer.uint32(10).string(message.correlationId);
+        }
+        if (message.data !== "") {
+            writer.uint32(18).string(message.data);
+        }
+        if (message.error !== "") {
+            writer.uint32(26).string(message.error);
+        }
+        if (message.isStreamChunk !== false) {
+            writer.uint32(32).bool(message.isStreamChunk);
+        }
+        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 = createBaseProcessResponseRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.correlationId = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.data = reader.string();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    message.error = reader.string();
+                    continue;
+                }
+                case 4: {
+                    if (tag !== 32) {
+                        break;
+                    }
+                    message.isStreamChunk = reader.bool();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseStreamUpdatesRequest() {
+    return { requestId: "" };
+}
+exports.StreamUpdatesRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.requestId !== "") {
+            writer.uint32(10).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 = createBaseStreamUpdatesRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.requestId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseProcessResponseResponse() {
+    return { success: false, error: "" };
+}
+exports.ProcessResponseResponse = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.success !== false) {
+            writer.uint32(8).bool(message.success);
+        }
+        if (message.error !== "") {
+            writer.uint32(18).string(message.error);
+        }
+        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 = createBaseProcessResponseResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 8) {
+                        break;
+                    }
+                    message.success = reader.bool();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.error = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function ResponseServiceControllerMethods() {
+    return function (constructor) {
+        const grpcMethods = ["processResponse", "getStreamUpdates"];
+        for (const method of grpcMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            (0, microservices_1.GrpcMethod)("ResponseService", method)(constructor.prototype[method], method, descriptor);
+        }
+        const grpcStreamMethods = [];
+        for (const method of grpcStreamMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            (0, microservices_1.GrpcStreamMethod)("ResponseService", method)(constructor.prototype[method], method, descriptor);
+        }
+    };
+}
+exports.RESPONSE_SERVICE_NAME = "ResponseService";
+exports.ResponseServiceService = {
+    processResponse: {
+        path: "/response.ResponseService/ProcessResponse",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(exports.ProcessResponseRequest.encode(value).finish()),
+        requestDeserialize: (value) => exports.ProcessResponseRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(exports.ProcessResponseResponse.encode(value).finish()),
+        responseDeserialize: (value) => exports.ProcessResponseResponse.decode(value),
+    },
+    getStreamUpdates: {
+        path: "/response.ResponseService/GetStreamUpdates",
+        requestStream: false,
+        responseStream: true,
+        requestSerialize: (value) => Buffer.from(exports.StreamUpdatesRequest.encode(value).finish()),
+        requestDeserialize: (value) => exports.StreamUpdatesRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(exports.StreamUpdate.encode(value).finish()),
+        responseDeserialize: (value) => exports.StreamUpdate.decode(value),
+    },
+};

package/dist/shared.module.d.ts

@@ -28,6 +28,14 @@ export interface SharedModuleOptions {
         protoPath: string;
         url: string;
     };
+    request?: {
+        protoPath: string;
+        url: string;
+    };
+    response?: {
+        protoPath: string;
+        url: string;
+    };
 }
 export declare class SharedModule {
     private static readonly logger;

package/dist/shared.module.js

@@ -18,6 +18,8 @@ const ai_client_1 = require("./ai.client");
 const storage_client_1 = require("./storage.client");
 const event_client_1 = require("./event.client");
 const key_client_1 = require("./key.client");
+const request_client_1 = require("./request.client");
+const response_client_1 = require("./response.client");
 let SharedModule = SharedModule_1 = class SharedModule {
     static forRoot(options = {}) {
         const clients = [];
@@ -232,6 +234,66 @@ let SharedModule = SharedModule_1 = class SharedModule {
         else {
             providers.push({ provide: key_client_1.KeyClient, useValue: null });
         }
+        // REQUEST
+        if (options.request) {
+            clients.push({
+                name: "REQUEST_PACKAGE",
+                transport: microservices_1.Transport.GRPC,
+                options: {
+                    package: "request",
+                    protoPath: (0, path_1.resolve)(process.cwd(), options.request.protoPath),
+                    url: options.request.url,
+                },
+            });
+            providers.push({
+                provide: request_client_1.RequestClient,
+                useFactory: (client) => {
+                    const svc = new request_client_1.RequestClient(client);
+                    try {
+                        svc.onModuleInit();
+                        SharedModule_1.logger.log("RequestClient initialized successfully");
+                    }
+                    catch (err) {
+                        SharedModule_1.logger.error("RequestClient initialization failed", err);
+                    }
+                    return svc;
+                },
+                inject: ["REQUEST_PACKAGE"],
+            });
+        }
+        else {
+            providers.push({ provide: request_client_1.RequestClient, useValue: null });
+        }
+        // RESPONSE
+        if (options.response) {
+            clients.push({
+                name: "RESPONSE_PACKAGE",
+                transport: microservices_1.Transport.GRPC,
+                options: {
+                    package: "response",
+                    protoPath: (0, path_1.resolve)(process.cwd(), options.response.protoPath),
+                    url: options.response.url,
+                },
+            });
+            providers.push({
+                provide: response_client_1.ResponseClient,
+                useFactory: (client) => {
+                    const svc = new response_client_1.ResponseClient(client);
+                    try {
+                        svc.onModuleInit();
+                        SharedModule_1.logger.log("ResponseClient initialized successfully");
+                    }
+                    catch (err) {
+                        SharedModule_1.logger.error("ResponseClient initialization failed", err);
+                    }
+                    return svc;
+                },
+                inject: ["RESPONSE_PACKAGE"],
+            });
+        }
+        else {
+            providers.push({ provide: response_client_1.ResponseClient, useValue: null });
+        }
         return {
             module: SharedModule_1,
             imports: clients.length ? [microservices_1.ClientsModule.register(clients)] : [],

package/dist/storage.interface.d.ts

@@ -13,29 +13,29 @@ export interface UploadRequest_MetadataEntry {
     key: string;
     value: string;
 }
-export interface UploadResponse {
+export interface DownloadRequest {
     fileId: string;
 }
-export interface DownloadRequest {
+export interface DeleteRequest {
+    fileId: string;
+}
+export interface UploadResponse {
     fileId: string;
 }
 export interface DownloadResponse {
     content: Uint8Array;
     filename: string;
 }
-export interface DeleteRequest {
-    fileId: string;
-}
 export interface DeleteResponse {
     success: boolean;
 }
 export declare const STORAGE_PACKAGE_NAME = "storage";
 export declare const UploadRequest: MessageFns<UploadRequest>;
 export declare const UploadRequest_MetadataEntry: MessageFns<UploadRequest_MetadataEntry>;
-export declare const UploadResponse: MessageFns<UploadResponse>;
 export declare const DownloadRequest: MessageFns<DownloadRequest>;
-export declare const DownloadResponse: MessageFns<DownloadResponse>;
 export declare const DeleteRequest: MessageFns<DeleteRequest>;
+export declare const UploadResponse: MessageFns<UploadResponse>;
+export declare const DownloadResponse: MessageFns<DownloadResponse>;
 export declare const DeleteResponse: MessageFns<DeleteResponse>;
 export interface StorageServiceClient {
     upload(request: UploadRequest, metadata?: Metadata): Observable<UploadResponse>;

package/dist/storage.interface.js

@@ -5,7 +5,7 @@
 //   protoc               v5.28.2
 // source: storage.proto
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StorageServiceService = exports.STORAGE_SERVICE_NAME = exports.DeleteResponse = exports.DeleteRequest = exports.DownloadResponse = exports.DownloadRequest = exports.UploadResponse = exports.UploadRequest_MetadataEntry = exports.UploadRequest = exports.STORAGE_PACKAGE_NAME = exports.protobufPackage = void 0;
+exports.StorageServiceService = exports.STORAGE_SERVICE_NAME = exports.DeleteResponse = exports.DownloadResponse = exports.UploadResponse = exports.DeleteRequest = exports.DownloadRequest = exports.UploadRequest_MetadataEntry = exports.UploadRequest = exports.STORAGE_PACKAGE_NAME = exports.protobufPackage = void 0;
 exports.StorageServiceControllerMethods = StorageServiceControllerMethods;
 /* eslint-disable */
 const wire_1 = require("@bufbuild/protobuf/wire");
@@ -111,10 +111,10 @@ exports.UploadRequest_MetadataEntry = {
         return message;
     },
 };
-function createBaseUploadResponse() {
+function createBaseDownloadRequest() {
     return { fileId: "" };
 }
-exports.UploadResponse = {
+exports.DownloadRequest = {
     encode(message, writer = new wire_1.BinaryWriter()) {
         if (message.fileId !== "") {
             writer.uint32(10).string(message.fileId);
@@ -124,7 +124,7 @@ exports.UploadResponse = {
     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 = createBaseUploadResponse();
+        const message = createBaseDownloadRequest();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -144,10 +144,10 @@ exports.UploadResponse = {
         return message;
     },
 };
-function createBaseDownloadRequest() {
+function createBaseDeleteRequest() {
     return { fileId: "" };
 }
-exports.DownloadRequest = {
+exports.DeleteRequest = {
     encode(message, writer = new wire_1.BinaryWriter()) {
         if (message.fileId !== "") {
             writer.uint32(10).string(message.fileId);
@@ -157,7 +157,7 @@ exports.DownloadRequest = {
     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 = createBaseDownloadRequest();
+        const message = createBaseDeleteRequest();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -177,23 +177,20 @@ exports.DownloadRequest = {
         return message;
     },
 };
-function createBaseDownloadResponse() {
-    return { content: new Uint8Array(0), filename: "" };
+function createBaseUploadResponse() {
+    return { fileId: "" };
 }
-exports.DownloadResponse = {
+exports.UploadResponse = {
     encode(message, writer = new wire_1.BinaryWriter()) {
-        if (message.content.length !== 0) {
-            writer.uint32(10).bytes(message.content);
-        }
-        if (message.filename !== "") {
-            writer.uint32(18).string(message.filename);
+        if (message.fileId !== "") {
+            writer.uint32(10).string(message.fileId);
         }
         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 = createBaseDownloadResponse();
+        const message = createBaseUploadResponse();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -201,14 +198,7 @@ exports.DownloadResponse = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.content = reader.bytes();
-                    continue;
-                }
-                case 2: {
-                    if (tag !== 18) {
-                        break;
-                    }
-                    message.filename = reader.string();
+                    message.fileId = reader.string();
                     continue;
                 }
             }
@@ -220,20 +210,23 @@ exports.DownloadResponse = {
         return message;
     },
 };
-function createBaseDeleteRequest() {
-    return { fileId: "" };
+function createBaseDownloadResponse() {
+    return { content: new Uint8Array(0), filename: "" };
 }
-exports.DeleteRequest = {
+exports.DownloadResponse = {
     encode(message, writer = new wire_1.BinaryWriter()) {
-        if (message.fileId !== "") {
-            writer.uint32(10).string(message.fileId);
+        if (message.content.length !== 0) {
+            writer.uint32(10).bytes(message.content);
+        }
+        if (message.filename !== "") {
+            writer.uint32(18).string(message.filename);
         }
         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 = createBaseDeleteRequest();
+        const message = createBaseDownloadResponse();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
@@ -241,7 +234,14 @@ exports.DeleteRequest = {
                     if (tag !== 10) {
                         break;
                     }
-                    message.fileId = reader.string();
+                    message.content = reader.bytes();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.filename = reader.string();
                     continue;
                 }
             }