MBC CQRS serverless framework Core package

import { CoreModule } from '@mbc-cqrs-serverless/core';
import { Module } from '@nestjs/common';

@Module({
  imports: [
    CoreModule.forRoot({
      region: 'ap-northeast-1',
      stage: 'dev',
    }),
  ],
})
export class AppModule {}

import { CommandInputModel } from '@mbc-cqrs-serverless/core';

export class CreateUserCommand implements CommandInputModel {
  readonly pk: string;
  readonly sk: string;
  readonly id: string;
  
  constructor(public readonly userId: string, public readonly userData: any) {
    this.pk = `USER#${userId}`;
    this.sk = `METADATA#${userId}`;
    this.id = userId;
  }
}

import { CommandHandler, ICommandHandler } from '@mbc-cqrs-serverless/core';

@CommandHandler(CreateUserCommand)
export class CreateUserHandler implements ICommandHandler<CreateUserCommand> {
  async execute(command: CreateUserCommand): Promise<void> {
    // Implementation
  }
}

import { EventsHandler, IEventHandler } from '@mbc-cqrs-serverless/core';
import { UserCreatedEvent } from './user-created.event';

@EventsHandler(UserCreatedEvent)
export class UserCreatedHandler implements IEventHandler<UserCreatedEvent> {
  async handle(event: UserCreatedEvent): Promise<void> {
    // Implementation
  }
}

import { DataService, InjectDataService } from '@mbc-cqrs-serverless/core';

@Injectable()
export class UserService {
  constructor(
    @InjectDataService() private readonly dataService: DataService
  ) {}

  async getUser(userId: string): Promise<User> {
    return this.dataService.findOne({
      pk: `USER#${userId}`,
      sk: `METADATA#${userId}`,
    });
  }
}

import { RolesGuard, Roles } from '@mbc-cqrs-serverless/core';

@Controller('users')
@UseGuards(RolesGuard)
export class UserController {
  @Post()
  @Roles('admin')
  async createUser(@Body() userData: CreateUserDto): Promise<void> {
    // Implementation
  }
}

import { TenantContext, UseTenant } from '@mbc-cqrs-serverless/core';

@Injectable()
export class UserService {
  @UseTenant()
  async getUsersForTenant(
    @TenantContext() tenantId: string
  ): Promise<User[]> {
    // Implementation with automatic tenant isolation
  }
}

import { 
  StepFunctionService, 
  NotificationService 
} from '@mbc-cqrs-serverless/core';

@Injectable()
export class WorkflowService {
  constructor(
    private readonly stepFunctions: StepFunctionService,
    private readonly notifications: NotificationService
  ) {}

  async startWorkflow(data: any): Promise<void> {
    await this.stepFunctions.startExecution({
      stateMachineArn: 'your-state-machine-arn',
      input: JSON.stringify(data),
    });
  }
}

import { 
  CommandError,
  ValidationError,
  NotFoundError 
} from '@mbc-cqrs-serverless/core';

@CommandHandler(UpdateUserCommand)
export class UpdateUserHandler implements ICommandHandler<UpdateUserCommand> {
  async execute(command: UpdateUserCommand): Promise<void> {
    if (!command.userId) {
      throw new ValidationError('User ID is required');
    }
    
    const user = await this.userService.findById(command.userId);
    if (!user) {
      throw new NotFoundError(`User ${command.userId} not found`);
    }
    
    // Implementation
  }
}