nest-authme 1.0.0

package/dist/generator/templates/users/users.service.ts.hbs

@@ -0,0 +1,192 @@
+import { Injectable, ConflictException, NotFoundException } from '@nestjs/common';
+{{#if (eq orm "typeorm")}}
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { User } from './entities/user.entity';
+{{else if (eq orm "prisma")}}
+import { PrismaService } from '../prisma/prisma.service';
+{{/if}}
+import { CreateUserDto } from '../auth/dto/create-user.dto';
+
+@Injectable()
+export class UsersService {
+{{#if (eq orm "typeorm")}}
+  constructor(
+    @InjectRepository(User)
+    private usersRepository: Repository<User>,
+  ) {}
+
+  async create(createUserDto: CreateUserDto): Promise<User> {
+    const existingUser = await this.usersRepository.findOne({
+      where: { email: createUserDto.email },
+    });
+    if (existingUser) {
+      throw new ConflictException('User with this email already exists');
+    }
+    const user = this.usersRepository.create(createUserDto);
+    return await this.usersRepository.save(user);
+  }
+
+  async findByEmail(email: string): Promise<User | null> {
+    return await this.usersRepository.findOne({ where: { email } });
+  }
+
+  async findById(id: string): Promise<User | null> {
+    return await this.usersRepository.findOne({ where: { id } });
+  }
+
+  async findAll(): Promise<User[]> {
+    return await this.usersRepository.find({
+      select: ['id', 'email'{{#if features.useUsername}}, 'username'{{/if}}{{#if rbac.enabled}}, 'roles'{{/if}}, 'createdAt'],
+    });
+  }
+
+  async updatePassword(id: string, hashedPassword: string): Promise<void> {
+    await this.usersRepository.update(id, { password: hashedPassword });
+  }
+
+{{#if features.emailVerification}}
+  async setVerificationToken(id: string, token: string): Promise<void> {
+    await this.usersRepository.update(id, { emailVerificationToken: token });
+  }
+
+  async findByVerificationToken(token: string): Promise<User | null> {
+    return await this.usersRepository.findOne({ where: { emailVerificationToken: token } });
+  }
+
+  async markEmailVerified(id: string): Promise<void> {
+    await this.usersRepository.update(id, { isEmailVerified: true, emailVerificationToken: null as any });
+  }
+{{/if}}
+
+{{#if features.resetPassword}}
+  async setResetToken(id: string, token: string, expires: Date): Promise<void> {
+    await this.usersRepository.update(id, { passwordResetToken: token, passwordResetExpires: expires });
+  }
+
+  async findByResetToken(token: string): Promise<User | null> {
+    return await this.usersRepository.findOne({ where: { passwordResetToken: token } });
+  }
+
+  async clearResetToken(id: string): Promise<void> {
+    await this.usersRepository.update(id, { passwordResetToken: null as any, passwordResetExpires: null as any });
+  }
+{{/if}}
+{{else if (eq orm "prisma")}}
+  constructor(private prisma: PrismaService) {}
+
+  async create(createUserDto: CreateUserDto): Promise<any> {
+    const existingUser = await this.prisma.user.findUnique({
+      where: { email: createUserDto.email },
+    });
+    if (existingUser) {
+      throw new ConflictException('User with this email already exists');
+    }
+    return await this.prisma.user.create({ data: createUserDto });
+  }
+
+  async findByEmail(email: string): Promise<any> {
+    return await this.prisma.user.findUnique({ where: { email } });
+  }
+
+  async findById(id: string): Promise<any> {
+    return await this.prisma.user.findUnique({ where: { id } });
+  }
+
+  async findAll(): Promise<any[]> {
+    return await this.prisma.user.findMany({
+      select: {
+        id: true,
+        email: true,
+{{#if features.useUsername}}
+        username: true,
+{{/if}}
+{{#if rbac.enabled}}
+        roles: true,
+{{/if}}
+        createdAt: true,
+      },
+    });
+  }
+
+  async updatePassword(id: string, hashedPassword: string): Promise<void> {
+    await this.prisma.user.update({ where: { id }, data: { password: hashedPassword } });
+  }
+
+{{#if features.emailVerification}}
+  async setVerificationToken(id: string, token: string): Promise<void> {
+    await this.prisma.user.update({ where: { id }, data: { emailVerificationToken: token } });
+  }
+
+  async findByVerificationToken(token: string): Promise<any> {
+    return await this.prisma.user.findFirst({ where: { emailVerificationToken: token } });
+  }
+
+  async markEmailVerified(id: string): Promise<void> {
+    await this.prisma.user.update({ where: { id }, data: { isEmailVerified: true, emailVerificationToken: null } });
+  }
+{{/if}}
+
+{{#if features.resetPassword}}
+  async setResetToken(id: string, token: string, expires: Date): Promise<void> {
+    await this.prisma.user.update({ where: { id }, data: { passwordResetToken: token, passwordResetExpires: expires } });
+  }
+
+  async findByResetToken(token: string): Promise<any> {
+    return await this.prisma.user.findFirst({ where: { passwordResetToken: token } });
+  }
+
+  async clearResetToken(id: string): Promise<void> {
+    await this.prisma.user.update({ where: { id }, data: { passwordResetToken: null, passwordResetExpires: null } });
+  }
+{{/if}}
+{{else}}
+  async create(createUserDto: CreateUserDto): Promise<any> {
+    throw new Error('Not implemented - implement with your ORM');
+  }
+
+  async findByEmail(email: string): Promise<any> {
+    throw new Error('Not implemented');
+  }
+
+  async findById(id: string): Promise<any> {
+    throw new Error('Not implemented');
+  }
+
+  async findAll(): Promise<any[]> {
+    throw new Error('Not implemented');
+  }
+
+  async updatePassword(id: string, hashedPassword: string): Promise<void> {
+    throw new Error('Not implemented');
+  }
+
+{{#if features.emailVerification}}
+  async setVerificationToken(id: string, token: string): Promise<void> {
+    throw new Error('Not implemented');
+  }
+
+  async findByVerificationToken(token: string): Promise<any> {
+    throw new Error('Not implemented');
+  }
+
+  async markEmailVerified(id: string): Promise<void> {
+    throw new Error('Not implemented');
+  }
+{{/if}}
+
+{{#if features.resetPassword}}
+  async setResetToken(id: string, token: string, expires: Date): Promise<void> {
+    throw new Error('Not implemented');
+  }
+
+  async findByResetToken(token: string): Promise<any> {
+    throw new Error('Not implemented');
+  }
+
+  async clearResetToken(id: string): Promise<void> {
+    throw new Error('Not implemented');
+  }
+{{/if}}
+{{/if}}
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Main CLI orchestrator
+ */
+interface RunOptions {
+    yes?: boolean;
+}
+declare function run(cwd?: string, options?: RunOptions): Promise<void>;
+
+export { type RunOptions, run };