Add minio and kv modules

src/kv/kv.controller.spec.ts

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

src/kv/kv.controller.ts

@@ -0,0 +1,94 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Req,
+  Body,
+  Param,
+  HttpException,
+} from '@nestjs/common';
+import { KvService } from './kv.service';
+import { Request } from 'express';
+
+@Controller('kv')
+export class KvController {
+  constructor(private readonly kvService: KvService) {}
+
+  @Get(':namespace/:key/metadata')
+  async getMetadata(
+    @Param('namespace') namespace: string,
+    @Param('key') key: string,
+    @Req() request: Request,
+  ): Promise<object> {
+    if (!request.headers['x-secret-key']) {
+      throw new HttpException("Missing 'X-Secret-Key' header", 403);
+    }
+    try {
+      return await this.kvService.queryObjectMetadata(
+        namespace,
+        key,
+        request.headers['x-secret-key'] as string,
+      );
+    } catch (e) {
+      throw new HttpException(e.message, 403);
+    }
+  }
+
+  @Get(':namespace/:key')
+  async get(
+    @Param('namespace') namespace: string,
+    @Param('key') key: string,
+    @Req() request: Request,
+  ): Promise<string> {
+    if (request.headers['x-secret-key']) {
+      try {
+        return await this.kvService.getWithSecretKey(
+          namespace,
+          key,
+          request.headers['x-secret-key'] as string,
+        );
+      } catch (e) {
+        throw new HttpException(e.message, 403);
+      }
+    }
+    try {
+      return await this.kvService.get(namespace, key);
+    } catch (e) {
+      throw new HttpException(e.message, 403);
+    }
+  }
+
+  @Post(':namespace/:key')
+  async create(
+    @Param('namespace') namespace: string,
+    @Param('key') key: string,
+    @Req() request: Request,
+    @Body() body: object,
+  ) {
+    const secretKey =
+      (request.headers['x-secret-key'] as string | undefined) ?? '';
+    const publicFlag = request.headers['x-public'] === 'true';
+    if (secretKey) {
+      return await this.kvService.set(
+        namespace,
+        key,
+        JSON.stringify(body),
+        secretKey,
+        { public: publicFlag },
+      );
+    }
+    return 'No secret key provided within X-Secret-Key header';
+  }
+
+  @Post(':namespace')
+  async claimNamespace(
+    @Param('namespace') namespace: string,
+    @Req() request: Request,
+  ) {
+    try {
+      return await this.kvService.claimNamespace(namespace);
+    } catch (e) {
+      throw new HttpException(e.message, 403);
+    }
+  }
+}

src/kv/kv.module.ts

@@ -0,0 +1,10 @@
+import { Module } from '@nestjs/common';
+import { KvService } from './kv.service';
+import { KvController } from './kv.controller';
+import { MinioService } from 'src/minio/minio.service';
+
+@Module({
+  providers: [KvService, MinioService],
+  controllers: [KvController],
+})
+export class KvModule {}

src/kv/kv.service.spec.ts

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

src/kv/kv.service.ts

@@ -0,0 +1,135 @@
+import { Injectable } from '@nestjs/common';
+import { UploadedObjectInfo } from 'minio';
+import { MinioService } from 'src/minio/minio.service';
+
+@Injectable()
+export class KvService {
+  private readonly kvBucketName = 'api.us.dev';
+  private readonly kvPrefix = 'kv';
+  private readonly kvMetadataFileName = 'metadata.json';
+  private readonly kvMetadataPath = `${this.kvPrefix}/${this.kvMetadataFileName}`;
+
+  constructor(private readonly minioService: MinioService) {}
+
+  public generateFilePath(namespace: string, key: string): string {
+    return `${this.kvPrefix}/${namespace}/${key}`;
+  }
+
+  private async getMetadataFile(): Promise<Buffer> {
+    return await this.minioService.getBuffer(
+      this.kvBucketName,
+      this.kvMetadataPath,
+    );
+  }
+
+  private async setMetadataFile(buffer: Buffer): Promise<void> {
+    await this.minioService.uploadBuffer(
+      this.kvBucketName,
+      this.kvMetadataPath,
+      buffer,
+    );
+  }
+
+  public async queryObjectMetadata(
+    namespace: string,
+    key: string,
+    secretKey: string,
+  ): Promise<object> {
+    const metadata = await this.getMetadataFile().then((buffer) =>
+      JSON.parse(buffer.toString()),
+    );
+    if (metadata[namespace]?.secretKey !== secretKey) {
+      throw new Error('Secret key does not match');
+    }
+    const objectMetadata = await this.minioService.getObjectMetadata(
+      this.kvBucketName,
+      this.generateFilePath(namespace, key),
+    );
+    return objectMetadata?.metaData;
+  }
+
+  public async get(namespace: string, key: string): Promise<string> {
+    const objectMetadata = await this.minioService.getObjectMetadata(
+      this.kvBucketName,
+      this.generateFilePath(namespace, key),
+    );
+    console.log(objectMetadata);
+    if (objectMetadata?.metaData.public !== 'true') {
+      throw new Error('Object is not public');
+    }
+    return await this.minioService
+      .getBuffer(this.kvBucketName, this.generateFilePath(namespace, key))
+      .then((buffer) => buffer.toString());
+  }
+
+  public async getWithSecretKey(
+    namespace: string,
+    key: string,
+    secretKey: string,
+  ): Promise<string> {
+    const metadata = await this.getMetadataFile().then((buffer) =>
+      JSON.parse(buffer.toString()),
+    );
+    if (metadata[namespace]?.secretKey !== secretKey) {
+      throw new Error('Secret key does not match');
+    }
+    return await this.minioService
+      .getBuffer(this.kvBucketName, this.generateFilePath(namespace, key))
+      .then((buffer) => buffer.toString());
+  }
+
+  public async claimNamespace(
+    namespace: string,
+    extraData: object = {},
+  ): Promise<void> {
+    const metadata = await this.getMetadataFile().then((buffer) =>
+      JSON.parse(buffer.toString()),
+    );
+    if (metadata[namespace]?.secretKey) {
+      throw new Error('Namespace already claimed');
+    }
+    metadata[namespace] = {
+      ...extraData,
+      secretKey: Math.random().toString(36).substring(2),
+      claimed: new Date().toISOString(),
+    };
+    await this.setMetadataFile(Buffer.from(JSON.stringify(metadata)));
+    return metadata[namespace];
+  }
+
+  public async set(
+    namespace: string,
+    key: string,
+    value: string,
+    secretKey: string,
+    options: {
+      public: boolean;
+    } = {
+      public: false,
+    },
+  ): Promise<UploadedObjectInfo> {
+    const metadata = await this.getMetadataFile().then((buffer) =>
+      JSON.parse(buffer.toString()),
+    );
+    if (metadata[namespace]?.secretKey !== secretKey) {
+      throw new Error('Incorrect secret key for namespace');
+    }
+    return await this.minioService.uploadBuffer(
+      this.kvBucketName,
+      this.generateFilePath(namespace, key),
+      Buffer.from(value),
+      {
+        set: new Date().toISOString(),
+        namespace,
+        ...options,
+      },
+    );
+  }
+
+  public async delete(namespace: string, key: string): Promise<void> {
+    await this.minioService.deleteObject(
+      this.kvBucketName,
+      this.generateFilePath(namespace, key),
+    );
+  }
+}