listpage-next-nest 0.0.247 → 0.0.248

package/dist/cjs/index.d.ts

@@ -165,6 +165,51 @@ declare type MetaRequestionOption = {
     [key: string]: any;
 };
 
+export declare const MINIO_OPTIONS = "MINIO_OPTIONS";
+
+export declare class MinioModule {
+    static register(options: MinioModuleOptions): DynamicModule;
+}
+
+export declare interface MinioModuleOptions {
+    prefix: string;
+    endpoint: string;
+    accessKeyId: string;
+    secretAccessKey: string;
+    bucketName: string;
+    region?: string;
+}
+
+export declare class MinioService {
+    private readonly options;
+    constructor(options: MinioModuleOptions);
+    private getClient;
+    listAssets(): Promise<{
+        assets: any[];
+        folders: any[];
+    }>;
+    createFolder(folderName: string, parentPath: string | null): Promise<{
+        id: string;
+        name: string;
+        parentId: string;
+        createdAt: string;
+        type: string;
+    }>;
+    deleteFolder(folderPath: string): Promise<void>;
+    uploadMulterFile(file: any, folderId: string | null): Promise<{
+        id: string;
+        name: string;
+        url: string;
+        type: string;
+        size: string;
+        createdAt: string;
+        source: string;
+        parentId: string;
+    }>;
+    deleteObject(assetKey: string): Promise<void>;
+    private formatBytes;
+}
+
 export declare class PaginatedResponse<T> extends ApiResponse<PaginationData<T>> {
     constructor(list: T[], current: number, pageSize: number, total: number, message?: string);
     static create<T>(list: T[], current: number, pageSize: number, total: number, message?: string): PaginatedResponse<T>;

package/dist/cjs/index.js

@@ -24,12 +24,13 @@ var __webpack_require__ = {};
 var __webpack_exports__ = {};
 __webpack_require__.r(__webpack_exports__);
 __webpack_require__.d(__webpack_exports__, {
-    VolcengineProvider: ()=>VolcengineProvider,
+    MinioModule: ()=>MinioModule,
     LLMProviderModule: ()=>LLMProviderModule,
+    MinioService: ()=>MinioService,
     RequestContextMiddleware: ()=>RequestContextMiddleware,
-    setup: ()=>setup,
     AdminAuthGuard: ()=>AdminAuthGuard,
     LLMProvider: ()=>LLMProvider,
+    MINIO_OPTIONS: ()=>MINIO_OPTIONS,
     PaginationData: ()=>PaginationData,
     StaticRouteMiddleware: ()=>StaticRouteMiddleware,
     StaticRouteMiddlewareFactory: ()=>StaticRouteMiddlewareFactory,
@@ -43,9 +44,11 @@ __webpack_require__.d(__webpack_exports__, {
     HttpExceptionFilter: ()=>HttpExceptionFilter,
     User: ()=>User,
     Public: ()=>Public,
+    VolcengineProvider: ()=>VolcengineProvider,
     PaginatedResponse: ()=>PaginatedResponse,
     RequestContextService: ()=>RequestContextService,
     ServerSendEventName: ()=>types_ServerSendEventName,
+    setup: ()=>setup,
     LLMProviderService: ()=>LLMProviderService,
     MetaProvider: ()=>MetaProvider
 });
@@ -877,6 +880,353 @@ var types_ServerSendEventName = /*#__PURE__*/ function(ServerSendEventName) {
     ServerSendEventName["Citations"] = "citations";
     return ServerSendEventName;
 }({});
+const MINIO_OPTIONS = 'MINIO_OPTIONS';
+const client_s3_namespaceObject = require("@aws-sdk/client-s3");
+function minio_service_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) 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;
+}
+function minio_service_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+function _ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+class MinioService {
+    constructor(options){
+        this.options = options;
+    }
+    getClient() {
+        return new client_s3_namespaceObject.S3Client({
+            region: this.options.region || 'us-east-1',
+            endpoint: this.options.endpoint,
+            credentials: {
+                accessKeyId: this.options.accessKeyId,
+                secretAccessKey: this.options.secretAccessKey
+            },
+            forcePathStyle: true
+        });
+    }
+    async listAssets() {
+        const s3 = this.getClient();
+        const command = new client_s3_namespaceObject.ListObjectsV2Command({
+            Bucket: this.options.bucketName
+        });
+        const response = await s3.send(command);
+        const assets = [];
+        const foldersMap = new Map();
+        const getParentPath = (path)=>{
+            const cleanPath = path.endsWith('/') ? path.slice(0, -1) : path;
+            const parts = cleanPath.split('/');
+            if (parts.length <= 1) return null;
+            parts.pop();
+            return parts.join('/') + '/';
+        };
+        const ensureFolderExists = (path, date)=>{
+            if (!path || foldersMap.has(path)) return;
+            const parentId = getParentPath(path);
+            if (parentId) ensureFolderExists(parentId, date);
+            const cleanPath = path.slice(0, -1);
+            const name = cleanPath.split('/').pop() || 'Unknown';
+            foldersMap.set(path, {
+                id: path,
+                name,
+                parentId,
+                createdAt: date.toISOString(),
+                type: 'folder'
+            });
+        };
+        (response.Contents || []).forEach((item)=>{
+            const key = item.Key || '';
+            const date = item.LastModified || new Date();
+            if (key.endsWith('/')) return void ensureFolderExists(key, date);
+            const parts = key.split('/');
+            let parentId = null;
+            if (parts.length > 1) {
+                parts.pop();
+                parentId = parts.join('/') + '/';
+                ensureFolderExists(parentId, date);
+            }
+            const ext = key.split('.').pop()?.toLowerCase();
+            let type = 'file';
+            if ([
+                'png',
+                'jpg',
+                'jpeg',
+                'gif',
+                'webp',
+                'svg'
+            ].includes(ext || '')) type = 'image';
+            else if ([
+                'mp4',
+                'webm',
+                'mov',
+                'avi'
+            ].includes(ext || '')) type = 'video';
+            else if ([
+                'mp3',
+                'wav',
+                'ogg'
+            ].includes(ext || '')) type = 'audio';
+            else if ([
+                'obj',
+                'fbx',
+                'glb',
+                'gltf'
+            ].includes(ext || '')) type = 'model';
+            const url = `${this.options.endpoint}/${this.options.bucketName}/${key}`;
+            const name = key.split('/').pop() || key;
+            assets.push({
+                id: key,
+                name,
+                url,
+                type,
+                width: 0,
+                height: 0,
+                size: this.formatBytes(item.Size || 0),
+                createdAt: date.toISOString(),
+                source: 'upload',
+                parentId
+            });
+        });
+        return {
+            assets,
+            folders: Array.from(foldersMap.values())
+        };
+    }
+    async createFolder(folderName, parentPath) {
+        const prefix = parentPath ? parentPath : '';
+        const key = `${prefix}${folderName}/`;
+        const s3 = this.getClient();
+        const command = new client_s3_namespaceObject.PutObjectCommand({
+            Bucket: this.options.bucketName,
+            Key: key,
+            Body: new Uint8Array(0)
+        });
+        await s3.send(command);
+        return {
+            id: key,
+            name: folderName,
+            parentId: parentPath,
+            createdAt: new Date().toISOString(),
+            type: 'folder'
+        };
+    }
+    async deleteFolder(folderPath) {
+        const s3 = this.getClient();
+        let continuationToken;
+        do {
+            const listResp = await s3.send(new client_s3_namespaceObject.ListObjectsV2Command({
+                Bucket: this.options.bucketName,
+                Prefix: folderPath,
+                ContinuationToken: continuationToken
+            }));
+            const contents = listResp.Contents || [];
+            for (const item of contents){
+                const key = item.Key;
+                if (key) await s3.send(new client_s3_namespaceObject.DeleteObjectCommand({
+                    Bucket: this.options.bucketName,
+                    Key: key
+                }));
+            }
+            continuationToken = listResp.IsTruncated ? listResp.NextContinuationToken : void 0;
+        }while (continuationToken);
+    }
+    async uploadMulterFile(file, folderId) {
+        const prefix = folderId || '';
+        const cleanName = file.originalname.replace(/[^a-zA-Z0-9.-]/g, '_');
+        const key = `${prefix}${Date.now()}-${cleanName}`;
+        const s3 = this.getClient();
+        const command = new client_s3_namespaceObject.PutObjectCommand({
+            Bucket: this.options.bucketName,
+            Key: key,
+            Body: file.buffer,
+            ContentType: file.mimetype
+        });
+        await s3.send(command);
+        const publicUrl = `${this.options.endpoint}/${this.options.bucketName}/${key}`;
+        let type = 'file';
+        if (file.mimetype.startsWith('image/')) type = 'image';
+        else if (file.mimetype.startsWith('video/')) type = 'video';
+        else if (file.mimetype.startsWith('audio/')) type = 'audio';
+        else if (cleanName.endsWith('.obj') || cleanName.endsWith('.fbx') || cleanName.endsWith('.glb')) type = 'model';
+        return {
+            id: key,
+            name: key.split('/').pop(),
+            url: publicUrl,
+            type,
+            size: this.formatBytes(file.size),
+            createdAt: new Date().toISOString(),
+            source: 'upload',
+            parentId: folderId
+        };
+    }
+    async deleteObject(assetKey) {
+        const s3 = this.getClient();
+        const command = new client_s3_namespaceObject.DeleteObjectCommand({
+            Bucket: this.options.bucketName,
+            Key: assetKey
+        });
+        await s3.send(command);
+    }
+    formatBytes(bytes, decimals = 2) {
+        if (!+bytes) return '0 Bytes';
+        const k = 1024;
+        const dm = decimals < 0 ? 0 : decimals;
+        const sizes = [
+            'Bytes',
+            'KB',
+            'MB',
+            'GB',
+            'TB'
+        ];
+        const i = Math.floor(Math.log(bytes) / Math.log(k));
+        return `${parseFloat((bytes / Math.pow(k, i)).toFixed(dm))} ${sizes[i]}`;
+    }
+}
+MinioService = minio_service_ts_decorate([
+    (0, common_namespaceObject.Injectable)(),
+    _ts_param(0, (0, common_namespaceObject.Inject)(MINIO_OPTIONS)),
+    minio_service_ts_metadata("design:type", Function),
+    minio_service_ts_metadata("design:paramtypes", [
+        "undefined" == typeof MinioModuleOptions ? Object : MinioModuleOptions
+    ])
+], MinioService);
+const platform_express_namespaceObject = require("@nestjs/platform-express");
+function minio_controller_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) 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;
+}
+function minio_controller_ts_metadata(k, v) {
+    if ("object" == typeof Reflect && "function" == typeof Reflect.metadata) return Reflect.metadata(k, v);
+}
+function minio_controller_ts_param(paramIndex, decorator) {
+    return function(target, key) {
+        decorator(target, key, paramIndex);
+    };
+}
+function createMinioController(prefix) {
+    class MinioController {
+        async list(_body) {
+            return this.service.listAssets();
+        }
+        async createFolder(body) {
+            if (!body.name) throw new common_namespaceObject.BadRequestException('Folder name is required');
+            return this.service.createFolder(body.name, body.parentPath ?? null);
+        }
+        async removeFolder(path) {
+            if (!path) throw new common_namespaceObject.BadRequestException('Folder path is required');
+            await this.service.deleteFolder(path);
+            return {
+                ok: true
+            };
+        }
+        async upload(file, folderId) {
+            if (!file) throw new common_namespaceObject.BadRequestException('File is required');
+            const cleanFolderId = 'null' === folderId || 'undefined' === folderId ? null : folderId;
+            return this.service.uploadMulterFile(file, cleanFolderId);
+        }
+        async removeObject(key) {
+            if (!key) throw new common_namespaceObject.BadRequestException('Object key is required');
+            await this.service.deleteObject(key);
+            return {
+                ok: true
+            };
+        }
+    }
+    minio_controller_ts_decorate([
+        (0, common_namespaceObject.Inject)(MinioService),
+        minio_controller_ts_metadata("design:type", void 0 === MinioService ? Object : MinioService)
+    ], MinioController.prototype, "service", void 0);
+    minio_controller_ts_decorate([
+        (0, common_namespaceObject.Post)('assets/list'),
+        minio_controller_ts_param(0, (0, common_namespaceObject.Body)()),
+        minio_controller_ts_metadata("design:type", Function),
+        minio_controller_ts_metadata("design:paramtypes", [
+            Object
+        ]),
+        minio_controller_ts_metadata("design:returntype", Promise)
+    ], MinioController.prototype, "list", null);
+    minio_controller_ts_decorate([
+        (0, common_namespaceObject.Post)('folders/create'),
+        minio_controller_ts_param(0, (0, common_namespaceObject.Body)()),
+        minio_controller_ts_metadata("design:type", Function),
+        minio_controller_ts_metadata("design:paramtypes", [
+            Object
+        ]),
+        minio_controller_ts_metadata("design:returntype", Promise)
+    ], MinioController.prototype, "createFolder", null);
+    minio_controller_ts_decorate([
+        (0, common_namespaceObject.Post)('folders/delete'),
+        minio_controller_ts_param(0, (0, common_namespaceObject.Body)('path')),
+        minio_controller_ts_metadata("design:type", Function),
+        minio_controller_ts_metadata("design:paramtypes", [
+            String
+        ]),
+        minio_controller_ts_metadata("design:returntype", Promise)
+    ], MinioController.prototype, "removeFolder", null);
+    minio_controller_ts_decorate([
+        (0, common_namespaceObject.Post)('upload'),
+        (0, common_namespaceObject.UseInterceptors)((0, platform_express_namespaceObject.FileInterceptor)('file')),
+        minio_controller_ts_param(0, (0, common_namespaceObject.UploadedFile)()),
+        minio_controller_ts_param(1, (0, common_namespaceObject.Body)('folderId')),
+        minio_controller_ts_metadata("design:type", Function),
+        minio_controller_ts_metadata("design:paramtypes", [
+            Object,
+            Object
+        ]),
+        minio_controller_ts_metadata("design:returntype", Promise)
+    ], MinioController.prototype, "upload", null);
+    minio_controller_ts_decorate([
+        (0, common_namespaceObject.Post)('objects/delete'),
+        minio_controller_ts_param(0, (0, common_namespaceObject.Body)('key')),
+        minio_controller_ts_metadata("design:type", Function),
+        minio_controller_ts_metadata("design:paramtypes", [
+            String
+        ]),
+        minio_controller_ts_metadata("design:returntype", Promise)
+    ], MinioController.prototype, "removeObject", null);
+    MinioController = minio_controller_ts_decorate([
+        (0, common_namespaceObject.Controller)(prefix)
+    ], MinioController);
+    return MinioController;
+}
+function minio_module_ts_decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : null === desc ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if ("object" == typeof Reflect && "function" == typeof Reflect.decorate) 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;
+}
+class MinioModule {
+    static register(options) {
+        const controller = createMinioController(options.prefix);
+        return {
+            module: MinioModule,
+            controllers: [
+                controller
+            ],
+            providers: [
+                {
+                    provide: MINIO_OPTIONS,
+                    useValue: options
+                },
+                MinioService
+            ],
+            exports: [
+                MinioService
+            ]
+        };
+    }
+}
+MinioModule = minio_module_ts_decorate([
+    (0, common_namespaceObject.Module)({})
+], MinioModule);
 exports.AdminAuthGuard = __webpack_exports__.AdminAuthGuard;
 exports.ApiResponse = __webpack_exports__.ApiResponse;
 exports.BaseQueryDto = __webpack_exports__.BaseQueryDto;
@@ -886,7 +1236,10 @@ exports.LLMProvider = __webpack_exports__.LLMProvider;
 exports.LLMProviderModule = __webpack_exports__.LLMProviderModule;
 exports.LLMProviderService = __webpack_exports__.LLMProviderService;
 exports.LoggingInterceptor = __webpack_exports__.LoggingInterceptor;
+exports.MINIO_OPTIONS = __webpack_exports__.MINIO_OPTIONS;
 exports.MetaProvider = __webpack_exports__.MetaProvider;
+exports.MinioModule = __webpack_exports__.MinioModule;
+exports.MinioService = __webpack_exports__.MinioService;
 exports.PaginatedResponse = __webpack_exports__.PaginatedResponse;
 exports.PaginationData = __webpack_exports__.PaginationData;
 exports.Public = __webpack_exports__.Public;
@@ -911,7 +1264,10 @@ for(var __webpack_i__ in __webpack_exports__)if (-1 === [
     "LLMProviderModule",
     "LLMProviderService",
     "LoggingInterceptor",
+    "MINIO_OPTIONS",
     "MetaProvider",
+    "MinioModule",
+    "MinioService",
     "PaginatedResponse",
     "PaginationData",
     "Public",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "listpage-next-nest",
-  "version": "0.0.247",
+  "version": "0.0.248",
   "description": "A React component library for creating filter forms with Ant Design",
   "main": "./dist/cjs/index.js",
   "module": "./dist/esm/index.js",