@ackplus/nest-auth 0.1.50 → 1.1.0

package/src/lib/utils/device.util.ts

@@ -0,0 +1,111 @@
+/**
+ * Device and user-agent utilities
+ */
+export class DeviceUtil {
+    /**
+     * Parse user agent string
+     */
+    static parseUserAgent(userAgent: string): {
+        browser: string;
+        version: string;
+        os: string;
+        device: string;
+        isMobile: boolean;
+        isTablet: boolean;
+        isDesktop: boolean;
+    } {
+        const ua = userAgent.toLowerCase();
+
+        return {
+            browser: this.detectBrowser(ua),
+            version: this.detectBrowserVersion(ua),
+            os: this.detectOS(ua),
+            device: this.detectDevice(ua),
+            isMobile: this.isMobile(ua),
+            isTablet: this.isTablet(ua),
+            isDesktop: this.isDesktop(ua),
+        };
+    }
+
+    /**
+     * Detect browser from user agent
+     */
+    private static detectBrowser(ua: string): string {
+        if (ua.includes('edg/')) return 'Edge';
+        if (ua.includes('chrome/')) return 'Chrome';
+        if (ua.includes('firefox/')) return 'Firefox';
+        if (ua.includes('safari/') && !ua.includes('chrome')) return 'Safari';
+        if (ua.includes('opera') || ua.includes('opr/')) return 'Opera';
+        return 'Unknown';
+    }
+
+    /**
+     * Detect browser version
+     */
+    private static detectBrowserVersion(ua: string): string {
+        const match = ua.match(/(chrome|firefox|safari|edg|opr)\/(\d+)/);
+        return match ? match[2] : 'Unknown';
+    }
+
+    /**
+     * Detect operating system
+     */
+    private static detectOS(ua: string): string {
+        if (ua.includes('windows nt')) return 'Windows';
+        if (ua.includes('mac os x')) return 'macOS';
+        if (ua.includes('linux')) return 'Linux';
+        if (ua.includes('android')) return 'Android';
+        if (ua.includes('iphone') || ua.includes('ipad')) return 'iOS';
+        return 'Unknown';
+    }
+
+    /**
+     * Detect device type
+     */
+    private static detectDevice(ua: string): string {
+        if (ua.includes('iphone')) return 'iPhone';
+        if (ua.includes('ipad')) return 'iPad';
+        if (ua.includes('android')) return 'Android';
+        if (ua.includes('windows phone')) return 'Windows Phone';
+        if (ua.includes('macintosh')) return 'Mac';
+        if (ua.includes('windows')) return 'Windows PC';
+        if (ua.includes('linux')) return 'Linux PC';
+        return 'Unknown';
+    }
+
+    /**
+     * Check if mobile device
+     */
+    private static isMobile(ua: string): boolean {
+        return /mobile|android|iphone|ipod|blackberry|windows phone/i.test(ua);
+    }
+
+    /**
+     * Check if tablet
+     */
+    private static isTablet(ua: string): boolean {
+        return /ipad|android(?!.*mobile)|tablet/i.test(ua);
+    }
+
+    /**
+     * Check if desktop
+     */
+    private static isDesktop(ua: string): boolean {
+        return !this.isMobile(ua) && !this.isTablet(ua);
+    }
+
+    /**
+     * Generate friendly device name
+     */
+    static getDeviceName(userAgent: string): string {
+        const parsed = this.parseUserAgent(userAgent);
+
+        if (parsed.isMobile) {
+            return `${parsed.device} (${parsed.browser})`;
+        }
+        if (parsed.isTablet) {
+            return `${parsed.device} Tablet (${parsed.browser})`;
+        }
+        return `${parsed.os} (${parsed.browser})`;
+    }
+}

package/src/lib/utils/index.ts

@@ -0,0 +1,6 @@
+export * from './otp';
+export * from './device.util';
+export * from './date.util';
+export * from './database.utils';
+export * from './slug.util';
+export * from './security.util';

package/src/lib/utils/otp.ts

@@ -0,0 +1,3 @@
+export function generateOtp(length: number = 6): string {
+    return Math.floor(10 ** (length - 1) + Math.random() * (10 ** length - 10 ** (length - 1) - 1)).toString();
+}

package/src/lib/utils/security.util.ts

@@ -0,0 +1,27 @@
+import { timingSafeEqual, createHash } from 'crypto';
+
+/**
+ * Performs a constant-time comparison of two keys to prevent timing attacks.
+ * Uses hashing to fixed-length digests to prevent length-dependent timing attacks.
+ * This is critical for security-sensitive comparisons like setup keys.
+ *
+ * @param providedKey - The key provided by the user/client
+ * @param expectedKey - The expected key from configuration
+ * @returns true if keys match, false otherwise
+ */
+export function compareKeys(providedKey: string, expectedKey: string): boolean {
+    if (!providedKey || !expectedKey) {
+        return false;
+    }
+
+    try {
+        // Hash both keys to fixed-length digests to prevent length-dependent timing attacks
+        const providedDigest = createHash('sha256').update(providedKey, 'utf8').digest();
+        const expectedDigest = createHash('sha256').update(expectedKey, 'utf8').digest();
+
+        // Compare fixed-length digests using timing-safe comparison
+        return timingSafeEqual(providedDigest, expectedDigest);
+    } catch {
+        return false;
+    }
+}

package/src/lib/utils/slug.util.ts

@@ -0,0 +1,58 @@
+/**
+ * Validates if a string is a valid slug
+ * Valid format: lowercase letters, numbers, hyphens (-) and underscores (_) only
+ * No spaces, no special characters
+ *
+ * @param slug - The string to validate
+ * @returns true if valid, false otherwise
+ *
+ * @example
+ * ```typescript
+ * isValidSlug('my-app')        // true
+ * isValidSlug('acme_corp')     // true
+ * isValidSlug('tenant123')     // true
+ * isValidSlug('My-App')        // false (uppercase)
+ * isValidSlug('my app')        // false (space)
+ * isValidSlug('my@app')        // false (special char)
+ * ```
+ */
+export function isValidSlug(slug: string): boolean {
+    if (!slug || typeof slug !== 'string') {
+        return false;
+    }
+
+    // Only lowercase letters, numbers, hyphens, and underscores
+    const slugRegex = /^[a-z0-9_-]+$/;
+    return slugRegex.test(slug);
+}
+
+/**
+ * Converts a string to a valid slug
+ * - Converts to lowercase
+ * - Replaces spaces with hyphens
+ * - Removes invalid characters
+ *
+ * @param input - The string to convert
+ * @returns A valid slug
+ *
+ * @example
+ * ```typescript
+ * toSlug('My App')           // 'my-app'
+ * toSlug('ACME Corp')        // 'acme-corp'
+ * toSlug('My@App!')          // 'myapp'
+ * toSlug('Hello  World')     // 'hello-world'
+ * ```
+ */
+export function toSlug(input: string): string {
+    if (!input || typeof input !== 'string') {
+        return '';
+    }
+
+    return input
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, '-')           // Replace spaces with hyphens
+        .replace(/[^a-z0-9_-]/g, '')    // Remove invalid characters
+        .replace(/-+/g, '-')            // Replace multiple hyphens with single
+        .replace(/^-|-$/g, '');         // Remove leading/trailing hyphens
+}

package/src/types/ms.d.ts

@@ -0,0 +1 @@
+declare module 'ms';

package/test/access-key.service.spec.ts

@@ -0,0 +1,204 @@
+import { DataSource, Repository } from 'typeorm';
+import { AccessKeyService } from '../src/lib/user/services/access-key.service';
+import { NestAuthUser } from '../src/lib/user/entities/user.entity';
+import { NestAuthAccessKey } from '../src/lib/user/entities/access-key.entity';
+import { getRepositoryToken } from '@nestjs/typeorm';
+import { createTestModule } from './test.setup';
+import { NotFoundException, BadRequestException } from '@nestjs/common';
+import { EventEmitter2 } from '@nestjs/event-emitter';
+
+describe('AccessKeyService', () => {
+    let service: AccessKeyService;
+    let userRepository: Repository<NestAuthUser>;
+    let accessKeyRepository: Repository<NestAuthAccessKey>;
+    let dataSource: DataSource;
+    let eventEmitter: EventEmitter2;
+    let user: NestAuthUser;
+
+    beforeEach(async () => {
+        const moduleRef = await createTestModule();
+
+        service = moduleRef.get<AccessKeyService>(AccessKeyService);
+        dataSource = moduleRef.get<DataSource>(DataSource);
+        userRepository = moduleRef.get<Repository<NestAuthUser>>(getRepositoryToken(NestAuthUser));
+        accessKeyRepository = moduleRef.get<Repository<NestAuthAccessKey>>(getRepositoryToken(NestAuthAccessKey));
+        eventEmitter = moduleRef.get<EventEmitter2>(EventEmitter2);
+
+        // Create a test user
+        user = await userRepository.save({
+            email: 'test@example.com',
+            phone: '+1234567890',
+            isActive: true
+        });
+    });
+
+    afterEach(async () => {
+        // Clean up database after each test
+        await dataSource.synchronize(true);
+    });
+
+    afterAll(async () => {
+        // Close the connection after all tests
+        await dataSource.destroy();
+    });
+
+    describe('createAccessKey', () => {
+        it('should create a new access key successfully', async () => {
+            const name = 'Test API Key';
+            const metadata = { description: 'Test key' };
+
+            const result = await service.createAccessKey(user.id, name);
+
+            expect(result).toBeDefined();
+            expect(result.name).toBe(name);
+            expect(result.publicKey).toBeDefined();
+            expect(result.privateKey).toBeDefined();
+            expect(result.userId).toBe(user.id);
+            expect(result.isActive).toBe(true);
+        });
+
+        it('should throw NotFoundException if user not found', async () => {
+            await expect(
+                service.createAccessKey('non-existent-id', 'Test Key')
+            ).rejects.toThrow(NotFoundException);
+        });
+    });
+
+    describe('getAccessKey', () => {
+        it('should return access key by public key', async () => {
+            const accessKey = await service.createAccessKey(user.id, 'Test Key');
+
+            const result = await service.getAccessKey(accessKey.publicKey);
+
+            expect(result).toBeDefined();
+            expect(result.publicKey).toBe(accessKey.publicKey);
+            expect(result.user).toBeDefined();
+        });
+
+        it('should throw NotFoundException if access key not found', async () => {
+            await expect(
+                service.getAccessKey('non-existent-key')
+            ).rejects.toThrow(NotFoundException);
+        });
+
+        it('should throw BadRequestException if access key is inactive', async () => {
+            const accessKey = await service.createAccessKey(user.id, 'Test Key');
+            await service.deactivateAccessKey(accessKey.publicKey);
+
+            await expect(
+                service.getAccessKey(accessKey.publicKey)
+            ).rejects.toThrow(BadRequestException);
+        });
+
+        it('should throw BadRequestException if access key has expired', async () => {
+            const accessKey = await service.createAccessKey(user.id, 'Test Key');
+            const yesterday = new Date();
+            yesterday.setDate(yesterday.getDate() - 1);
+            await service.setAccessKeyExpiry(accessKey.publicKey, yesterday);
+
+            await expect(
+                service.getAccessKey(accessKey.publicKey)
+            ).rejects.toThrow(BadRequestException);
+        });
+    });
+
+    describe('validateAccessKey', () => {
+        it('should return true for valid key pair', async () => {
+            const accessKey = await service.createAccessKey(user.id, 'Test Key');
+
+            const isValid = await service.validateAccessKey(
+                accessKey.publicKey,
+                accessKey.privateKey
+            );
+
+            expect(isValid).toBe(true);
+        });
+
+        it('should return false for invalid private key', async () => {
+            const accessKey = await service.createAccessKey(user.id, 'Test Key');
+
+            const isValid = await service.validateAccessKey(
+                accessKey.publicKey,
+                'invalid-private-key'
+            );
+
+            expect(isValid).toBe(false);
+        });
+    });
+
+    describe('getUserAccessKeys', () => {
+        it('should return all access keys for a user', async () => {
+            // Create first key
+            await service.createAccessKey(user.id, 'Key 1');
+
+            // Create second key
+            await service.createAccessKey(user.id, 'Key 2');
+
+            const keys = await service.getUserAccessKeys(user.id);
+
+            expect(keys).toHaveLength(2);
+        });
+
+        it('should return empty array for user with no keys', async () => {
+            const keys = await service.getUserAccessKeys(user.id);
+            expect(keys).toHaveLength(0);
+        });
+    });
+
+    describe('deactivateAccessKey', () => {
+        it('should deactivate access key successfully', async () => {
+            const accessKey = await service.createAccessKey(user.id, 'Test Key');
+
+            const result = await service.deactivateAccessKey(accessKey.publicKey);
+
+            expect(result.isActive).toBe(false);
+        });
+
+        it('should throw NotFoundException if access key not found', async () => {
+            await expect(
+                service.deactivateAccessKey('non-existent-key')
+            ).rejects.toThrow(NotFoundException);
+        });
+    });
+
+    describe('updateAccessKeyLastUsed', () => {
+        it('should update last used timestamp', async () => {
+            const accessKey = await service.createAccessKey(user.id, 'Test Key');
+
+            await service.updateAccessKeyLastUsed(accessKey.publicKey);
+
+            const updatedKey = await service.getAccessKey(accessKey.publicKey);
+            expect(updatedKey.lastUsedAt).toBeDefined();
+        });
+    });
+
+    describe('setAccessKeyExpiry', () => {
+        it('should set expiry date successfully', async () => {
+            const accessKey = await service.createAccessKey(user.id, 'Test Key');
+            const tomorrow = new Date();
+            tomorrow.setDate(tomorrow.getDate() + 1);
+
+            const result = await service.setAccessKeyExpiry(accessKey.publicKey, tomorrow);
+
+            expect(result.expiresAt).toEqual(tomorrow);
+        });
+    });
+
+    describe('deleteAccessKey', () => {
+        it('should delete access key successfully', async () => {
+            const accessKey = await service.createAccessKey(user.id, 'Test Key');
+
+            await service.deleteAccessKey(accessKey.publicKey);
+
+            await expect(
+                service.getAccessKey(accessKey.publicKey)
+            ).rejects.toThrow(NotFoundException);
+        });
+
+        it('should throw NotFoundException if access key not found', async () => {
+            await expect(
+                service.deleteAccessKey('non-existent-key')
+            ).rejects.toThrow(NotFoundException);
+        });
+    });
+});