@ackplus/nest-auth 0.1.51 → 1.1.1

package/test/test.setup.ts

@@ -0,0 +1,66 @@
+import { Test } from '@nestjs/testing';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { ValidationPipe } from '@nestjs/common';
+import { AuthModuleOptions, NestAuthEntities } from '../src/lib/core';
+import { NestAuthModule } from '../src/lib/nest-auth.module';
+import { EventEmitterModule } from '@nestjs/event-emitter';
+import { TypeOrmModuleOptions } from '@nestjs/typeorm';;
+import { RedisModuleOptions } from '@nestjs-modules/ioredis';
+
+export const testDatabaseConfig: TypeOrmModuleOptions = {
+    type: 'sqlite',
+    database: ':memory:',
+    entities: NestAuthEntities,
+    logging: ['error', 'warn'],
+    synchronize: true, // Disable auto-synchronization
+    dropSchema: true, // Drop schema before tests
+};
+
+export const testRedisConfig: RedisModuleOptions = {
+    type: 'single',
+    options: {
+        host: 'localhost',
+        port: 6379,
+        retryStrategy: (times) => {
+            return Math.min(times * 50, 2000);
+        },
+    },
+};
+
+
+export async function createTestModule(options: Partial<AuthModuleOptions> = {}) {
+
+    const moduleRef = await Test.createTestingModule({
+        imports: [
+            TypeOrmModule.forRoot(testDatabaseConfig),
+            TypeOrmModule.forFeature(NestAuthEntities),
+            NestAuthModule.forRoot({
+                jwt: {
+                    secret: 'test-secret',
+                },
+                phoneAuth: {
+                    enabled: true,
+                },
+                emailAuth: {
+                    enabled: true,
+                },
+                ...options
+            }),
+            EventEmitterModule.forRoot(),
+        ],
+    }).compile();
+
+    return moduleRef;
+}
+
+export async function createTestApp(options: Partial<AuthModuleOptions> = {}) {
+
+    const moduleRef = await createTestModule(options);
+    const app = moduleRef.createNestApplication();
+
+    // Enable validation
+    app.useGlobalPipes(new ValidationPipe());
+
+    await app.init();
+    return app;
+}

package/test/user.service.spec.ts

@@ -0,0 +1,374 @@
+import { DataSource, Repository } from 'typeorm';
+import { UserService } from '../src/lib/user/services/user.service';
+import { NestAuthUser } from '../src/lib/user/entities/user.entity';
+import { NestAuthTenant } from '../src/lib/tenant/entities/tenant.entity';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { createTestModule } from './test.setup';
+import { ConflictException, NotFoundException } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+import { NestAuthEvents } from '../src/lib/auth.constants';
+
+describe('UserService', () => {
+    let service: UserService;
+    let userRepository: Repository<NestAuthUser>;
+    let tenantRepository: Repository<NestAuthTenant>;
+    let dataSource: DataSource;
+    let eventEmitter: EventEmitter2;
+    let tenant: NestAuthTenant;
+
+    beforeEach(async () => {
+        const moduleRef = await createTestModule();
+
+        service = moduleRef.get<UserService>(UserService);
+        dataSource = moduleRef.get<DataSource>(DataSource);
+        userRepository = moduleRef.get<Repository<NestAuthUser>>(getRepositoryToken(NestAuthUser));
+        tenantRepository = moduleRef.get<Repository<NestAuthTenant>>(getRepositoryToken(NestAuthTenant));
+        eventEmitter = moduleRef.get<EventEmitter2>(EventEmitter2);
+
+        // Create a test tenant
+        tenant = await tenantRepository.save({
+            name: 'Test Tenant',
+            domain: 'test.example.com'
+        });
+    });
+
+    afterEach(async () => {
+        // Clean up database after each test
+        await dataSource.synchronize(true);
+    });
+
+    afterAll(async () => {
+        // Close the connection after all tests
+        await dataSource.destroy();
+    });
+
+    describe('createUser', () => {
+        it('should create a new user successfully', async () => {
+            const createData = {
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            };
+
+            const result = await service.createUser(createData);
+
+            expect(result).toBeDefined();
+            expect(result.email).toBe(createData.email);
+            expect(result.phone).toBe(createData.phone);
+            expect(result.tenantId).toBe(tenant.id);
+            expect(result.isActive).toBe(true);
+            expect(result.isVerified).toBe(false);
+            expect(result.metadata).toEqual({});
+        });
+
+        it('should throw ConflictException if user with same email exists in same tenant', async () => {
+            const createData = {
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            };
+
+            await service.createUser(createData);
+
+            await expect(service.createUser(createData)).rejects.toThrow(ConflictException);
+        });
+
+        it('should allow same email across different tenants', async () => {
+            const tenant2 = await tenantRepository.save({
+                name: 'Test Tenant 2',
+                domain: 'test2.example.com'
+            });
+
+            const user1 = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            const user2 = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant2.id
+            });
+
+            expect(user1.id).not.toBe(user2.id);
+            expect(user1.tenantId).not.toBe(user2.tenantId);
+        });
+    });
+
+    describe('getUserById', () => {
+        it('should return user by id', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            const result = await service.getUserById(user.id);
+
+            expect(result).toBeDefined();
+            expect(result?.id).toBe(user.id);
+            expect(result?.email).toBe('test@example.com');
+        });
+
+        it('should return null if user not found', async () => {
+            const result = await service.getUserById('non-existent-id');
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('getUserByEmail', () => {
+        it('should return user by email and tenant', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            const result = await service.getUserByEmail('test@example.com', tenant.id);
+
+            expect(result).toBeDefined();
+            expect(result?.email).toBe('test@example.com');
+            expect(result?.tenantId).toBe(tenant.id);
+        });
+
+        it('should return null if user not found', async () => {
+            const result = await service.getUserByEmail('nonexistent@example.com', tenant.id);
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('updateUser', () => {
+        it('should update user successfully', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            const updateData = {
+                email: 'test2@example.com',
+                phone: '+1234567891',
+            };
+
+            const result = await service.updateUser(user.id, updateData);
+
+            expect(result.email).toBe('test2@example.com');
+            expect(result.phone).toBe('+1234567891');
+        });
+
+        it('should throw NotFoundException if user not found', async () => {
+            await expect(
+                service.updateUser('non-existent-id', { email: 'test@example.com' })
+            ).rejects.toThrow(NotFoundException);
+        });
+    });
+
+    describe('deleteUser', () => {
+        it('should delete user successfully', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            await service.deleteUser(user.id);
+
+            const deletedUser = await service.getUserById(user.id);
+            expect(deletedUser).toBeNull();
+        });
+
+        it('should throw NotFoundException if user not found', async () => {
+            await expect(
+                service.deleteUser('non-existent-id')
+            ).rejects.toThrow(NotFoundException);
+        });
+    });
+
+    describe('verifyUser', () => {
+        it('should verify user email successfully', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            const result = await service.verifyUser(user.id, 'email');
+
+            expect(result.emailVerifiedAt).toBeDefined();
+            expect(result.isVerified).toBe(true);
+        });
+
+        it('should verify user phone successfully', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            const result = await service.verifyUser(user.id, 'phone');
+
+            expect(result.phoneVerifiedAt).toBeDefined();
+            expect(result.isVerified).toBe(true);
+        });
+
+        it('should throw NotFoundException if user not found', async () => {
+            await expect(
+                service.verifyUser('non-existent-id', 'email')
+            ).rejects.toThrow(NotFoundException);
+        });
+    });
+
+    describe('unverifyUser', () => {
+        it('should unverify user email successfully', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            // First verify the user
+            await service.verifyUser(user.id, 'email');
+
+            // Then unverify
+            const result = await service.unverifyUser(user.id, 'email');
+
+            expect(result.emailVerifiedAt).toBeNull();
+            expect(result.isVerified).toBe(false);
+        });
+
+        it('should unverify user phone successfully', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            // First verify the user
+            await service.verifyUser(user.id, 'phone');
+
+            // Then unverify
+            const result = await service.unverifyUser(user.id, 'phone');
+
+            expect(result.phoneVerifiedAt).toBeNull();
+            expect(result.isVerified).toBe(false);
+        });
+
+        it('should throw NotFoundException if user not found', async () => {
+            await expect(
+                service.unverifyUser('non-existent-id', 'email')
+            ).rejects.toThrow(NotFoundException);
+        });
+
+        it('should handle unverifying already unverified user', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            const result = await service.unverifyUser(user.id, 'email');
+
+            expect(result.emailVerifiedAt).toBeNull();
+            expect(result.isVerified).toBe(false);
+        });
+
+        it('should maintain other verification status when unverifying one method', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            // Verify both email and phone
+            await service.verifyUser(user.id, 'email');
+            await service.verifyUser(user.id, 'phone');
+
+            // Unverify only email
+            const result = await service.unverifyUser(user.id, 'email');
+
+            expect(result.emailVerifiedAt).toBeNull();
+            expect(result.phoneVerifiedAt).toBeDefined();
+            expect(result.isVerified).toBe(true); // Still verified because phone is verified
+        });
+    });
+
+    describe('updateUserStatus', () => {
+        it('should update user status successfully', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            const result = await service.updateUserStatus(user.id, false);
+
+            expect(result.isActive).toBe(false);
+        });
+
+        it('should throw NotFoundException if user not found', async () => {
+            await expect(
+                service.updateUserStatus('non-existent-id', false)
+            ).rejects.toThrow(NotFoundException);
+        });
+    });
+
+    describe('updateUserMetadata', () => {
+        it('should update user metadata successfully', async () => {
+            const user = await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            const metadata = { key: 'value', nested: { data: 'test' } };
+            const result = await service.updateUserMetadata(user.id, metadata);
+
+            expect(result.metadata).toEqual(metadata);
+        });
+
+        it('should throw NotFoundException if user not found', async () => {
+            await expect(
+                service.updateUserMetadata('non-existent-id', { key: 'value' })
+            ).rejects.toThrow(NotFoundException);
+        });
+    });
+
+    describe('Multiple Users', () => {
+        it('should allow multiple users in same tenant', async () => {
+            const user1 = await service.createUser({
+                email: 'user1@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            const user2 = await service.createUser({
+                email: 'user2@example.com',
+                phone: '+1234567891',
+                tenantId: tenant.id
+            });
+
+            expect(user1.id).not.toBe(user2.id);
+            expect(user1.email).not.toBe(user2.email);
+            expect(user1.tenantId).toBe(user2.tenantId);
+        });
+
+        it('should prevent duplicate email in same tenant', async () => {
+            await service.createUser({
+                email: 'test@example.com',
+                phone: '+1234567890',
+                tenantId: tenant.id
+            });
+
+            await expect(
+                service.createUser({
+                    email: 'test@example.com',
+                    phone: '+1234567891',
+                    tenantId: tenant.id
+                })
+            ).rejects.toThrow(ConflictException);
+        });
+    });
+});

package/tsconfig.json

@@ -0,0 +1,17 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "forceConsistentCasingInFileNames": true,
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/packages/nest-auth",
+    "declaration": true,
+    "emitDeclarationOnly": false,
+    "types": ["node"],
+    "target": "es2021",
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "forceConsistentCasingInFileNames": true,
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,15 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "moduleResolution": "node10",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "jest.config.ts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.d.ts"
+  ]
+}

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"version":"5.8.3"}
+{"fileNames":[],"fileInfos":[],"root":[],"options":{"allowSyntheticDefaultImports":true,"composite":true,"declaration":true,"declarationMap":true,"emitDeclarationOnly":true,"esModuleInterop":true,"importHelpers":true,"module":1,"noEmitOnError":false,"noFallthroughCasesInSwitch":false,"noImplicitAny":false,"noImplicitOverride":false,"noImplicitReturns":false,"noPropertyAccessFromIndexSignature":false,"noUnusedLocals":false,"skipLibCheck":true,"strict":false,"strictBindCallApply":false,"strictFunctionTypes":false,"strictNullChecks":false,"target":9},"version":"5.9.3"}

package/ui/.env

@@ -0,0 +1 @@
+VITE_API_BASE_URL=http://localhost:3333

package/ui/.env.example

@@ -0,0 +1 @@
+VITE_API_BASE_URL=http://localhost:3333

package/ui/.eslintignore

@@ -0,0 +1,7 @@
+# Ignore build artifacts and configuration files
+node_modules
+dist
+build
+.vite
+*.config.js
+*.config.ts