Add minio and kv modules

src/minio/minio.module.ts

@@ -0,0 +1,7 @@
+import { Module } from '@nestjs/common';
+import { MinioService } from './minio.service';
+
+@Module({
+  providers: [MinioService]
+})
+export class MinioModule {}

src/minio/minio.service.spec.ts

@@ -0,0 +1,18 @@
+import { Test, TestingModule } from '@nestjs/testing';
+import { MinioService } from './minio.service';
+
+describe('MinioService', () => {
+  let service: MinioService;
+
+  beforeEach(async () => {
+    const module: TestingModule = await Test.createTestingModule({
+      providers: [MinioService],
+    }).compile();
+
+    service = module.get<MinioService>(MinioService);
+  });
+
+  it('should be defined', () => {
+    expect(service).toBeDefined();
+  });
+});

src/minio/minio.service.ts

@@ -0,0 +1,91 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { Client, ItemBucketMetadata, UploadedObjectInfo } from 'minio';
+
+@Injectable()
+export class MinioService {
+  private readonly client: Client;
+  public readonly defaultBucketName: string;
+
+  constructor(private readonly configService: ConfigService) {
+    this.client = new Client({
+      endPoint: this.configService.get<string>('S3_ENDPOINT', 's3.hooli.co'),
+      port: this.configService.get<number>('S3_PORT', 443),
+      useSSL: true,
+      accessKey: this.configService.get<string>('S3_ACCESS_KEY', ''),
+      secretKey: this.configService.get<string>('S3_SECRET_KEY', ''),
+    });
+    this.defaultBucketName = this.configService.get<string>('S3_BUCKET', '');
+  }
+
+  public async uploadFile(
+    bucketName: string,
+    objectName: string,
+    filePath: string,
+    metadata?: ItemBucketMetadata,
+  ): Promise<UploadedObjectInfo> {
+    return await this.client.fPutObject(
+      bucketName,
+      objectName,
+      filePath,
+      metadata,
+    );
+  }
+
+  public async uploadBuffer(
+    bucketName: string,
+    objectName: string,
+    buffer: Buffer,
+    metadata?: ItemBucketMetadata,
+  ): Promise<UploadedObjectInfo> {
+    return await this.client.putObject(
+      bucketName,
+      objectName,
+      buffer,
+      metadata,
+    );
+  }
+
+  public async getBuffer(
+    bucketName: string,
+    objectName: string,
+  ): Promise<Buffer> {
+    const objectStream = await this.client.getObject(bucketName, objectName);
+    return await new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      objectStream.on('data', (chunk) => chunks.push(chunk));
+      objectStream.on('end', () => resolve(Buffer.concat(chunks)));
+      objectStream.on('error', (err) => reject(err));
+    });
+  }
+
+  public async getObjectMetadata(
+    bucketName: string,
+    objectName: string,
+  ): Promise<ItemBucketMetadata> {
+    return await this.client.statObject(bucketName, objectName);
+  }
+
+  public async listBucketObjects(
+    bucketName: string,
+    prefix?: string,
+  ): Promise<string[]> {
+    const objectStream = await this.client.listObjects(bucketName, prefix);
+    const objects = await new Promise<ItemBucketMetadata[]>(
+      (resolve, reject) => {
+        const objects: ItemBucketMetadata[] = [];
+        objectStream.on('data', (object) => objects.push(object));
+        objectStream.on('end', () => resolve(objects));
+        objectStream.on('error', (err) => reject(err));
+      },
+    );
+    return objects.map((object) => object.name);
+  }
+
+  public async deleteObject(
+    bucketName: string,
+    objectName: string,
+  ): Promise<void> {
+    await this.client.removeObject(bucketName, objectName);
+  }
+}