feat(server): implement policy schema & apis (#574)

Author: maslow

server/package-lock.json

@@ -29,7 +29,7 @@
     "@nestjs/axios": "^1.0.0",
     "@nestjs/common": "^9.0.0",
     "@nestjs/config": "^2.2.0",
-    "@nestjs/core": "^9.0.0",
+    "@nestjs/core": "^9.2.1",
     "@nestjs/jwt": "^9.0.0",
     "@nestjs/mapped-types": "*",
     "@nestjs/passport": "^9.0.0",

server/package.json

@@ -130,6 +130,18 @@ model ApplicationConfiguration {
   application Application @relation(fields: [appid], references: [appid])
 }
 
+model DatabasePolicy {
+  id        String   @id @default(auto()) @map("_id") @db.ObjectId
+  appid     String
+  name      String
+  rules     String
+  injector  String?
+  createdAt DateTime @default(now())
+  updatedAt DateTime @updatedAt
+
+  @@unique([appid, name])
+}
+
 enum HttpMethod {
   GET
   POST

server/prisma/schema.prisma

@@ -1 +1,12 @@
-export class CreatePolicyDto {}
+import { ApiProperty } from '@nestjs/swagger'
+import { IsNotEmpty } from 'class-validator'
+
+export class CreatePolicyDto {
+  @ApiProperty()
+  @IsNotEmpty()
+  name: string
+
+  @ApiProperty()
+  @IsNotEmpty()
+  rules: string
+}

server/src/database/dto/create-policy.dto.ts

@@ -1,4 +1,7 @@
-import { PartialType } from '@nestjs/mapped-types'
-import { CreatePolicyDto } from './create-policy.dto'
-
-export class UpdatePolicyDto extends PartialType(CreatePolicyDto) {}
+import { ApiProperty } from '@nestjs/swagger'
+import { IsNotEmpty } from 'class-validator'
+export class UpdatePolicyDto {
+  @ApiProperty()
+  @IsNotEmpty()
+  rules: string
+}

server/src/database/dto/update-policy.dto.ts

@@ -6,11 +6,20 @@ import {
   Patch,
   Param,
   Delete,
+  UseGuards,
 } from '@nestjs/common'
 import { PolicyService } from './policy.service'
 import { CreatePolicyDto } from './dto/create-policy.dto'
-import { ApiBearerAuth, ApiOperation, ApiTags } from '@nestjs/swagger'
+import {
+  ApiBearerAuth,
+  ApiOperation,
+  ApiResponse,
+  ApiTags,
+} from '@nestjs/swagger'
 import { UpdatePolicyDto } from './dto/update-policy.dto'
+import { ResponseUtil } from 'src/utils/response'
+import { JwtAuthGuard } from 'src/auth/jwt.auth.guard'
+import { ApplicationAuthGuard } from 'src/auth/application.auth.guard'
 
 @ApiTags('Database')
 @ApiBearerAuth('Authorization')
@@ -19,32 +28,58 @@ export class PolicyController {
   constructor(private readonly policiesService: PolicyService) {}
 
   @Post()
-  @ApiOperation({ summary: 'TODO - ⌛️' })
-  create(@Body() createPolicyDto: CreatePolicyDto) {
-    return this.policiesService.create(createPolicyDto)
+  @ApiOperation({ summary: 'Create database policy' })
+  @ApiResponse({ type: ResponseUtil })
+  @UseGuards(JwtAuthGuard, ApplicationAuthGuard)
+  async create(@Param('appid') appid: string, @Body() dto: CreatePolicyDto) {
+    // check name existed
+    const existed = await this.policiesService.findOne(appid, dto.name)
+    if (existed) {
+      return ResponseUtil.error('Policy name existed')
+    }
+    const doc = await this.policiesService.create(appid, dto)
+    return ResponseUtil.ok(doc)
   }
 
   @Get()
-  @ApiOperation({ summary: 'TODO - ⌛️' })
-  findAll() {
-    return this.policiesService.findAll()
+  @ApiOperation({ summary: 'Get database policy list' })
+  @ApiResponse({ type: ResponseUtil })
+  @UseGuards(JwtAuthGuard, ApplicationAuthGuard)
+  async findAll(@Param('appid') appid: string) {
+    const docs = await this.policiesService.findAll(appid)
+    return ResponseUtil.ok(docs)
   }
 
-  @Get(':id')
-  @ApiOperation({ summary: 'TODO - ⌛️' })
-  findOne(@Param('id') id: string) {
-    return this.policiesService.findOne(+id)
+  @Patch(':name')
+  @ApiOperation({ summary: 'Update policy rules' })
+  @ApiResponse({ type: ResponseUtil })
+  @UseGuards(JwtAuthGuard, ApplicationAuthGuard)
+  async update(
+    @Param('appid') appid: string,
+    @Param('name') name: string,
+    @Body() dto: UpdatePolicyDto,
+  ) {
+    // check policy exists
+    const existed = await this.policiesService.findOne(appid, name)
+    if (!existed) {
+      return ResponseUtil.error('Policy not found')
+    }
+    const res = await this.policiesService.update(appid, name, dto)
+    return ResponseUtil.ok(res)
   }
 
-  @Patch(':id')
-  @ApiOperation({ summary: 'TODO - ⌛️' })
-  update(@Param('id') id: string, @Body() updatePolicyDto: UpdatePolicyDto) {
-    return this.policiesService.update(+id, updatePolicyDto)
-  }
+  @Delete(':name')
+  @ApiOperation({ summary: 'Remove a database policy' })
+  @ApiResponse({ type: ResponseUtil })
+  @UseGuards(JwtAuthGuard, ApplicationAuthGuard)
+  async remove(@Param('appid') appid: string, @Param('name') name: string) {
+    // check policy exists
+    const existed = await this.policiesService.findOne(appid, name)
+    if (!existed) {
+      return ResponseUtil.error('Policy not found')
+    }
 
-  @Delete(':id')
-  @ApiOperation({ summary: 'TODO - ⌛️' })
-  remove(@Param('id') id: string) {
-    return this.policiesService.remove(+id)
+    const res = await this.policiesService.remove(appid, name)
+    return ResponseUtil.ok(res)
   }
 }

server/src/database/policy.controller.ts

@@ -1,26 +1,103 @@
 import { Injectable } from '@nestjs/common'
+import { DatabasePolicy } from '@prisma/client'
+import { CN_PUBLISHED_POLICIES } from 'src/constants'
+import { DatabaseCoreService } from 'src/core/database.cr.service'
+import { PrismaService } from 'src/prisma.service'
 import { CreatePolicyDto } from './dto/create-policy.dto'
 import { UpdatePolicyDto } from './dto/update-policy.dto'
 
 @Injectable()
 export class PolicyService {
-  create(createPolicyDto: CreatePolicyDto) {
-    return 'This action adds a new policy'
+  constructor(
+    private readonly prisma: PrismaService,
+    private readonly db: DatabaseCoreService,
+  ) {}
+
+  async create(appid: string, createPolicyDto: CreatePolicyDto) {
+    const res = await this.prisma.databasePolicy.create({
+      data: {
+        appid,
+        name: createPolicyDto.name,
+        rules: createPolicyDto.rules,
+      },
+    })
+
+    await this.publish(res)
+    return res
+  }
+
+  async findAll(appid: string) {
+    const res = await this.prisma.databasePolicy.findMany({
+      where: {
+        appid,
+      },
+    })
+    return res
   }
 
-  findAll() {
-    return `This action returns all policies`
+  async findOne(appid: string, name: string) {
+    const res = await this.prisma.databasePolicy.findUnique({
+      where: {
+        appid_name: {
+          appid,
+          name,
+        },
+      },
+    })
+    return res
+  }
+
+  async update(appid: string, name: string, dto: UpdatePolicyDto) {
+    const res = await this.prisma.databasePolicy.update({
+      where: {
+        appid_name: {
+          appid,
+          name,
+        },
+      },
+      data: {
+        rules: dto.rules,
+      },
+    })
+
+    await this.publish(res)
+    return res
   }
 
-  findOne(id: number) {
-    return `This action returns a #${id} policy`
+  async remove(appid: string, name: string) {
+    const res = await this.prisma.databasePolicy.delete({
+      where: {
+        appid_name: {
+          appid,
+          name,
+        },
+      },
+    })
+    await this.unpublish(res)
+    return res
   }
 
-  update(id: number, updatePolicyDto: UpdatePolicyDto) {
-    return `This action updates a #${id} policy`
+  async publish(policy: DatabasePolicy) {
+    const { db, client } = await this.db.findAndConnect(policy.appid)
+    const session = client.startSession()
+    try {
+      await session.withTransaction(async () => {
+        const coll = db.collection(CN_PUBLISHED_POLICIES)
+        await coll.deleteOne({ name: policy.name }, { session })
+        await coll.insertOne(policy, { session })
+      })
+    } finally {
+      await client.close()
+    }
   }
 
-  remove(id: number) {
-    return `This action removes a #${id} policy`
+  async unpublish(appid: string, name: string) {
+    const { db, client } = await this.db.findAndConnect(appid)
+    try {
+      const coll = db.collection(CN_PUBLISHED_POLICIES)
+      await coll.deleteOne({ name })
+    } finally {
+      await client.close()
+    }
   }
 }