create POST /v1/people/bulk endpoint

Author: chasprowebdev

apps/api/src/people/dto/bulk-create-people.dto.ts

@@ -0,0 +1,32 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsArray, ValidateNested, ArrayMinSize, ArrayMaxSize } from 'class-validator';
+import { CreatePeopleDto } from './create-people.dto';
+
+export class BulkCreatePeopleDto {
+  @ApiProperty({
+    description: 'Array of members to create',
+    type: [CreatePeopleDto],
+    example: [
+      {
+        userId: 'usr_abc123def456',
+        role: 'admin',
+        department: 'it',
+        isActive: true,
+        fleetDmLabelId: 123,
+      },
+      {
+        userId: 'usr_def456ghi789',
+        role: 'member',
+        department: 'hr',
+        isActive: true,
+      },
+    ],
+  })
+  @IsArray()
+  @ArrayMinSize(1, { message: 'Members array cannot be empty' })
+  @ArrayMaxSize(100, { message: 'Maximum 100 members allowed per bulk request' })
+  @ValidateNested({ each: true })
+  @Type(() => CreatePeopleDto)
+  members: CreatePeopleDto[];
+}

apps/api/src/people/people.controller.ts

@@ -25,6 +25,7 @@ import { HybridAuthGuard } from '../auth/hybrid-auth.guard';
 import type { AuthContext as AuthContextType } from '../auth/types';
 import { CreatePeopleDto } from './dto/create-people.dto';
 import { UpdatePeopleDto } from './dto/update-people.dto';
+import { BulkCreatePeopleDto } from './dto/bulk-create-people.dto';
 import { PeopleResponseDto } from './dto/people-responses.dto';
 import { PeopleService } from './people.service';
 
@@ -225,6 +226,152 @@ export class PeopleController {
     };
   }
 
+  @Post('bulk')
+  @ApiOperation({
+    summary: 'Add multiple members to organization',
+    description:
+      'Bulk adds multiple members to the authenticated organization. Each member must have a valid user ID that exists in the system. Members who already exist in the organization or have invalid data will be skipped with error details returned. Supports both API key authentication (X-API-Key header) and session authentication (cookies + X-Organization-Id header).',
+  })
+  @ApiBody({
+    description: 'Bulk member creation data',
+    type: BulkCreatePeopleDto,
+  })
+  @ApiResponse({
+    status: 201,
+    description: 'Bulk member creation completed',
+    schema: {
+      type: 'object',
+      properties: {
+        created: {
+          type: 'array',
+          items: { $ref: '#/components/schemas/PeopleResponseDto' },
+          description: 'Successfully created members',
+        },
+        errors: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              index: {
+                type: 'number',
+                description: 'Index in the original array where the error occurred',
+                example: 2,
+              },
+              userId: {
+                type: 'string',
+                description: 'User ID that failed to be added',
+                example: 'usr_abc123def456',
+              },
+              error: {
+                type: 'string',
+                description: 'Error message explaining why the member could not be created',
+                example: 'User [email protected] is already a member of this organization',
+              },
+            },
+          },
+          description: 'Members that failed to be created with error details',
+        },
+        summary: {
+          type: 'object',
+          properties: {
+            total: {
+              type: 'number',
+              description: 'Total number of members in the request',
+              example: 5,
+            },
+            successful: {
+              type: 'number',
+              description: 'Number of members successfully created',
+              example: 3,
+            },
+            failed: {
+              type: 'number',
+              description: 'Number of members that failed to be created',
+              example: 2,
+            },
+          },
+        },
+        authType: {
+          type: 'string',
+          enum: ['api-key', 'session'],
+          description: 'How the request was authenticated',
+        },
+        authenticatedUser: {
+          type: 'object',
+          properties: {
+            id: {
+              type: 'string',
+              description: 'User ID',
+              example: 'usr_abc123def456',
+            },
+            email: {
+              type: 'string',
+              description: 'User email',
+              example: '[email protected]',
+            },
+          },
+        },
+      },
+    },
+  })
+  @ApiResponse({
+    status: 400,
+    description: 'Bad Request - Invalid bulk data or validation errors',
+    schema: {
+      type: 'object',
+      properties: {
+        message: {
+          type: 'string',
+          examples: [
+            'Validation failed',
+            'Members array cannot be empty',
+            'Maximum 100 members allowed per bulk request',
+          ],
+        },
+      },
+    },
+  })
+  @ApiResponse({
+    status: 401,
+    description:
+      'Unauthorized - Invalid authentication or insufficient permissions',
+  })
+  @ApiResponse({
+    status: 404,
+    description: 'Organization not found',
+    schema: {
+      type: 'object',
+      properties: {
+        message: {
+          type: 'string',
+          example: 'Organization with ID org_abc123def456 not found',
+        },
+      },
+    },
+  })
+  @ApiResponse({
+    status: 500,
+    description: 'Internal server error',
+  })
+  async bulkCreateMembers(
+    @Body() bulkCreateData: BulkCreatePeopleDto,
+    @OrganizationId() organizationId: string,
+    @AuthContext() authContext: AuthContextType,
+  ) {
+    const result = await this.peopleService.bulkCreate(organizationId, bulkCreateData);
+
+    return {
+      ...result,
+      authType: authContext.authType,
+      ...(authContext.userId && authContext.userEmail && {
+        authenticatedUser: {
+          id: authContext.userId,
+          email: authContext.userEmail,
+        },
+      }),
+    };
+  }
+
   @Get(':id')
   @ApiOperation({
     summary: 'Get person by ID',

apps/api/src/people/people.service.ts

@@ -3,6 +3,7 @@ import { db } from '@trycompai/db';
 import type { PeopleResponseDto } from './dto/people-responses.dto';
 import type { CreatePeopleDto } from './dto/create-people.dto';
 import type { UpdatePeopleDto } from './dto/update-people.dto';
+import type { BulkCreatePeopleDto } from './dto/bulk-create-people.dto';
 
 @Injectable()
 export class PeopleService {
@@ -195,6 +196,125 @@ export class PeopleService {
     }
   }
 
+  async bulkCreate(organizationId: string, bulkCreateData: BulkCreatePeopleDto): Promise<{
+    created: PeopleResponseDto[];
+    errors: Array<{ index: number; userId: string; error: string }>;
+    summary: { total: number; successful: number; failed: number };
+  }> {
+    try {
+      // First verify the organization exists
+      const organization = await db.organization.findUnique({
+        where: { id: organizationId },
+        select: { id: true, name: true },
+      });
+
+      if (!organization) {
+        throw new NotFoundException(`Organization with ID ${organizationId} not found`);
+      }
+
+      const created: PeopleResponseDto[] = [];
+      const errors: Array<{ index: number; userId: string; error: string }> = [];
+
+      // Process each member in the bulk request
+      for (let i = 0; i < bulkCreateData.members.length; i++) {
+        const memberData = bulkCreateData.members[i];
+        try {
+          // Verify the user exists
+          const user = await db.user.findUnique({
+            where: { id: memberData.userId },
+            select: { id: true, name: true, email: true },
+          });
+
+          if (!user) {
+            errors.push({
+              index: i,
+              userId: memberData.userId,
+              error: `User with ID ${memberData.userId} not found`,
+            });
+            continue;
+          }
+
+          // Check if user is already a member of this organization
+          const existingMember = await db.member.findFirst({
+            where: {
+              userId: memberData.userId,
+              organizationId,
+            },
+          });
+
+          if (existingMember) {
+            errors.push({
+              index: i,
+              userId: memberData.userId,
+              error: `User ${user.email} is already a member of this organization`,
+            });
+            continue;
+          }
+
+          // Create the new member
+          const member = await db.member.create({
+            data: {
+              organizationId,
+              userId: memberData.userId,
+              role: memberData.role,
+              department: memberData.department || 'none',
+              isActive: memberData.isActive ?? true,
+              fleetDmLabelId: memberData.fleetDmLabelId || null,
+            },
+            select: {
+              id: true,
+              organizationId: true,
+              userId: true,
+              role: true,
+              createdAt: true,
+              department: true,
+              isActive: true,
+              fleetDmLabelId: true,
+              user: {
+                select: {
+                  id: true,
+                  name: true,
+                  email: true,
+                  emailVerified: true,
+                  image: true,
+                  createdAt: true,
+                  updatedAt: true,
+                  lastLogin: true,
+                },
+              },
+            },
+          });
+
+          created.push(member);
+          this.logger.log(`Created member: ${member.user.name} (${member.id}) for organization ${organizationId}`);
+        } catch (error) {
+          errors.push({
+            index: i,
+            userId: memberData.userId,
+            error: error.message || 'Unknown error occurred',
+          });
+          this.logger.error(`Failed to create member at index ${i} (userId: ${memberData.userId}):`, error);
+        }
+      }
+
+      const summary = {
+        total: bulkCreateData.members.length,
+        successful: created.length,
+        failed: errors.length,
+      };
+
+      this.logger.log(`Bulk create completed for organization ${organizationId}: ${summary.successful}/${summary.total} successful`);
+      
+      return { created, errors, summary };
+    } catch (error) {
+      if (error instanceof NotFoundException) {
+        throw error;
+      }
+      this.logger.error(`Failed to bulk create members for organization ${organizationId}:`, error);
+      throw new Error(`Failed to bulk create members: ${error.message}`);
+    }
+  }
+
   async updateById(memberId: string, organizationId: string, updateData: UpdatePeopleDto): Promise<PeopleResponseDto> {
     try {
       // First verify the organization exists