ar-saas 0.4.3 → 0.5.0

package/templates/backend/src/modules/auth/auth.service.ts

@@ -17,14 +17,23 @@ import { ForgotPasswordDto } from './dto/forgot-password.dto';
 import { LoginDto } from './dto/login.dto';
 import { RegisterDto } from './dto/register.dto';
 import { ResetPasswordDto } from './dto/reset-password.dto';
+import { GithubProfile } from './strategies/github.strategy';
 
 interface TokenPair {
   accessToken: string;
   refreshToken: string;
 }
 
+interface OAuthCode {
+  userId: string;
+  alreadyExisted: boolean;
+  expiresAt: number;
+}
+
 @Injectable()
 export class AuthService {
+  private readonly oauthCodes = new Map<string, OAuthCode>();
+
   constructor(
     private readonly usersService: UsersService,
     private readonly workspacesService: WorkspacesService,
@@ -34,19 +43,19 @@ export class AuthService {
   ) {}
 
   async register(dto: RegisterDto): Promise<{ message: string }> {
-    const workspace = await this.workspacesService.create('pending', dto.name);
-    const workspaceId = String(workspace._id);
+    const user = await this.usersService.create({
+      name: dto.name,
+      email: dto.email,
+      password: dto.password,
+      workspaceId: '',
+    });
+    const userId = String(user._id);
 
     try {
-      const user = await this.usersService.create({
-        name: dto.name,
-        email: dto.email,
-        password: dto.password,
-        workspaceId,
-      });
-      const userId = String(user._id);
+      const workspace = await this.workspacesService.create(userId, dto.name);
+      const workspaceId = String(workspace._id);
 
-      await this.workspacesService.update(workspaceId, { ownerId: userId });
+      await this.usersService.updateWorkspaceId(userId, workspaceId);
 
       const token = this.generateSecureToken();
       const expiresAt = new Date(Date.now() + 24 * 60 * 60 * 1000);
@@ -55,7 +64,7 @@ export class AuthService {
 
       return { message: 'Verification email sent' };
     } catch (error) {
-      await this.workspacesService.delete(workspaceId);
+      await this.usersService.delete(userId);
       throw error;
     }
   }
@@ -192,6 +201,82 @@ export class AuthService {
     return { message: 'Password reset successful' };
   }
 
+  async githubLogin(
+    profile: GithubProfile,
+  ): Promise<{ code: string; alreadyExisted: boolean }> {
+    let alreadyExisted = false;
+    let user = await this.usersService.findByGithubId(profile.githubId);
+
+    if (!user) {
+      const existingByEmail = await this.usersService.findByEmail(profile.email);
+      if (existingByEmail) {
+        const existingId = String(existingByEmail._id);
+        await this.usersService.linkGithubId(existingId, profile.githubId);
+        if (!existingByEmail.emailVerified) {
+          await this.usersService.markEmailVerified(existingId);
+        }
+        user = await this.usersService.findById(existingId);
+        alreadyExisted = true;
+      } else {
+        user = await this.usersService.createGithubUser({
+          name: profile.name,
+          email: profile.email,
+          githubId: profile.githubId,
+          workspaceId: '',
+        });
+        const userId = String(user._id);
+        const workspace = await this.workspacesService.create(userId, profile.name);
+        const workspaceId = String(workspace._id);
+        await this.usersService.updateWorkspaceId(userId, workspaceId);
+        user = await this.usersService.findById(userId);
+      }
+    } else {
+      alreadyExisted = true;
+    }
+
+    if (!user) {
+      throw new InternalServerErrorException('Error al obtener el usuario.');
+    }
+
+    const userId = String(user._id);
+    await this.usersService.updateLastLoginAt(userId);
+
+    const code = crypto.randomBytes(32).toString('hex');
+    this.oauthCodes.set(code, {
+      userId,
+      alreadyExisted,
+      expiresAt: Date.now() + 30_000,
+    });
+
+    return { code, alreadyExisted };
+  }
+
+  async exchangeGithubCode(
+    code: string,
+  ): Promise<{ alreadyExisted: boolean } & TokenPair> {
+    const entry = this.oauthCodes.get(code);
+    if (!entry || entry.expiresAt < Date.now()) {
+      this.oauthCodes.delete(code);
+      throw new UnauthorizedException('Código inválido o expirado.');
+    }
+    this.oauthCodes.delete(code);
+
+    const user = await this.usersService.findById(entry.userId);
+    if (!user) {
+      throw new UnauthorizedException('Usuario no encontrado.');
+    }
+
+    const tokens = await this.generateTokens(
+      entry.userId,
+      user.email,
+      user.workspaceId,
+      user.role,
+    );
+    await this.usersService.updateRefreshToken(entry.userId, tokens.refreshToken);
+
+    return { alreadyExisted: entry.alreadyExisted, ...tokens };
+  }
+
   async getMe(userId: string): Promise<UserDocument> {
     const user = await this.usersService.findById(userId);
     if (!user) {

package/templates/backend/src/modules/auth/strategies/github.strategy.ts

@@ -0,0 +1,46 @@
+import { Injectable } from '@nestjs/common';
+import { ConfigService } from '@nestjs/config';
+import { PassportStrategy } from '@nestjs/passport';
+import { Strategy, Profile } from 'passport-github2';
+
+export interface GithubProfile {
+  githubId: string;
+  name: string;
+  email: string;
+  avatarUrl: string | null;
+}
+
+@Injectable()
+export class GithubStrategy extends PassportStrategy(Strategy, 'github') {
+  constructor(configService: ConfigService) {
+    const opts = {
+      clientID: configService.getOrThrow<string>('GITHUB_CLIENT_ID'),
+      clientSecret: configService.getOrThrow<string>('GITHUB_CLIENT_SECRET'),
+      callbackURL: configService.getOrThrow<string>('GITHUB_CALLBACK_URL'),
+      scope: ['user:email'],
+    };
+    super(opts);
+  }
+
+  validate(
+    _accessToken: string,
+    _refreshToken: string,
+    profile: Profile,
+    done: (err: Error | null, user: GithubProfile | false) => void,
+  ): void {
+    const email =
+      profile.emails?.[0]?.value ?? null;
+
+    if (!email) {
+      done(new Error('No public email on GitHub account'), false);
+      return;
+    }
+
+    done(null, {
+      githubId: profile.id,
+      name: profile.displayName || profile.username || email.split('@')[0],
+      email,
+      avatarUrl: profile.photos?.[0]?.value ?? null,
+    });
+  }
+}

package/templates/backend/src/modules/clients/clients.controller.ts

@@ -0,0 +1,91 @@
+import {
+  Body,
+  Controller,
+  Delete,
+  Get,
+  HttpCode,
+  HttpStatus,
+  Param,
+  Patch,
+  Post,
+  Query,
+  UseGuards,
+} from '@nestjs/common';
+import {
+  ApiBearerAuth,
+  ApiOperation,
+  ApiResponse,
+  ApiTags,
+} from '@nestjs/swagger';
+import { CurrentUser } from '../../common/decorators/current-user.decorator';
+import type { TokenPayload } from '../../common/decorators/current-user.decorator';
+import { WorkspaceId } from '../../common/decorators/workspace-id.decorator';
+import { JwtAuthGuard } from '../../common/guards/jwt-auth.guard';
+import { ClientsService } from './clients.service';
+import { CreateClientDto } from './dto/create-client.dto';
+import { QueryClientDto } from './dto/query-client.dto';
+import { UpdateClientDto } from './dto/update-client.dto';
+
+@ApiTags('Clients')
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+@Controller('clients')
+export class ClientsController {
+  constructor(private readonly clientsService: ClientsService) {}
+
+  @Get()
+  @ApiOperation({ summary: 'Listar clientes del workspace' })
+  @ApiResponse({ status: 200, description: 'Lista paginada de clientes' })
+  findAll(
+    @WorkspaceId() workspaceId: string,
+    @Query() query: QueryClientDto,
+  ) {
+    return this.clientsService.findAll(workspaceId, query);
+  }
+
+  @Get(':id')
+  @ApiOperation({ summary: 'Obtener un cliente por ID' })
+  @ApiResponse({ status: 200, description: 'Cliente encontrado' })
+  @ApiResponse({ status: 404, description: 'Cliente no encontrado' })
+  findOne(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.clientsService.findOne(workspaceId, id);
+  }
+
+  @Post()
+  @ApiOperation({ summary: 'Crear un nuevo cliente' })
+  @ApiResponse({ status: 201, description: 'Cliente creado' })
+  create(
+    @WorkspaceId() workspaceId: string,
+    @CurrentUser() user: TokenPayload,
+    @Body() dto: CreateClientDto,
+  ) {
+    return this.clientsService.create(workspaceId, user.userId, dto);
+  }
+
+  @Patch(':id')
+  @ApiOperation({ summary: 'Actualizar un cliente' })
+  @ApiResponse({ status: 200, description: 'Cliente actualizado' })
+  @ApiResponse({ status: 404, description: 'Cliente no encontrado' })
+  update(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+    @Body() dto: UpdateClientDto,
+  ) {
+    return this.clientsService.update(workspaceId, id, dto);
+  }
+
+  @Delete(':id')
+  @HttpCode(HttpStatus.NO_CONTENT)
+  @ApiOperation({ summary: 'Eliminar un cliente (soft delete)' })
+  @ApiResponse({ status: 204, description: 'Cliente eliminado' })
+  @ApiResponse({ status: 404, description: 'Cliente no encontrado' })
+  remove(
+    @WorkspaceId() workspaceId: string,
+    @Param('id') id: string,
+  ) {
+    return this.clientsService.remove(workspaceId, id);
+  }
+}

package/templates/backend/src/modules/clients/clients.module.ts

@@ -0,0 +1,16 @@
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { ClientsController } from './clients.controller';
+import { ClientsRepository } from './clients.repository';
+import { ClientsService } from './clients.service';
+import { Client, ClientSchema } from './schemas/client.schema';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([{ name: Client.name, schema: ClientSchema }]),
+  ],
+  controllers: [ClientsController],
+  providers: [ClientsService, ClientsRepository],
+  exports: [ClientsService],
+})
+export class ClientsModule {}

package/templates/backend/src/modules/clients/clients.repository.ts

@@ -0,0 +1,14 @@
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { BaseRepository } from '../../common/base/base.repository';
+import { Client, ClientDocument } from './schemas/client.schema';
+
+@Injectable()
+export class ClientsRepository extends BaseRepository<ClientDocument> {
+  constructor(
+    @InjectModel(Client.name) private readonly clientModel: Model<ClientDocument>,
+  ) {
+    super(clientModel);
+  }
+}

package/templates/backend/src/modules/clients/clients.service.ts

@@ -0,0 +1,52 @@
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { ClientsRepository } from './clients.repository';
+import { CreateClientDto } from './dto/create-client.dto';
+import { QueryClientDto } from './dto/query-client.dto';
+import { UpdateClientDto } from './dto/update-client.dto';
+
+@Injectable()
+export class ClientsService {
+  constructor(private readonly clientsRepository: ClientsRepository) {}
+
+  findAll(workspaceId: string, query: QueryClientDto) {
+    const { page, limit, search, status } = query;
+    const filter: Record<string, unknown> = {};
+
+    if (status) filter.status = status;
+    if (search) {
+      filter.$or = [
+        { name: { $regex: search, $options: 'i' } },
+        { email: { $regex: search, $options: 'i' } },
+      ];
+    }
+
+    return this.clientsRepository.paginate(workspaceId, { page, limit, filter, sort: { createdAt: -1 } });
+  }
+
+  async findOne(workspaceId: string, id: string) {
+    const client = await this.clientsRepository.findById(workspaceId, id);
+    if (!client) throw new NotFoundException('Cliente no encontrado');
+    return client;
+  }
+
+  create(workspaceId: string, userId: string, dto: CreateClientDto) {
+    return this.clientsRepository.create({
+      ...dto,
+      workspaceId: workspaceId as unknown as import('mongoose').Types.ObjectId,
+      createdBy: userId as unknown as import('mongoose').Types.ObjectId,
+      deletedAt: null,
+    } as never);
+  }
+
+  async update(workspaceId: string, id: string, dto: UpdateClientDto) {
+    await this.findOne(workspaceId, id);
+    const client = await this.clientsRepository.update(workspaceId, id, dto);
+    if (!client) throw new NotFoundException('Cliente no encontrado');
+    return client;
+  }
+
+  async remove(workspaceId: string, id: string) {
+    await this.findOne(workspaceId, id);
+    await this.clientsRepository.softDelete(workspaceId, id);
+  }
+}

package/templates/backend/src/modules/clients/dto/create-client.dto.ts

@@ -0,0 +1,40 @@
+import { ApiProperty, ApiPropertyOptional } from '@nestjs/swagger';
+import {
+  IsEmail,
+  IsEnum,
+  IsOptional,
+  IsString,
+  MaxLength,
+} from 'class-validator';
+
+export class CreateClientDto {
+  @ApiProperty({ example: 'Empresa SA', maxLength: 200 })
+  @IsString({ message: 'El nombre debe ser un texto' })
+  @MaxLength(200, { message: 'El nombre no puede superar los 200 caracteres' })
+  name!: string;
+
+  @ApiPropertyOptional({ example: 'empresa@ejemplo.com' })
+  @IsOptional()
+  @IsEmail({}, { message: 'El email no tiene un formato válido' })
+  email?: string;
+
+  @ApiPropertyOptional({ example: '+54 11 1234-5678' })
+  @IsOptional()
+  @IsString({ message: 'El teléfono debe ser un texto' })
+  phone?: string;
+
+  @ApiPropertyOptional({ example: 'Av. Corrientes 1234, CABA' })
+  @IsOptional()
+  @IsString({ message: 'La dirección debe ser un texto' })
+  address?: string;
+
+  @ApiPropertyOptional({ example: 'Cliente VIP', })
+  @IsOptional()
+  @IsString({ message: 'Las notas deben ser un texto' })
+  notes?: string;
+
+  @ApiPropertyOptional({ enum: ['active', 'archived'], default: 'active' })
+  @IsOptional()
+  @IsEnum(['active', 'archived'], { message: 'El estado debe ser "active" o "archived"' })
+  status?: 'active' | 'archived';
+}

package/templates/backend/src/modules/clients/dto/query-client.dto.ts

@@ -0,0 +1,30 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsEnum, IsInt, IsOptional, IsString, Max, Min } from 'class-validator';
+
+export class QueryClientDto {
+  @ApiPropertyOptional({ description: 'Búsqueda por nombre o email' })
+  @IsOptional()
+  @IsString({ message: 'La búsqueda debe ser un texto' })
+  search?: string;
+
+  @ApiPropertyOptional({ enum: ['active', 'archived'] })
+  @IsOptional()
+  @IsEnum(['active', 'archived'], { message: 'El estado debe ser "active" o "archived"' })
+  status?: 'active' | 'archived';
+
+  @ApiPropertyOptional({ default: 1, minimum: 1 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt({ message: 'La página debe ser un número entero' })
+  @Min(1, { message: 'La página mínima es 1' })
+  page?: number = 1;
+
+  @ApiPropertyOptional({ default: 20, minimum: 1, maximum: 100 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt({ message: 'El límite debe ser un número entero' })
+  @Min(1, { message: 'El límite mínimo es 1' })
+  @Max(100, { message: 'El límite máximo es 100' })
+  limit?: number = 20;
+}

package/templates/backend/src/modules/clients/dto/update-client.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/swagger';
+import { CreateClientDto } from './create-client.dto';
+
+export class UpdateClientDto extends PartialType(CreateClientDto) {}

package/templates/backend/src/modules/clients/schemas/client.schema.ts

@@ -0,0 +1,32 @@
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+import { BaseSchema } from '../../../common/base/base.schema';
+
+export type ClientDocument = HydratedDocument<Client>;
+
+@Schema({ collection: 'clients', timestamps: true })
+export class Client extends BaseSchema {
+  @Prop({ required: true, trim: true, maxlength: 200 })
+  name!: string;
+
+  @Prop({ trim: true, lowercase: true })
+  email!: string;
+
+  @Prop({ trim: true })
+  phone!: string;
+
+  @Prop({ trim: true })
+  address!: string;
+
+  @Prop({ type: String, enum: ['active', 'archived'], default: 'active' })
+  status!: 'active' | 'archived';
+
+  @Prop({ trim: true })
+  notes!: string;
+}
+
+export const ClientSchema = SchemaFactory.createForClass(Client);
+
+ClientSchema.index({ workspaceId: 1 });
+ClientSchema.index({ workspaceId: 1, status: 1 });
+ClientSchema.index({ workspaceId: 1, createdAt: -1 });

package/templates/backend/src/modules/invoices/dto/create-invoice.dto.ts

@@ -0,0 +1,79 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import {
+  IsArray,
+  IsDateString,
+  IsEnum,
+  IsNumber,
+  IsOptional,
+  IsString,
+  Min,
+  ValidateNested,
+} from 'class-validator';
+import { InvoiceItemDto } from './invoice-item.dto';
+
+export class CreateInvoiceDto {
+  @ApiPropertyOptional({ enum: ['income', 'expense'], default: 'income' })
+  @IsOptional()
+  @IsEnum(['income', 'expense'], { message: 'El tipo debe ser "income" o "expense"' })
+  type?: 'income' | 'expense';
+
+  @ApiPropertyOptional({ example: 'FAC-001' })
+  @IsOptional()
+  @IsString({ message: 'El número debe ser un texto' })
+  number?: string;
+
+  @ApiPropertyOptional({ description: 'ID del cliente' })
+  @IsOptional()
+  @IsString({ message: 'El clientId debe ser un texto' })
+  clientId?: string;
+
+  @ApiPropertyOptional({
+    enum: ['draft', 'pending', 'paid', 'overdue', 'cancelled'],
+    default: 'draft',
+  })
+  @IsOptional()
+  @IsEnum(['draft', 'pending', 'paid', 'overdue', 'cancelled'], {
+    message: 'El estado no es válido',
+  })
+  status?: 'draft' | 'pending' | 'paid' | 'overdue' | 'cancelled';
+
+  @ApiPropertyOptional({ example: '2026-01-15' })
+  @IsOptional()
+  @IsDateString({}, { message: 'La fecha de emisión debe ser una fecha válida' })
+  issueDate?: string;
+
+  @ApiPropertyOptional({ example: '2026-02-15' })
+  @IsOptional()
+  @IsDateString({}, { message: 'La fecha de vencimiento debe ser una fecha válida' })
+  dueDate?: string;
+
+  @ApiPropertyOptional({ type: [InvoiceItemDto] })
+  @IsOptional()
+  @IsArray({ message: 'Los ítems deben ser un array' })
+  @ValidateNested({ each: true })
+  @Type(() => InvoiceItemDto)
+  items?: InvoiceItemDto[];
+
+  @ApiPropertyOptional({ example: 21, minimum: 0 })
+  @IsOptional()
+  @IsNumber({}, { message: 'La tasa de impuesto debe ser un número' })
+  @Min(0, { message: 'La tasa de impuesto no puede ser negativa' })
+  taxRate?: number;
+
+  @ApiPropertyOptional({ example: 'USD' })
+  @IsOptional()
+  @IsString({ message: 'La moneda debe ser un texto' })
+  currency?: string;
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'Las notas deben ser un texto' })
+  notes?: string;
+
+  @ApiPropertyOptional({ example: 1000, minimum: 0 })
+  @IsOptional()
+  @IsNumber({}, { message: 'El total debe ser un número' })
+  @Min(0, { message: 'El total no puede ser negativo' })
+  total?: number;
+}

package/templates/backend/src/modules/invoices/dto/invoice-item.dto.ts

@@ -0,0 +1,23 @@
+import { ApiProperty } from '@nestjs/swagger';
+import { IsNumber, IsString, Min } from 'class-validator';
+
+export class InvoiceItemDto {
+  @ApiProperty({ example: 'Consultoría mensual' })
+  @IsString({ message: 'La descripción debe ser un texto' })
+  description!: string;
+
+  @ApiProperty({ example: 1, minimum: 0 })
+  @IsNumber({}, { message: 'La cantidad debe ser un número' })
+  @Min(0, { message: 'La cantidad no puede ser negativa' })
+  quantity!: number;
+
+  @ApiProperty({ example: 1000, minimum: 0 })
+  @IsNumber({}, { message: 'El precio unitario debe ser un número' })
+  @Min(0, { message: 'El precio unitario no puede ser negativo' })
+  unitPrice!: number;
+
+  @ApiProperty({ example: 1000, minimum: 0 })
+  @IsNumber({}, { message: 'El monto debe ser un número' })
+  @Min(0, { message: 'El monto no puede ser negativo' })
+  amount!: number;
+}

package/templates/backend/src/modules/invoices/dto/query-invoice.dto.ts

@@ -0,0 +1,40 @@
+import { ApiPropertyOptional } from '@nestjs/swagger';
+import { Type } from 'class-transformer';
+import { IsEnum, IsInt, IsOptional, IsString, Max, Min } from 'class-validator';
+
+export class QueryInvoiceDto {
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'La búsqueda debe ser un texto' })
+  search?: string;
+
+  @ApiPropertyOptional({ enum: ['draft', 'pending', 'paid', 'overdue', 'cancelled'] })
+  @IsOptional()
+  @IsEnum(['draft', 'pending', 'paid', 'overdue', 'cancelled'], { message: 'El estado no es válido' })
+  status?: 'draft' | 'pending' | 'paid' | 'overdue' | 'cancelled';
+
+  @ApiPropertyOptional({ enum: ['income', 'expense'] })
+  @IsOptional()
+  @IsEnum(['income', 'expense'], { message: 'El tipo debe ser "income" o "expense"' })
+  type?: 'income' | 'expense';
+
+  @ApiPropertyOptional()
+  @IsOptional()
+  @IsString({ message: 'El clientId debe ser un texto' })
+  clientId?: string;
+
+  @ApiPropertyOptional({ default: 1, minimum: 1 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt({ message: 'La página debe ser un número entero' })
+  @Min(1, { message: 'La página mínima es 1' })
+  page?: number = 1;
+
+  @ApiPropertyOptional({ default: 20, minimum: 1, maximum: 100 })
+  @IsOptional()
+  @Type(() => Number)
+  @IsInt({ message: 'El límite debe ser un número entero' })
+  @Min(1, { message: 'El límite mínimo es 1' })
+  @Max(100, { message: 'El límite máximo es 100' })
+  limit?: number = 20;
+}

package/templates/backend/src/modules/invoices/dto/update-invoice.dto.ts

@@ -0,0 +1,4 @@
+import { PartialType } from '@nestjs/swagger';
+import { CreateInvoiceDto } from './create-invoice.dto';
+
+export class UpdateInvoiceDto extends PartialType(CreateInvoiceDto) {}