Completed kms

src/kms/kms.service.ts

@@ -1,8 +1,12 @@
 import { Injectable } from '@nestjs/common';
+import { Prisma } from '@prisma/client';
 
 import { PrismaService } from '../_prisma/prisma.service';
-import { ArnParts } from '../util/breakdown-arn';
+import { breakdownArn } from '../util/breakdown-arn';
 import { KmsKey } from './kms-key.entity';
+import { KmsAlias } from './kms-alias.entity';
+import { AwsProperties } from '../abstract-action.handler';
+import { NotFoundException } from '../aws-shared-entities/aws-exceptions';
 
 @Injectable()
 export class KmsService {
@@ -10,21 +14,103 @@ export class KmsService {
     private readonly prismaService: PrismaService,
   ) {}
 
-  async findOneById(id: string): Promise<KmsKey | null> {
-    const pRecord = await this.prismaService.kmsKey.findFirst({
-      where: { id }
-    });
-    return pRecord ? new KmsKey(pRecord) : null;
+  async findOneByRef(ref: string, awsProperties: AwsProperties): Promise<KmsKey> {
+    if (ref.startsWith('arn')) {
+      return await this.findOneByArn(ref);
+    }
+    return await this.findOneById(awsProperties.accountId, awsProperties.region, ref);
   }
 
-  async findKeyIdFromAlias(alias: string, arn: ArnParts): Promise<string | null> {
-    const record = await this.prismaService.kmsAlias.findFirst({
+  async findOneByArn(arn: string): Promise<KmsKey> {
+    const parts = breakdownArn(arn);
+    return await this.findOneById(parts.accountId, parts.region, parts.identifier.split('/')[1]);
+  }
+
+  async findOneById(accountId: string, region: string, ref: string): Promise<KmsKey> {
+
+    const [alias, record] = await Promise.all([
+      this.prismaService.kmsAlias.findFirst({
+        include: {
+          kmsKey: true
+        },
+        where: {
+          accountId,
+          region,
+          name: ref,
+        }
+      }),
+      this.prismaService.kmsKey.findFirst({
+        where: {
+          accountId,
+          region,
+          id: ref,
+        }
+      })
+    ]);
+
+    if (!alias?.kmsKey && !record) {
+      throw new NotFoundException();
+    }
+
+    return record ? new KmsKey(record) : new KmsKey(alias!.kmsKey);
+  }
+
+  async findAndCountAliasesByKeyId(accountId: string, region: string, limit: number, kmsKeyId: string, marker = ''): Promise<KmsAlias[]> {
+    const take = limit + 1;
+    const records = await this.prismaService.kmsAlias.findMany({
       where: {
-        name: alias,
-        accountId: arn.accountId,
-        region: arn.region,
-      }
+        accountId,
+        region,
+        kmsKeyId,
+        name: {
+          gte: marker,
+        }
+      },
+      take,
+      orderBy: {
+        name: 'desc',
+      },
+    });
+
+    return records.map(r => new KmsAlias(r));
+  }
+
+  async findAndCountAliases(accountId: string, region: string, limit: number, marker = ''): Promise<KmsAlias[]> {
+    const take = limit + 1;
+    const records = await this.prismaService.kmsAlias.findMany({
+      where: {
+        accountId,
+        region,
+        name: {
+          gte: marker,
+        }
+      },
+      take,
+      orderBy: {
+        name: 'desc',
+      },
+    });
+
+    return records.map(r => new KmsAlias(r));
+  }
+
+  async createKmsKey(data: Prisma.KmsKeyCreateInput): Promise<KmsKey> {
+    const record = await this.prismaService.kmsKey.create({
+      data
+    });
+    return new KmsKey(record);
+  }
+
+  async updateKmsKey(id: string, data: Prisma.KmsKeyUpdateInput): Promise<void> {
+    await this.prismaService.kmsKey.update({
+      where: { id },
+      data,
+    });
+  }
+
+  async createAlias(data: Prisma.KmsAliasCreateInput) {
+    await this.prismaService.kmsAlias.create({
+      data
     });
-    return record?.kmsKeyId ?? null;
   }
 }