adding in rules endpoint to api

.vscode/launch.json

@@ -0,0 +1,18 @@
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "type": "node",
+      "request": "launch",
+      "name": "Debug NestJS (start:debug)",
+      "runtimeExecutable": "pnpm",
+      "runtimeArgs": ["run", "start:debug"],
+      "cwd": "${workspaceFolder}",
+      "console": "integratedTerminal",
+      "sourceMaps": true,
+      "autoAttachChildProcesses": true,
+      "envFile": "${workspaceFolder}/.env",
+      "skipFiles": ["<node_internals>/**"]
+    }
+  ]
+}

src/app.module.ts

@@ -14,6 +14,7 @@ import { join } from 'path';
 import { ThrottlerGuard, ThrottlerModule } from '@nestjs/throttler';
 import { APP_GUARD } from '@nestjs/core';
 import { DevicesModule } from './devices/devices.module';
+import { RulesModule } from './rules/rules.module';
 
 @Module({
   imports: [
@@ -37,6 +38,7 @@ import { DevicesModule } from './devices/devices.module';
       },
     ]),
     DevicesModule,
+    RulesModule,
   ],
   controllers: [AppController],
   providers: [AppService, { provide: APP_GUARD, useClass: ThrottlerGuard }],

src/main.ts

@@ -31,6 +31,9 @@ async function bootstrap() {
     customSwaggerUiPath: join(process.cwd(), 'static', 'docs'),
     customCssUrl: '/cw-swagger.css',
     customfavIcon: '/favicon.svg',
+    swaggerOptions: {
+      persistAuthorization: true,
+    },
   });
   app.use(
     helmet({

src/rules/dto/create-rule.dto.ts

@@ -0,0 +1,42 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Database } from '../../../database.types';
+
+type RuleInsert = Database['public']['Tables']['cw_rules']['Insert'];
+
+export class CreateRuleDto implements RuleInsert {
+	@ApiProperty()
+	action_recipient: string;
+
+	@ApiProperty()
+	name: string;
+
+	@ApiProperty()
+	notifier_type: number;
+
+	@ApiProperty()
+	ruleGroupId: string;
+
+	@ApiProperty({ required: false })
+	created_at?: string;
+
+	@ApiProperty({ required: false, nullable: true })
+	dev_eui?: string | null;
+
+	@ApiProperty({ required: false })
+	id?: number;
+
+	@ApiProperty({ required: false })
+	is_triggered?: boolean;
+
+	@ApiProperty({ required: false, nullable: true })
+	last_triggered?: string | null;
+
+	@ApiProperty({ required: false })
+	profile_id?: string;
+
+	@ApiProperty({ required: false, nullable: true })
+	send_using?: string | null;
+
+	@ApiProperty({ required: false })
+	trigger_count?: number;
+}

src/rules/dto/rule.dto.ts

@@ -0,0 +1,42 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Database } from '../../../database.types';
+
+type RuleRow = Database['public']['Tables']['cw_rules']['Row'];
+
+export class RuleDto implements RuleRow {
+	@ApiProperty()
+	id: number;
+
+	@ApiProperty()
+	name: string;
+
+	@ApiProperty()
+	action_recipient: string;
+
+	@ApiProperty()
+	notifier_type: number;
+
+	@ApiProperty()
+	ruleGroupId: string;
+
+	@ApiProperty()
+	profile_id: string;
+
+	@ApiProperty({ nullable: true, required: false })
+	dev_eui: string | null;
+
+	@ApiProperty({ nullable: true, required: false })
+	send_using: string | null;
+
+	@ApiProperty()
+	is_triggered: boolean;
+
+	@ApiProperty()
+	trigger_count: number;
+
+	@ApiProperty({ format: 'date-time' })
+	created_at: string;
+
+	@ApiProperty({ nullable: true, required: false, format: 'date-time' })
+	last_triggered: string | null;
+}

src/rules/dto/update-rule.dto.ts

@@ -0,0 +1,9 @@
+import { PartialType } from '@nestjs/swagger';
+import { Database } from '../../../database.types';
+import { CreateRuleDto } from './create-rule.dto';
+
+type RuleUpdate = Database['public']['Tables']['cw_rules']['Update'];
+
+export class UpdateRuleDto
+	extends PartialType(CreateRuleDto)
+	implements RuleUpdate {}

src/rules/entities/rule.entity.ts

@@ -0,0 +1 @@
+export class Rule {}

src/rules/rules.controller.spec.ts

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

src/rules/rules.controller.ts

@@ -0,0 +1,82 @@
+import { Controller, Get, Post, Body, Patch, Param, Delete, Req, UseGuards } from '@nestjs/common';
+import { RulesService } from './rules.service';
+import { CreateRuleDto } from './dto/create-rule.dto';
+import { UpdateRuleDto } from './dto/update-rule.dto';
+import { ApiBearerAuth, ApiOkResponse, ApiSecurity } from '@nestjs/swagger';
+import { JwtAuthGuard } from '../auth/guards/jwt.auth.guard';
+import { RuleDto } from './dto/rule.dto';
+
+@ApiBearerAuth('bearerAuth')
+@ApiSecurity('apiKey')
+@Controller('rules')
+export class RulesController {
+  constructor(private readonly rulesService: RulesService) { }
+
+  @UseGuards(JwtAuthGuard)
+  @ApiOkResponse({
+    description:
+      "Create a new rule configuration. Only the fields included in the request body will be used.",
+    type: RuleDto,
+    isArray: false,
+  })
+  @Post()
+  create(@Body() createRuleDto: CreateRuleDto, @Req() req) {
+    const authHeader = req.headers?.authorization;
+    if (!authHeader) {
+      throw new Error('Authorization header is required');
+    }
+    return this.rulesService.create(createRuleDto, req.user, authHeader);
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @ApiOkResponse({
+    description:
+      "Current all of the user's rules configurations.",
+    type: RuleDto,
+    isArray: true,
+  })
+  @Get()
+  findAll(@Req() req) {
+    const authHeader = req.headers?.authorization ?? '';
+    return this.rulesService.findAll(req.user, authHeader);
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @ApiOkResponse({
+    description:
+      "Gets a user's rule configuration by ID.",
+    type: RuleDto,
+    isArray: false,
+  })
+  @Get(':id')
+  findOne(@Param('id') id: number, @Req() req) {
+    const authHeader = req.headers?.authorization ?? '';
+    return this.rulesService.findOne(id, req.user, authHeader);
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @ApiOkResponse({
+    description:
+      "Update a single rule configuration by ID. Only the fields included in the request body will be updated.",
+    type: RuleDto,
+    isArray: false,
+  })
+  @Patch(':id')
+  update(@Param('id') id: number, @Body() updateRuleDto: UpdateRuleDto, @Req() req) {
+    const authHeader = req.headers?.authorization ?? '';
+    return this.rulesService.update(id, updateRuleDto, req.user, authHeader);
+  }
+
+  @UseGuards(JwtAuthGuard)
+  @ApiOkResponse({
+    description:
+      "Delete a user's rule configuration by ID.",
+    type: Number,
+    isArray: false,
+  })
+  @Delete(':id')
+  remove(@Param('id') id: number, @Req() req) {
+    const authHeader = req.headers?.authorization ?? '';
+    return this.rulesService.remove(id, req.user, authHeader);
+  }
+}

src/rules/rules.module.ts

@@ -0,0 +1,11 @@
+import { Module } from '@nestjs/common';
+import { RulesService } from './rules.service';
+import { RulesController } from './rules.controller';
+import { SupabaseModule } from '../supabase/supabase.module';
+
+@Module({
+  imports: [SupabaseModule],
+  controllers: [RulesController],
+  providers: [RulesService],
+})
+export class RulesModule { }

src/rules/rules.service.spec.ts

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