@ackplus/nest-auth 1.1.0 → 1.1.2

package/test/test.setup.ts

@@ -1,66 +0,0 @@
-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

@@ -1,374 +0,0 @@
-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

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

package/tsconfig.lib.json

@@ -1,15 +0,0 @@
-{
-  "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

@@ -1,15 +0,0 @@
-{
-  "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 +0,0 @@
-{"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

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

package/ui/.env.example

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

package/ui/.eslintignore

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