ar-saas 0.3.1 → 0.3.2

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

@@ -1,51 +1,51 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-import { User, UserDocument } from './schemas/user.schema';
-
-@Injectable()
-export class UsersRepository {
-  constructor(
-    @InjectModel(User.name) private readonly userModel: Model<UserDocument>,
-  ) {}
-
-  async findByEmail(email: string): Promise<UserDocument | null> {
-    return this.userModel
-      .findOne({ email })
-      .select('+password +refreshToken')
-      .exec();
-  }
-
-  async findById(id: string): Promise<UserDocument | null> {
-    return this.userModel.findById(id).exec();
-  }
-
-  async findByIdWithSecrets(id: string): Promise<UserDocument | null> {
-    return this.userModel.findById(id).select('+refreshToken').exec();
-  }
-
-  async findByVerificationToken(token: string): Promise<UserDocument | null> {
-    return this.userModel
-      .findOne({ emailVerificationToken: token })
-      .select('+emailVerificationToken')
-      .exec();
-  }
-
-  async findByPasswordResetToken(token: string): Promise<UserDocument | null> {
-    return this.userModel
-      .findOne({ passwordResetToken: token })
-      .select('+passwordResetToken')
-      .exec();
-  }
-
-  async create(data: Partial<User>): Promise<UserDocument> {
-    const user = new this.userModel(data);
-    return user.save();
-  }
-
-  async update(id: string, data: Partial<User>): Promise<UserDocument | null> {
-    return this.userModel
-      .findByIdAndUpdate(id, { $set: data }, { returnDocument: 'after' })
-      .exec();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { User, UserDocument } from './schemas/user.schema';
+
+@Injectable()
+export class UsersRepository {
+  constructor(
+    @InjectModel(User.name) private readonly userModel: Model<UserDocument>,
+  ) {}
+
+  async findByEmail(email: string): Promise<UserDocument | null> {
+    return this.userModel
+      .findOne({ email })
+      .select('+password +refreshToken')
+      .exec();
+  }
+
+  async findById(id: string): Promise<UserDocument | null> {
+    return this.userModel.findById(id).exec();
+  }
+
+  async findByIdWithSecrets(id: string): Promise<UserDocument | null> {
+    return this.userModel.findById(id).select('+refreshToken').exec();
+  }
+
+  async findByVerificationToken(token: string): Promise<UserDocument | null> {
+    return this.userModel
+      .findOne({ emailVerificationToken: token })
+      .select('+emailVerificationToken')
+      .exec();
+  }
+
+  async findByPasswordResetToken(token: string): Promise<UserDocument | null> {
+    return this.userModel
+      .findOne({ passwordResetToken: token })
+      .select('+passwordResetToken')
+      .exec();
+  }
+
+  async create(data: Partial<User>): Promise<UserDocument> {
+    const user = new this.userModel(data);
+    return user.save();
+  }
+
+  async update(id: string, data: Partial<User>): Promise<UserDocument | null> {
+    return this.userModel
+      .findByIdAndUpdate(id, { $set: data }, { returnDocument: 'after' })
+      .exec();
+  }
+}

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

@@ -1,104 +1,104 @@
-import { ConflictException, Injectable } from '@nestjs/common';
-import * as bcrypt from 'bcryptjs';
-import { User, UserDocument, UserRole } from './schemas/user.schema';
-import { UsersRepository } from './users.repository';
-
-@Injectable()
-export class UsersService {
-  constructor(private readonly usersRepository: UsersRepository) {}
-
-  async create(data: {
-    name: string;
-    email: string;
-    password: string;
-    workspaceId: string;
-    role?: UserRole;
-  }): Promise<UserDocument> {
-    const existing = await this.usersRepository.findByEmail(data.email);
-    if (existing) {
-      throw new ConflictException('Este email ya está registrado.');
-    }
-    const hashedPassword = await bcrypt.hash(data.password, 12);
-    return this.usersRepository.create({ ...data, password: hashedPassword });
-  }
-
-  async findByEmail(email: string): Promise<UserDocument | null> {
-    return this.usersRepository.findByEmail(email);
-  }
-
-  async findById(id: string): Promise<UserDocument | null> {
-    return this.usersRepository.findById(id);
-  }
-
-  async updateRefreshToken(
-    userId: string,
-    refreshToken: string | null,
-  ): Promise<void> {
-    const hashed = refreshToken
-      ? await bcrypt.hash(refreshToken, 10)
-      : null;
-    await this.usersRepository.update(userId, { refreshToken: hashed });
-  }
-
-  async validateRefreshToken(
-    userId: string,
-    token: string,
-  ): Promise<UserDocument | null> {
-    const user = await this.usersRepository.findByIdWithSecrets(userId);
-    if (!user?.refreshToken) return null;
-    const valid = await bcrypt.compare(token, user.refreshToken);
-    return valid ? user : null;
-  }
-
-  async setEmailVerificationToken(
-    userId: string,
-    token: string,
-    expiresAt: Date,
-  ): Promise<void> {
-    await this.usersRepository.update(userId, {
-      emailVerificationToken: token,
-      emailVerificationTokenExpiresAt: expiresAt,
-    });
-  }
-
-  async findByVerificationToken(token: string): Promise<UserDocument | null> {
-    return this.usersRepository.findByVerificationToken(token);
-  }
-
-  async markEmailVerified(userId: string): Promise<void> {
-    await this.usersRepository.update(userId, {
-      emailVerified: true,
-      emailVerificationToken: null,
-      emailVerificationTokenExpiresAt: null,
-    });
-  }
-
-  async setPasswordResetToken(
-    userId: string,
-    token: string,
-    expiresAt: Date,
-  ): Promise<void> {
-    await this.usersRepository.update(userId, {
-      passwordResetToken: token,
-      passwordResetTokenExpiresAt: expiresAt,
-    });
-  }
-
-  async findByPasswordResetToken(token: string): Promise<UserDocument | null> {
-    return this.usersRepository.findByPasswordResetToken(token);
-  }
-
-  async updatePassword(userId: string, password: string): Promise<void> {
-    const hashed = await bcrypt.hash(password, 12);
-    await this.usersRepository.update(userId, {
-      password: hashed,
-      passwordResetToken: null,
-      passwordResetTokenExpiresAt: null,
-      refreshToken: null,
-    });
-  }
-
-  async updateLastLoginAt(userId: string): Promise<void> {
-    await this.usersRepository.update(userId, { lastLoginAt: new Date() });
-  }
-}
+import { ConflictException, Injectable } from '@nestjs/common';
+import * as bcrypt from 'bcryptjs';
+import { User, UserDocument, UserRole } from './schemas/user.schema';
+import { UsersRepository } from './users.repository';
+
+@Injectable()
+export class UsersService {
+  constructor(private readonly usersRepository: UsersRepository) {}
+
+  async create(data: {
+    name: string;
+    email: string;
+    password: string;
+    workspaceId: string;
+    role?: UserRole;
+  }): Promise<UserDocument> {
+    const existing = await this.usersRepository.findByEmail(data.email);
+    if (existing) {
+      throw new ConflictException('Este email ya está registrado.');
+    }
+    const hashedPassword = await bcrypt.hash(data.password, 12);
+    return this.usersRepository.create({ ...data, password: hashedPassword });
+  }
+
+  async findByEmail(email: string): Promise<UserDocument | null> {
+    return this.usersRepository.findByEmail(email);
+  }
+
+  async findById(id: string): Promise<UserDocument | null> {
+    return this.usersRepository.findById(id);
+  }
+
+  async updateRefreshToken(
+    userId: string,
+    refreshToken: string | null,
+  ): Promise<void> {
+    const hashed = refreshToken
+      ? await bcrypt.hash(refreshToken, 10)
+      : null;
+    await this.usersRepository.update(userId, { refreshToken: hashed });
+  }
+
+  async validateRefreshToken(
+    userId: string,
+    token: string,
+  ): Promise<UserDocument | null> {
+    const user = await this.usersRepository.findByIdWithSecrets(userId);
+    if (!user?.refreshToken) return null;
+    const valid = await bcrypt.compare(token, user.refreshToken);
+    return valid ? user : null;
+  }
+
+  async setEmailVerificationToken(
+    userId: string,
+    token: string,
+    expiresAt: Date,
+  ): Promise<void> {
+    await this.usersRepository.update(userId, {
+      emailVerificationToken: token,
+      emailVerificationTokenExpiresAt: expiresAt,
+    });
+  }
+
+  async findByVerificationToken(token: string): Promise<UserDocument | null> {
+    return this.usersRepository.findByVerificationToken(token);
+  }
+
+  async markEmailVerified(userId: string): Promise<void> {
+    await this.usersRepository.update(userId, {
+      emailVerified: true,
+      emailVerificationToken: null,
+      emailVerificationTokenExpiresAt: null,
+    });
+  }
+
+  async setPasswordResetToken(
+    userId: string,
+    token: string,
+    expiresAt: Date,
+  ): Promise<void> {
+    await this.usersRepository.update(userId, {
+      passwordResetToken: token,
+      passwordResetTokenExpiresAt: expiresAt,
+    });
+  }
+
+  async findByPasswordResetToken(token: string): Promise<UserDocument | null> {
+    return this.usersRepository.findByPasswordResetToken(token);
+  }
+
+  async updatePassword(userId: string, password: string): Promise<void> {
+    const hashed = await bcrypt.hash(password, 12);
+    await this.usersRepository.update(userId, {
+      password: hashed,
+      passwordResetToken: null,
+      passwordResetTokenExpiresAt: null,
+      refreshToken: null,
+    });
+  }
+
+  async updateLastLoginAt(userId: string): Promise<void> {
+    await this.usersRepository.update(userId, { lastLoginAt: new Date() });
+  }
+}

package/templates/backend/src/modules/workspaces/schemas/workspace.schema.ts

@@ -1,26 +1,26 @@
-import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
-import { HydratedDocument } from 'mongoose';
-
-export type WorkspaceDocument = HydratedDocument<Workspace>;
-
-@Schema({ collection: 'workspaces', timestamps: true })
-export class Workspace {
-  @Prop({ required: true, trim: true })
-  name!: string;
-
-  @Prop({ required: true, unique: true, lowercase: true, trim: true })
-  slug!: string;
-
-  @Prop({ required: true })
-  ownerId!: string;
-
-  @Prop({ type: String, enum: ['active', 'suspended'], default: 'active' })
-  status!: 'active' | 'suspended';
-
-  createdAt!: Date;
-  updatedAt!: Date;
-}
-
-export const WorkspaceSchema = SchemaFactory.createForClass(Workspace);
-
-WorkspaceSchema.index({ ownerId: 1 });
+import { Prop, Schema, SchemaFactory } from '@nestjs/mongoose';
+import { HydratedDocument } from 'mongoose';
+
+export type WorkspaceDocument = HydratedDocument<Workspace>;
+
+@Schema({ collection: 'workspaces', timestamps: true })
+export class Workspace {
+  @Prop({ required: true, trim: true })
+  name!: string;
+
+  @Prop({ required: true, unique: true, lowercase: true, trim: true })
+  slug!: string;
+
+  @Prop({ required: true })
+  ownerId!: string;
+
+  @Prop({ type: String, enum: ['active', 'suspended'], default: 'active' })
+  status!: 'active' | 'suspended';
+
+  createdAt!: Date;
+  updatedAt!: Date;
+}
+
+export const WorkspaceSchema = SchemaFactory.createForClass(Workspace);
+
+WorkspaceSchema.index({ ownerId: 1 });

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

@@ -1,16 +1,16 @@
-import { Module } from '@nestjs/common';
-import { MongooseModule } from '@nestjs/mongoose';
-import { Workspace, WorkspaceSchema } from './schemas/workspace.schema';
-import { WorkspacesRepository } from './workspaces.repository';
-import { WorkspacesService } from './workspaces.service';
-
-@Module({
-  imports: [
-    MongooseModule.forFeature([
-      { name: Workspace.name, schema: WorkspaceSchema },
-    ]),
-  ],
-  providers: [WorkspacesService, WorkspacesRepository],
-  exports: [WorkspacesService],
-})
-export class WorkspacesModule {}
+import { Module } from '@nestjs/common';
+import { MongooseModule } from '@nestjs/mongoose';
+import { Workspace, WorkspaceSchema } from './schemas/workspace.schema';
+import { WorkspacesRepository } from './workspaces.repository';
+import { WorkspacesService } from './workspaces.service';
+
+@Module({
+  imports: [
+    MongooseModule.forFeature([
+      { name: Workspace.name, schema: WorkspaceSchema },
+    ]),
+  ],
+  providers: [WorkspacesService, WorkspacesRepository],
+  exports: [WorkspacesService],
+})
+export class WorkspacesModule {}

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

@@ -1,34 +1,34 @@
-import { Injectable } from '@nestjs/common';
-import { InjectModel } from '@nestjs/mongoose';
-import { Model } from 'mongoose';
-import { Workspace, WorkspaceDocument } from './schemas/workspace.schema';
-
-@Injectable()
-export class WorkspacesRepository {
-  constructor(
-    @InjectModel(Workspace.name)
-    private readonly workspaceModel: Model<WorkspaceDocument>,
-  ) {}
-
-  async findById(id: string): Promise<WorkspaceDocument | null> {
-    return this.workspaceModel.findById(id).exec();
-  }
-
-  async findBySlug(slug: string): Promise<WorkspaceDocument | null> {
-    return this.workspaceModel.findOne({ slug }).exec();
-  }
-
-  async create(data: Partial<Workspace>): Promise<WorkspaceDocument> {
-    const workspace = new this.workspaceModel(data);
-    return workspace.save();
-  }
-
-  async update(
-    id: string,
-    data: Partial<Workspace>,
-  ): Promise<WorkspaceDocument | null> {
-    return this.workspaceModel
-      .findByIdAndUpdate(id, { $set: data }, { returnDocument: 'after' })
-      .exec();
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { InjectModel } from '@nestjs/mongoose';
+import { Model } from 'mongoose';
+import { Workspace, WorkspaceDocument } from './schemas/workspace.schema';
+
+@Injectable()
+export class WorkspacesRepository {
+  constructor(
+    @InjectModel(Workspace.name)
+    private readonly workspaceModel: Model<WorkspaceDocument>,
+  ) {}
+
+  async findById(id: string): Promise<WorkspaceDocument | null> {
+    return this.workspaceModel.findById(id).exec();
+  }
+
+  async findBySlug(slug: string): Promise<WorkspaceDocument | null> {
+    return this.workspaceModel.findOne({ slug }).exec();
+  }
+
+  async create(data: Partial<Workspace>): Promise<WorkspaceDocument> {
+    const workspace = new this.workspaceModel(data);
+    return workspace.save();
+  }
+
+  async update(
+    id: string,
+    data: Partial<Workspace>,
+  ): Promise<WorkspaceDocument | null> {
+    return this.workspaceModel
+      .findByIdAndUpdate(id, { $set: data }, { returnDocument: 'after' })
+      .exec();
+  }
+}

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

@@ -1,42 +1,42 @@
-import { Injectable } from '@nestjs/common';
-import { Workspace, WorkspaceDocument } from './schemas/workspace.schema';
-import { WorkspacesRepository } from './workspaces.repository';
-
-@Injectable()
-export class WorkspacesService {
-  constructor(
-    private readonly workspacesRepository: WorkspacesRepository,
-  ) {}
-
-  async create(ownerId: string, name: string): Promise<WorkspaceDocument> {
-    const slug = await this.generateUniqueSlug(name);
-    return this.workspacesRepository.create({ name, slug, ownerId });
-  }
-
-  async update(
-    id: string,
-    data: Partial<Workspace>,
-  ): Promise<WorkspaceDocument | null> {
-    return this.workspacesRepository.update(id, data);
-  }
-
-  async findById(id: string): Promise<WorkspaceDocument | null> {
-    return this.workspacesRepository.findById(id);
-  }
-
-  private async generateUniqueSlug(name: string): Promise<string> {
-    const base = name
-      .toLowerCase()
-      .normalize('NFD')
-      .replace(/\p{M}/gu, '')
-      .replace(/[^a-z0-9]+/g, '-')
-      .replace(/^-+|-+$/g, '');
-
-    let slug = base || 'workspace';
-    let counter = 1;
-    while (await this.workspacesRepository.findBySlug(slug)) {
-      slug = `${base}-${counter++}`;
-    }
-    return slug;
-  }
-}
+import { Injectable } from '@nestjs/common';
+import { Workspace, WorkspaceDocument } from './schemas/workspace.schema';
+import { WorkspacesRepository } from './workspaces.repository';
+
+@Injectable()
+export class WorkspacesService {
+  constructor(
+    private readonly workspacesRepository: WorkspacesRepository,
+  ) {}
+
+  async create(ownerId: string, name: string): Promise<WorkspaceDocument> {
+    const slug = await this.generateUniqueSlug(name);
+    return this.workspacesRepository.create({ name, slug, ownerId });
+  }
+
+  async update(
+    id: string,
+    data: Partial<Workspace>,
+  ): Promise<WorkspaceDocument | null> {
+    return this.workspacesRepository.update(id, data);
+  }
+
+  async findById(id: string): Promise<WorkspaceDocument | null> {
+    return this.workspacesRepository.findById(id);
+  }
+
+  private async generateUniqueSlug(name: string): Promise<string> {
+    const base = name
+      .toLowerCase()
+      .normalize('NFD')
+      .replace(/\p{M}/gu, '')
+      .replace(/[^a-z0-9]+/g, '-')
+      .replace(/^-+|-+$/g, '');
+
+    let slug = base || 'workspace';
+    let counter = 1;
+    while (await this.workspacesRepository.findBySlug(slug)) {
+      slug = `${base}-${counter++}`;
+    }
+    return slug;
+  }
+}

package/templates/backend/test/app.e2e-spec.ts

@@ -1,25 +1,25 @@
-import { Test, TestingModule } from '@nestjs/testing';
-import { INestApplication } from '@nestjs/common';
-import request from 'supertest';
-import { App } from 'supertest/types';
-import { AppModule } from './../src/app.module';
-
-describe('AppController (e2e)', () => {
-  let app: INestApplication<App>;
-
-  beforeEach(async () => {
-    const moduleFixture: TestingModule = await Test.createTestingModule({
-      imports: [AppModule],
-    }).compile();
-
-    app = moduleFixture.createNestApplication();
-    await app.init();
-  });
-
-  it('/ (GET)', () => {
-    return request(app.getHttpServer())
-      .get('/')
-      .expect(200)
-      .expect('Hello World!');
-  });
-});
+import { Test, TestingModule } from '@nestjs/testing';
+import { INestApplication } from '@nestjs/common';
+import request from 'supertest';
+import { App } from 'supertest/types';
+import { AppModule } from './../src/app.module';
+
+describe('AppController (e2e)', () => {
+  let app: INestApplication<App>;
+
+  beforeEach(async () => {
+    const moduleFixture: TestingModule = await Test.createTestingModule({
+      imports: [AppModule],
+    }).compile();
+
+    app = moduleFixture.createNestApplication();
+    await app.init();
+  });
+
+  it('/ (GET)', () => {
+    return request(app.getHttpServer())
+      .get('/')
+      .expect(200)
+      .expect('Hello World!');
+  });
+});

package/templates/backend/test/jest-e2e.json

@@ -1,9 +1,9 @@
-{
-  "moduleFileExtensions": ["js", "json", "ts"],
-  "rootDir": ".",
-  "testEnvironment": "node",
-  "testRegex": ".e2e-spec.ts$",
-  "transform": {
-    "^.+\\.(t|j)s$": "ts-jest"
-  }
-}
+{
+  "moduleFileExtensions": ["js", "json", "ts"],
+  "rootDir": ".",
+  "testEnvironment": "node",
+  "testRegex": ".e2e-spec.ts$",
+  "transform": {
+    "^.+\\.(t|j)s$": "ts-jest"
+  }
+}

package/templates/backend/tsconfig.build.json

@@ -1,4 +1,4 @@
-{
-  "extends": "./tsconfig.json",
-  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
-}
+{
+  "extends": "./tsconfig.json",
+  "exclude": ["node_modules", "test", "dist", "**/*spec.ts"]
+}