@zola_do/minio 0.2.4 → 0.2.6

package/README.md

@@ -1,7 +1,20 @@
 # @zola_do/minio
 
+[![npm version](https://img.shields.io/npm/v/@zola_do/minio.svg)](https://www.npmjs.com/package/@zola_do/minio)
+[![npm downloads](https://img.shields.io/npm/dm/@zola_do/minio.svg)](https://www.npmjs.com/package/@zola_do/minio)
+[![License: ISC](https://img.shields.io/badge/License-ISC-blue.svg)](https://opensource.org/licenses/ISC)
+
 MinIO object storage integration for NestJS applications.
 
+## Overview
+
+`@zola_do/minio` provides:
+
+- **File Upload** — Direct upload with Multer or buffer
+- **Presigned URLs** — Secure upload/download links
+- **Bucket Management** — Multiple predefined buckets
+- **Streaming** — Efficient file streaming
+
 ## Installation
 
 ```bash
@@ -12,15 +25,37 @@ npm install @zola_do/minio
 npm install @zola_do/nestjs-shared
 ```
 
-**Note:** If installation fails due to `nestjs-minio-client` postinstall script, use `npm install --ignore-scripts`.
+**Note:** If installation fails due to `nestjs-minio-client` postinstall script, use:
+
+```bash
+npm install @zola_do/minio --ignore-scripts
+```
+
+### Dependencies
 
-## Usage
+```bash
+npm install nestjs-minio-client
+```
+
+## Quick Start
+
+### 1. Configure Environment
 
-### Module Setup
+```bash
+# .env
+MINIO_ENDPOINT=localhost
+MINIO_PORT=9000
+MINIO_USESSL=false
+MINIO_ACCESSKEY=your-access-key
+MINIO_SECRETKEY=your-secret-key
+DURATION_OF_PRE_SIGNED_DOCUMENT=120
+```
+
+### 2. Register Module
 
 ```typescript
-import { Module } from '@nestjs/common';
-import { MinIoModule } from '@zola_do/minio';
+import { Module } from "@nestjs/common";
+import { MinIoModule } from "@zola_do/minio";
 
 @Module({
   imports: [MinIoModule],
@@ -28,80 +63,353 @@ import { MinIoModule } from '@zola_do/minio';
 export class AppModule {}
 ```
 
-### Uploading Files
+### 3. Use Service
 
 ```typescript
-import { Injectable } from '@nestjs/common';
-import { MinIOService, BucketNameEnum } from '@zola_do/minio';
+import { Injectable } from "@nestjs/common";
+import { MinIOService, BucketNameEnum } from "@zola_do/minio";
 
 @Injectable()
-export class FileUploadService {
+export class FileService {
   constructor(private readonly minioService: MinIOService) {}
 
-  async uploadFile(file: Express.Multer.File, bucketName: string) {
-    return await this.minioService.upload(file, bucketName);
-    // Returns { filepath, bucketName, contentType, originalname }
+  async uploadFile(file: Express.Multer.File) {
+    return await this.minioService.upload(file, BucketNameEnum.MEGP);
   }
+}
+```
+
+## MinIO Architecture
+
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│                       MinIO Flow                                     │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                      │
+│  ┌──────────┐                                                       │
+│  │  Client  │                                                       │
+│  └────┬─────┘                                                       │
+│       │                                                             │
+│       │ 1. Request presigned URL                                    │
+│       ├─────────────────────────────────────┐                       │
+│       │                                     │                       │
+│       │  ┌───────────────┐                  │                       │
+│       │  │  Controller    │                  │                       │
+│       │  └───────┬───────┘                  │                       │
+│       │          │                          │                       │
+│       │          │ 2. Generate URL           │                       │
+│       │          ▼                          │                       │
+│       │  ┌───────────────┐                  │                       │
+│       │  │ MinIOService  │                  │                       │
+│       │  └───────┬───────┘                  │                       │
+│       │          │                          │                       │
+│       │          │ 3. Client PUT             │                       │
+│       │<─────────┼──────────────────────────┘                       │
+│       │          │                                                    │
+│       │          ▼                                                    │
+│       │  ┌───────────────┐                  │                       │
+│       │  │    MinIO      │◄─────────────────┘                       │
+│       │  │    Server     │    Direct upload                         │
+│       │  └───────────────┘                                          │
+│       │                                                             │
+│       │          4. File stored                                     │
+│       │          ┌───────────────┐                                  │
+│       │          │    Bucket     │                                  │
+│       │          │   documents/  │                                  │
+│       │          └───────────────┘                                  │
+│       │                                                             │
+└───────┴─────────────────────────────────────────────────────────────┘
+```
+
+## Upload Operations
+
+### File Upload
+
+```typescript
+async uploadFile(file: Express.Multer.File) {
+  const result = await this.minioService.upload(
+    file,
+    BucketNameEnum.MEGP,
+  );
+  // Returns: { filepath, bucketName, contentType, originalname }
+}
+```
+
+### Buffer Upload
+
+```typescript
+async uploadBuffer(
+  buffer: Buffer,
+  filename: string,
+  mimetype: string,
+) {
+  const result = await this.minioService.uploadBuffer(
+    buffer,
+    filename,
+    mimetype,
+    BucketNameEnum.MEGP,
+  );
+  return result;
+}
+```
+
+### Custom Bucket
+
+```typescript
+async uploadToCustomBucket(file: Express.Multer.File, bucketName: string) {
+  // Ensure bucket exists
+  await this.minioService.ensureBucket(bucketName);
+
+  return await this.minioService.upload(file, bucketName);
+}
+```
+
+## Download Operations
+
+### Download to Buffer
+
+```typescript
+async downloadFile(filepath: string, bucketName: string): Promise<Buffer> {
+  const buffer = await this.minioService.downloadBuffer({
+    filepath,
+    bucketName,
+  });
+  return buffer;
+}
+```
+
+### Download to Response
+
+```typescript
+async downloadToResponse(
+  @Param('filepath') filepath: string,
+  @Res() res: Response,
+) {
+  const buffer = await this.minioService.downloadBuffer({
+    filepath: `documents/${filepath}`,
+    bucketName: BucketNameEnum.MEGP,
+  });
+
+  res.setHeader('Content-Type', 'application/pdf');
+  res.setHeader('Content-Disposition', `attachment; filename="${filepath}"`);
+  res.end(buffer);
+}
+```
+
+## Presigned URLs
+
+### Generate Upload URL
+
+```typescript
+async getUploadUrl(filename: string, contentType: string) {
+  const { presignedUrl, file } = await this.minioService.generatePresignedUploadUrl(
+    { originalname: filename, contentType },
+    'documents/', // Folder prefix
+  );
+
+  return {
+    presignedUrl,
+    filepath: file.filepath,
+    bucketName: file.bucketName,
+  };
+}
+```
+
+### Generate Download URL
+
+```typescript
+async getDownloadUrl(filepath: string) {
+  const fileInfo = {
+    filepath,
+    bucketName: BucketNameEnum.MEGP,
+    contentType: 'application/pdf',
+    originalname: 'document.pdf',
+  };
+
+  const presignedUrl = await this.minioService.generatePresignedDownloadUrl(fileInfo);
+  return { downloadUrl: presignedUrl };
+}
+```
+
+### Client-Side Upload Example
+
+```typescript
+// Backend
+@Post('upload-url')
+async getUploadUrl() {
+  const { presignedUrl, file } = await this.minioService.generatePresignedUploadUrl(
+    { originalname: 'report.pdf', contentType: 'application/pdf' },
+    'reports/',
+  );
+  return { presignedUrl, file };
+}
+
+// Frontend (React/Angular/Vue)
+const response = await fetch('/api/upload-url');
+const { presignedUrl, file } = await response.json();
+
+await fetch(presignedUrl, {
+  method: 'PUT',
+  body: fileBuffer,
+  headers: { 'Content-Type': 'application/pdf' },
+});
+```
+
+## BucketNameEnum
+
+Predefined bucket names:
+
+```typescript
+enum BucketNameEnum {
+  MEGP = "megp",
+  SPD_TEMPLATE = "spd_template",
+  // Add more buckets as needed
+}
+```
+
+### Custom Buckets
+
+```typescript
+// Define custom bucket names
+const MY_BUCKETS = {
+  DOCUMENTS: "my-documents",
+  IMAGES: "my-images",
+  EXPORTS: "my-exports",
+} as const;
+```
+
+### Ensure Bucket Exists
+
+```typescript
+async ensureBucketExists(bucketName: string) {
+  await this.minioService.ensureBucket(bucketName);
+}
+```
+
+## Environment Variables
+
+| Variable                          | Description                    | Default  |
+| --------------------------------- | ------------------------------ | -------- |
+| `MINIO_ENDPOINT`                  | MinIO server endpoint          | Required |
+| `MINIO_PORT`                      | MinIO port                     | `443`    |
+| `MINIO_USESSL`                    | Use SSL                        | `true`   |
+| `MINIO_ACCESSKEY`                 | MinIO access key               | Required |
+| `MINIO_SECRETKEY`                 | MinIO secret key               | Required |
+| `DURATION_OF_PRE_SIGNED_DOCUMENT` | Presigned URL expiry (seconds) | `120`    |
+
+## PresignedFileUploadDto
+
+Response type for presigned upload:
+
+```typescript
+interface PresignedFileUploadDto {
+  presignedUrl: string;
+  file: {
+    filepath: string;
+    bucketName: string;
+    contentType: string;
+    originalname: string;
+  };
+}
+```
+
+## API Reference
+
+### Module
+
+```typescript
+MinIoModule.forRoot(options?: MinIoModuleOptions)
+MinIoModule.forRootAsync(options?: MinIoModuleAsyncOptions)
+```
+
+### Service
+
+```typescript
+class MinIOService {
+  async upload(
+    file: Express.Multer.File,
+    bucketName: string,
+  ): Promise<{
+    filepath: string;
+    bucketName: string;
+    contentType: string;
+    originalname: string;
+  }>;
 
   async uploadBuffer(
     buffer: Buffer,
     originalname: string,
     mimetype: string,
     bucketName: string,
-  ) {
-    return await this.minioService.uploadBuffer(
-      buffer,
-      originalname,
-      mimetype,
-      bucketName,
-    );
-  }
+  ): Promise<FileUploadResult>;
+
+  async downloadBuffer(fileInfo: FileInfo): Promise<Buffer>;
+
+  async generatePresignedUploadUrl(
+    file: Partial<FileInfo>,
+    folder?: string,
+    expiry?: number,
+  ): Promise<PresignedFileUploadDto>;
+
+  async generatePresignedDownloadUrl(
+    fileInfo: FileInfo,
+    expiry?: number,
+  ): Promise<string>;
+
+  async ensureBucket(bucketName: string): Promise<void>;
 }
 ```
 
-### Presigned URLs
+## Troubleshooting
 
-Generate presigned upload URLs for client-side uploads:
+### Q: Connection refused error?
 
-```typescript
-const { presignedUrl, file } = await this.minioService.generatePresignedUploadUrl(
-  { originalname: 'document.pdf', contentType: 'application/pdf' },
-  'documents/',
-);
-// Send presignedUrl to client; they upload directly to MinIO
+Verify MinIO is running:
+
+```bash
+docker run -p 9000:9000 minio/minio server /data
 ```
 
-### Downloading Files
+### Q: Bucket not found?
+
+Create the bucket in MinIO console or use `ensureBucket()`:
 
 ```typescript
-const stream = await this.minioService.downloadBuffer({
-  filepath: 'path/to/file.pdf',
-  bucketName: BucketNameEnum.MEGP,
-});
+await this.minioService.ensureBucket("my-bucket");
 ```
 
-## Environment Variables
+### Q: Presigned URL expired?
 
-| Variable | Description |
-|----------|-------------|
-| `MINIO_ENDPOINT` | MinIO server endpoint |
-| `MINIO_PORT` | MinIO port (default: 443) |
-| `MINIO_USESSL` | Use SSL (default: true) |
-| `MINIO_ACCESSKEY` | MinIO access key |
-| `MINIO_SECRETKEY` | MinIO secret key |
-| `DURATION_OF_PRE_SIGNED_DOCUMENT` | Presigned URL expiry in seconds (default: 120) |
+Increase `DURATION_OF_PRE_SIGNED_DOCUMENT` or pass custom expiry:
 
-## Exports
+```typescript
+await this.minioService.generatePresignedUploadUrl(file, "folder", 3600);
+```
 
-- `MinIoModule` — Register the MinIO module
-- `MinIOService` — Upload, download, presigned URLs
-- `BucketNameEnum` — Bucket name constants
-- `PresignedFileUploadDto` — DTO for presigned upload responses
+### Q: File upload fails with CORS?
+
+Configure MinIO CORS:
+
+```bash
+mc cors set minio/ALIAS <<EOF
+{
+  "CORSRules": [{
+    "AllowedOrigins": ["*"],
+    "AllowedMethods": ["GET", "PUT", "POST", "DELETE"],
+    "AllowedHeaders": ["*"]
+  }]
+}
+EOF
+```
 
 ## Related Packages
 
 - [@zola_do/document-manipulator](../document-manipulator) — Uses MinIO for document storage
 
+## License
+
+ISC
+
 ## Community
 
 - [Contributing](../../CONTRIBUTING.md)

package/dist/index.d.ts

@@ -1,4 +1,6 @@
+export * from './zola-object-storage';
 export * from './presigned-file-upload.dto';
 export * from './bucket-name.enum';
 export * from './min-io.module';
 export * from './min-io.service';
+export * from './min-io.zola-object-storage';

package/dist/index.js

@@ -14,8 +14,10 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./zola-object-storage"), exports);
 __exportStar(require("./presigned-file-upload.dto"), exports);
 __exportStar(require("./bucket-name.enum"), exports);
 __exportStar(require("./min-io.module"), exports);
 __exportStar(require("./min-io.service"), exports);
+__exportStar(require("./min-io.zola-object-storage"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8DAA4C;AAC5C,qDAAmC;AACnC,kDAAgC;AAChC,mDAAiC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wDAAsC;AACtC,8DAA4C;AAC5C,qDAAmC;AACnC,kDAAgC;AAChC,mDAAiC;AACjC,+DAA6C"}

package/dist/min-io.module.js

@@ -11,6 +11,7 @@ exports.MinIOModule = void 0;
 const common_1 = require("@nestjs/common");
 const nestjs_minio_client_1 = require("nestjs-minio-client");
 const min_io_service_1 = require("./min-io.service");
+const min_io_zola_object_storage_1 = require("./min-io.zola-object-storage");
 let MinIOModule = class MinIOModule {
 };
 exports.MinIOModule = MinIOModule;
@@ -26,8 +27,8 @@ exports.MinIOModule = MinIOModule = __decorate([
             }),
         ],
         controllers: [],
-        providers: [min_io_service_1.MinIOService],
-        exports: [min_io_service_1.MinIOService],
+        providers: [min_io_service_1.MinIOService, min_io_zola_object_storage_1.MinioZolaObjectStorage],
+        exports: [min_io_service_1.MinIOService, min_io_zola_object_storage_1.MinioZolaObjectStorage],
     })
 ], MinIOModule);
 //# sourceMappingURL=min-io.module.js.map

package/dist/min-io.module.js.map

@@ -1 +1 @@
-{"version":3,"file":"min-io.module.js","sourceRoot":"","sources":["../src/min-io.module.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAAwC;AACxC,6DAAkD;AAClD,qDAAgD;AAgBzC,IAAM,WAAW,GAAjB,MAAM,WAAW;CAAG,CAAA;AAAd,kCAAW;sBAAX,WAAW;IAdvB,IAAA,eAAM,EAAC;QACN,OAAO,EAAE;YACP,iCAAW,CAAC,QAAQ,CAAC;gBACnB,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc;gBACpC,IAAI,EAAE,MAAM,CAAC,MAAA,OAAO,CAAC,GAAG,CAAC,UAAU,mCAAI,GAAG,CAAC;gBAC3C,MAAM,EAAE,OAAO,CAAC,MAAA,OAAO,CAAC,GAAG,CAAC,YAAY,mCAAI,IAAI,CAAC;gBACjD,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,eAAe;gBACtC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,eAAe;aACvC,CAAC;SACH;QACD,WAAW,EAAE,EAAE;QACf,SAAS,EAAE,CAAC,6BAAY,CAAC;QACzB,OAAO,EAAE,CAAC,6BAAY,CAAC;KACxB,CAAC;GACW,WAAW,CAAG"}
+{"version":3,"file":"min-io.module.js","sourceRoot":"","sources":["../src/min-io.module.ts"],"names":[],"mappings":";;;;;;;;;;AAAA,2CAAwC;AACxC,6DAAkD;AAClD,qDAAgD;AAChD,6EAAsE;AAgB/D,IAAM,WAAW,GAAjB,MAAM,WAAW;CAAG,CAAA;AAAd,kCAAW;sBAAX,WAAW;IAdvB,IAAA,eAAM,EAAC;QACN,OAAO,EAAE;YACP,iCAAW,CAAC,QAAQ,CAAC;gBACnB,QAAQ,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc;gBACpC,IAAI,EAAE,MAAM,CAAC,MAAA,OAAO,CAAC,GAAG,CAAC,UAAU,mCAAI,GAAG,CAAC;gBAC3C,MAAM,EAAE,OAAO,CAAC,MAAA,OAAO,CAAC,GAAG,CAAC,YAAY,mCAAI,IAAI,CAAC;gBACjD,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,eAAe;gBACtC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,eAAe;aACvC,CAAC;SACH;QACD,WAAW,EAAE,EAAE;QACf,SAAS,EAAE,CAAC,6BAAY,EAAE,mDAAsB,CAAC;QACjD,OAAO,EAAE,CAAC,6BAAY,EAAE,mDAAsB,CAAC;KAChD,CAAC;GACW,WAAW,CAAG"}

package/dist/min-io.zola-object-storage.d.ts

@@ -0,0 +1,16 @@
+import { ZolaObjectStorage, ZolaStoredFileRef } from './zola-object-storage';
+import { MinIOService } from './min-io.service';
+export declare class MinioZolaObjectStorage implements ZolaObjectStorage {
+    private readonly minio;
+    constructor(minio: MinIOService);
+    uploadFile(file: Express.Multer.File, bucketName: string, metaData?: Record<string, string>): Promise<ZolaStoredFileRef>;
+    uploadBuffer(buffer: Buffer, originalname: string, mimetype: string, bucketName: string, metaData?: Record<string, string>): Promise<ZolaStoredFileRef>;
+    generatePresignedUploadUrl(fileInfo: {
+        originalname: string;
+        contentType?: string;
+    }, bucketName: string): Promise<{
+        presignedUrl: string;
+        file: ZolaStoredFileRef;
+    }>;
+    generatePresignedDownloadUrl(fileInfo: Pick<ZolaStoredFileRef, 'bucketName' | 'filepath' | 'contentType' | 'originalname'>): Promise<string>;
+}

package/dist/min-io.zola-object-storage.js

@@ -0,0 +1,41 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MinioZolaObjectStorage = void 0;
+const common_1 = require("@nestjs/common");
+const min_io_service_1 = require("./min-io.service");
+let MinioZolaObjectStorage = class MinioZolaObjectStorage {
+    constructor(minio) {
+        this.minio = minio;
+    }
+    uploadFile(file, bucketName, metaData) {
+        return this.minio.upload(file, bucketName, metaData);
+    }
+    uploadBuffer(buffer, originalname, mimetype, bucketName, metaData) {
+        return this.minio.uploadBuffer(buffer, originalname, mimetype, bucketName, metaData);
+    }
+    async generatePresignedUploadUrl(fileInfo, bucketName) {
+        const result = await this.minio.generatePresignedUploadUrl(fileInfo, bucketName);
+        return {
+            presignedUrl: result.presignedUrl,
+            file: result.file,
+        };
+    }
+    async generatePresignedDownloadUrl(fileInfo) {
+        return this.minio.generatePresignedDownloadUrl(fileInfo);
+    }
+};
+exports.MinioZolaObjectStorage = MinioZolaObjectStorage;
+exports.MinioZolaObjectStorage = MinioZolaObjectStorage = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [min_io_service_1.MinIOService])
+], MinioZolaObjectStorage);
+//# sourceMappingURL=min-io.zola-object-storage.js.map

package/dist/min-io.zola-object-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"min-io.zola-object-storage.js","sourceRoot":"","sources":["../src/min-io.zola-object-storage.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,2CAA4C;AAE5C,qDAAgD;AAGzC,IAAM,sBAAsB,GAA5B,MAAM,sBAAsB;IACjC,YAA6B,KAAmB;QAAnB,UAAK,GAAL,KAAK,CAAc;IAAG,CAAC;IAEpD,UAAU,CACR,IAAyB,EACzB,UAAkB,EAClB,QAAiC;QAEjC,OAAO,IAAI,CAAC,KAAK,CAAC,MAAM,CAAC,IAAI,EAAE,UAAU,EAAE,QAAQ,CAAC,CAAC;IACvD,CAAC;IAED,YAAY,CACV,MAAc,EACd,YAAoB,EACpB,QAAgB,EAChB,UAAkB,EAClB,QAAiC;QAEjC,OAAO,IAAI,CAAC,KAAK,CAAC,YAAY,CAC5B,MAAM,EACN,YAAY,EACZ,QAAQ,EACR,UAAU,EACV,QAAQ,CACT,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,0BAA0B,CAC9B,QAAwD,EACxD,UAAkB;QAElB,MAAM,MAAM,GAAG,MAAM,IAAI,CAAC,KAAK,CAAC,0BAA0B,CACxD,QAAQ,EACR,UAAU,CACX,CAAC;QACF,OAAO;YACL,YAAY,EAAE,MAAM,CAAC,YAAY;YACjC,IAAI,EAAE,MAAM,CAAC,IAAI;SAClB,CAAC;IACJ,CAAC;IAED,KAAK,CAAC,4BAA4B,CAChC,QAGC;QAED,OAAO,IAAI,CAAC,KAAK,CAAC,4BAA4B,CAAC,QAAQ,CAAC,CAAC;IAC3D,CAAC;CACF,CAAA;AAjDY,wDAAsB;iCAAtB,sBAAsB;IADlC,IAAA,mBAAU,GAAE;qCAEyB,6BAAY;GADrC,sBAAsB,CAiDlC"}

package/dist/zola-object-storage.d.ts

@@ -0,0 +1,19 @@
+export type ZolaStoredFileRef = {
+    filepath: string;
+    bucketName: string;
+    contentType: string;
+    originalname: string;
+};
+export interface ZolaObjectStorage {
+    uploadFile(file: Express.Multer.File, bucketName: string, metaData?: Record<string, string>): Promise<ZolaStoredFileRef>;
+    uploadBuffer(buffer: Buffer, originalname: string, mimetype: string, bucketName: string, metaData?: Record<string, string>): Promise<ZolaStoredFileRef>;
+    generatePresignedUploadUrl(fileInfo: {
+        originalname: string;
+        contentType?: string;
+    }, bucketName: string): Promise<{
+        presignedUrl: string;
+        file: ZolaStoredFileRef;
+    }>;
+    generatePresignedDownloadUrl(fileInfo: Pick<ZolaStoredFileRef, 'bucketName' | 'filepath' | 'contentType' | 'originalname'>): Promise<string>;
+}
+export declare const ZOLA_STORAGE_CONTRACT_VERSION: 1;

package/dist/zola-object-storage.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ZOLA_STORAGE_CONTRACT_VERSION = void 0;
+exports.ZOLA_STORAGE_CONTRACT_VERSION = 1;
+//# sourceMappingURL=zola-object-storage.js.map

package/dist/zola-object-storage.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"zola-object-storage.js","sourceRoot":"","sources":["../src/zola-object-storage.ts"],"names":[],"mappings":";;;AA2Ca,QAAA,6BAA6B,GAAG,CAAU,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zola_do/minio",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "MinIO object storage for NestJS",
   "author": "zolaDO",
   "license": "ISC",