geniebox-shared-lib 1.0.73 → 2.0.0

package/dist/shared.module.js

@@ -11,13 +11,13 @@ exports.SharedModule = void 0;
 const common_1 = require("@nestjs/common");
 const microservices_1 = require("@nestjs/microservices");
 const path_1 = require("path");
-const user_client_1 = require("./user/user.client");
-const auth_client_1 = require("./auth/auth.client");
-const openai_client_1 = require("./openai/openai.client");
-const ai_client_1 = require("./ai/ai.client");
-const file_client_1 = require("./file/file.client");
-const event_client_1 = require("./event/event.client");
-const key_client_1 = require("./key/key.client");
+const user_client_1 = require("./user.client");
+const auth_client_1 = require("./auth.client");
+const openai_client_1 = require("./openai.client");
+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");
 let SharedModule = SharedModule_1 = class SharedModule {
     static forRoot(options = {}) {
         const clients = [];
@@ -142,35 +142,35 @@ let SharedModule = SharedModule_1 = class SharedModule {
         else {
             providers.push({ provide: openai_client_1.OpenAIClient, useValue: null });
         }
-        // FILE
-        if (options.file) {
+        // STORAGE
+        if (options.storage) {
             clients.push({
-                name: "FILE_PACKAGE",
+                name: "STORAGE_PACKAGE",
                 transport: microservices_1.Transport.GRPC,
                 options: {
-                    package: "file",
-                    protoPath: (0, path_1.resolve)(process.cwd(), options.file.protoPath),
-                    url: options.file.url,
+                    package: "storage",
+                    protoPath: (0, path_1.resolve)(process.cwd(), options.storage.protoPath),
+                    url: options.storage.url,
                 },
             });
             providers.push({
-                provide: file_client_1.FileClient,
+                provide: storage_client_1.StorageClient,
                 useFactory: (client) => {
-                    const svc = new file_client_1.FileClient(client);
+                    const svc = new storage_client_1.StorageClient(client);
                     try {
                         svc.onModuleInit();
-                        SharedModule_1.logger.log("FileClient initialized successfully");
+                        SharedModule_1.logger.log("StorageClient initialized successfully");
                     }
                     catch (err) {
-                        SharedModule_1.logger.error("FileClient initialization failed", err);
+                        SharedModule_1.logger.error("StorageClient initialization failed", err);
                     }
                     return svc;
                 },
-                inject: ["FILE_PACKAGE"],
+                inject: ["STORAGE_PACKAGE"],
             });
         }
         else {
-            providers.push({ provide: file_client_1.FileClient, useValue: null });
+            providers.push({ provide: storage_client_1.StorageClient, useValue: null });
         }
         // EVENT
         if (options.event) {

package/dist/storage.client.d.ts

@@ -0,0 +1,12 @@
+import { OnModuleInit } from "@nestjs/common";
+import { ClientGrpc } from "@nestjs/microservices";
+import { StorageServiceClient } from "./storage.interface";
+export declare class StorageClient implements OnModuleInit {
+    private readonly client;
+    private readonly logger;
+    private storageClient?;
+    constructor(client: ClientGrpc);
+    onModuleInit(): void;
+    get service(): StorageServiceClient;
+    isReady(): boolean;
+}

package/dist/storage.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 StorageClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StorageClient = void 0;
+const common_1 = require("@nestjs/common");
+let StorageClient = StorageClient_1 = class StorageClient {
+    constructor(client) {
+        this.client = client;
+        this.logger = new common_1.Logger(StorageClient_1.name);
+    }
+    onModuleInit() {
+        this.storageClient =
+            this.client.getService("StorageService");
+        this.logger.log("StorageServiceClient initialized");
+    }
+    get service() {
+        if (!this.storageClient) {
+            throw new common_1.InternalServerErrorException("StorageService is not initialized yet");
+        }
+        return this.storageClient;
+    }
+    isReady() {
+        return !!this.storageClient;
+    }
+};
+exports.StorageClient = StorageClient;
+exports.StorageClient = StorageClient = StorageClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)("STORAGE_PACKAGE")),
+    __metadata("design:paramtypes", [Object])
+], StorageClient);

package/dist/storage.interface.d.ts

@@ -0,0 +1,90 @@
+import { BinaryReader, BinaryWriter } from "@bufbuild/protobuf/wire";
+import type { handleUnaryCall, Metadata, UntypedServiceImplementation } from "@grpc/grpc-js";
+import { Observable } from "rxjs";
+export declare const protobufPackage = "storage";
+export interface UploadRequest {
+    filename: string;
+    content: Uint8Array;
+    metadata: {
+        [key: string]: string;
+    };
+}
+export interface UploadRequest_MetadataEntry {
+    key: string;
+    value: string;
+}
+export interface UploadResponse {
+    fileId: string;
+}
+export interface DownloadRequest {
+    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 DeleteResponse: MessageFns<DeleteResponse>;
+export interface StorageServiceClient {
+    upload(request: UploadRequest, metadata?: Metadata): Observable<UploadResponse>;
+    download(request: DownloadRequest, metadata?: Metadata): Observable<DownloadResponse>;
+    delete(request: DeleteRequest, metadata?: Metadata): Observable<DeleteResponse>;
+}
+export interface StorageServiceController {
+    upload(request: UploadRequest, metadata?: Metadata): Promise<UploadResponse> | Observable<UploadResponse> | UploadResponse;
+    download(request: DownloadRequest, metadata?: Metadata): Promise<DownloadResponse> | Observable<DownloadResponse> | DownloadResponse;
+    delete(request: DeleteRequest, metadata?: Metadata): Promise<DeleteResponse> | Observable<DeleteResponse> | DeleteResponse;
+}
+export declare function StorageServiceControllerMethods(): (constructor: Function) => void;
+export declare const STORAGE_SERVICE_NAME = "StorageService";
+export type StorageServiceService = typeof StorageServiceService;
+export declare const StorageServiceService: {
+    readonly upload: {
+        readonly path: "/storage.StorageService/upload";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: UploadRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => UploadRequest;
+        readonly responseSerialize: (value: UploadResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => UploadResponse;
+    };
+    readonly download: {
+        readonly path: "/storage.StorageService/download";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DownloadRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DownloadRequest;
+        readonly responseSerialize: (value: DownloadResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => DownloadResponse;
+    };
+    readonly delete: {
+        readonly path: "/storage.StorageService/delete";
+        readonly requestStream: false;
+        readonly responseStream: false;
+        readonly requestSerialize: (value: DeleteRequest) => Buffer;
+        readonly requestDeserialize: (value: Buffer) => DeleteRequest;
+        readonly responseSerialize: (value: DeleteResponse) => Buffer;
+        readonly responseDeserialize: (value: Buffer) => DeleteResponse;
+    };
+};
+export interface StorageServiceServer extends UntypedServiceImplementation {
+    upload: handleUnaryCall<UploadRequest, UploadResponse>;
+    download: handleUnaryCall<DownloadRequest, DownloadResponse>;
+    delete: handleUnaryCall<DeleteRequest, DeleteResponse>;
+}
+export interface MessageFns<T> {
+    encode(message: T, writer?: BinaryWriter): BinaryWriter;
+    decode(input: BinaryReader | Uint8Array, length?: number): T;
+}

package/dist/storage.interface.js

@@ -0,0 +1,332 @@
+"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: 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.StorageServiceControllerMethods = StorageServiceControllerMethods;
+/* eslint-disable */
+const wire_1 = require("@bufbuild/protobuf/wire");
+const microservices_1 = require("@nestjs/microservices");
+exports.protobufPackage = "storage";
+exports.STORAGE_PACKAGE_NAME = "storage";
+function createBaseUploadRequest() {
+    return { filename: "", content: new Uint8Array(0), metadata: {} };
+}
+exports.UploadRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.filename !== "") {
+            writer.uint32(10).string(message.filename);
+        }
+        if (message.content.length !== 0) {
+            writer.uint32(18).bytes(message.content);
+        }
+        Object.entries(message.metadata).forEach(([key, value]) => {
+            exports.UploadRequest_MetadataEntry.encode({ key: key, value }, writer.uint32(26).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 = createBaseUploadRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.filename = reader.string();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.content = reader.bytes();
+                    continue;
+                }
+                case 3: {
+                    if (tag !== 26) {
+                        break;
+                    }
+                    const entry3 = exports.UploadRequest_MetadataEntry.decode(reader, reader.uint32());
+                    if (entry3.value !== undefined) {
+                        message.metadata[entry3.key] = entry3.value;
+                    }
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseUploadRequest_MetadataEntry() {
+    return { key: "", value: "" };
+}
+exports.UploadRequest_MetadataEntry = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        if (message.key !== "") {
+            writer.uint32(10).string(message.key);
+        }
+        if (message.value !== "") {
+            writer.uint32(18).string(message.value);
+        }
+        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 = createBaseUploadRequest_MetadataEntry();
+        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;
+    },
+};
+function createBaseUploadResponse() {
+    return { fileId: "" };
+}
+exports.UploadResponse = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        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 = createBaseUploadResponse();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.fileId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseDownloadRequest() {
+    return { fileId: "" };
+}
+exports.DownloadRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        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 = createBaseDownloadRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.fileId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseDownloadResponse() {
+    return { content: new Uint8Array(0), filename: "" };
+}
+exports.DownloadResponse = {
+    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);
+        }
+        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();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.content = reader.bytes();
+                    continue;
+                }
+                case 2: {
+                    if (tag !== 18) {
+                        break;
+                    }
+                    message.filename = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseDeleteRequest() {
+    return { fileId: "" };
+}
+exports.DeleteRequest = {
+    encode(message, writer = new wire_1.BinaryWriter()) {
+        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 = createBaseDeleteRequest();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1: {
+                    if (tag !== 10) {
+                        break;
+                    }
+                    message.fileId = reader.string();
+                    continue;
+                }
+            }
+            if ((tag & 7) === 4 || tag === 0) {
+                break;
+            }
+            reader.skip(tag & 7);
+        }
+        return message;
+    },
+};
+function createBaseDeleteResponse() {
+    return { success: false };
+}
+exports.DeleteResponse = {
+    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 = createBaseDeleteResponse();
+        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 StorageServiceControllerMethods() {
+    return function (constructor) {
+        const grpcMethods = ["upload", "download", "delete"];
+        for (const method of grpcMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            (0, microservices_1.GrpcMethod)("StorageService", method)(constructor.prototype[method], method, descriptor);
+        }
+        const grpcStreamMethods = [];
+        for (const method of grpcStreamMethods) {
+            const descriptor = Reflect.getOwnPropertyDescriptor(constructor.prototype, method);
+            (0, microservices_1.GrpcStreamMethod)("StorageService", method)(constructor.prototype[method], method, descriptor);
+        }
+    };
+}
+exports.STORAGE_SERVICE_NAME = "StorageService";
+exports.StorageServiceService = {
+    upload: {
+        path: "/storage.StorageService/upload",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(exports.UploadRequest.encode(value).finish()),
+        requestDeserialize: (value) => exports.UploadRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(exports.UploadResponse.encode(value).finish()),
+        responseDeserialize: (value) => exports.UploadResponse.decode(value),
+    },
+    download: {
+        path: "/storage.StorageService/download",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(exports.DownloadRequest.encode(value).finish()),
+        requestDeserialize: (value) => exports.DownloadRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(exports.DownloadResponse.encode(value).finish()),
+        responseDeserialize: (value) => exports.DownloadResponse.decode(value),
+    },
+    delete: {
+        path: "/storage.StorageService/delete",
+        requestStream: false,
+        responseStream: false,
+        requestSerialize: (value) => Buffer.from(exports.DeleteRequest.encode(value).finish()),
+        requestDeserialize: (value) => exports.DeleteRequest.decode(value),
+        responseSerialize: (value) => Buffer.from(exports.DeleteResponse.encode(value).finish()),
+        responseDeserialize: (value) => exports.DeleteResponse.decode(value),
+    },
+};

package/dist/user.client.d.ts

@@ -0,0 +1,12 @@
+import { OnModuleInit } from "@nestjs/common";
+import { ClientGrpc } from "@nestjs/microservices";
+import { UserServiceClient } from "./user.interface";
+export declare class UsersClient implements OnModuleInit {
+    private readonly client;
+    private readonly logger;
+    private userClient?;
+    constructor(client: ClientGrpc);
+    onModuleInit(): void;
+    get service(): UserServiceClient;
+    isReady(): boolean;
+}

package/dist/user.client.js

@@ -0,0 +1,42 @@
+"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 UsersClient_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UsersClient = void 0;
+const common_1 = require("@nestjs/common");
+let UsersClient = UsersClient_1 = class UsersClient {
+    constructor(client) {
+        this.client = client;
+        this.logger = new common_1.Logger(UsersClient_1.name);
+    }
+    onModuleInit() {
+        this.userClient = this.client.getService("UserService");
+        this.logger.log("UserServiceClient initialized");
+    }
+    get service() {
+        if (!this.userClient) {
+            throw new common_1.InternalServerErrorException("UserService is not initialized yet");
+        }
+        return this.userClient;
+    }
+    isReady() {
+        return !!this.userClient;
+    }
+};
+exports.UsersClient = UsersClient;
+exports.UsersClient = UsersClient = UsersClient_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, common_1.Inject)("USER_PACKAGE")),
+    __metadata("design:paramtypes", [Object])
+], UsersClient);