@flusys/nestjs-shared 7.1.0 → 8.0.0

package/fesm/utils/request.util.spec.js

@@ -1,245 +0,0 @@
-const isProductionMock = jest.fn();
-const getOriginsMock = jest.fn();
-jest.mock('@flusys/nestjs-core/config', ()=>({
-        envConfig: {
-            isProduction: ()=>isProductionMock(),
-            getOrigins: ()=>getOriginsMock()
-        }
-    }));
-import { buildCookieOptions, buildFrontendUrl, extractFrontendUrl, isBrowserRequest, parseDurationToMs } from './request.util';
-function buildRequest(overrides = {}) {
-    return {
-        headers: {},
-        hostname: 'app.example.com',
-        secure: false,
-        get: jest.fn((name)=>overrides.headers?.[name.toLowerCase()]),
-        ...overrides
-    };
-}
-describe('request.util', ()=>{
-    beforeEach(()=>{
-        isProductionMock.mockReset().mockReturnValue(false);
-        getOriginsMock.mockReset().mockReturnValue([]);
-    });
-    describe('isBrowserRequest', ()=>{
-        it('should return true when x-client-type header is "browser"', ()=>{
-            const req = buildRequest({
-                headers: {
-                    'x-client-type': 'browser'
-                }
-            });
-            expect(isBrowserRequest(req)).toBe(true);
-        });
-        it('should return true when x-client-type header is "web"', ()=>{
-            const req = buildRequest({
-                headers: {
-                    'x-client-type': 'WEB'
-                }
-            });
-            expect(isBrowserRequest(req)).toBe(true);
-        });
-        it('should return false when x-client-type header is a non-browser value', ()=>{
-            const req = buildRequest({
-                headers: {
-                    'x-client-type': 'mobile'
-                }
-            });
-            expect(isBrowserRequest(req)).toBe(false);
-        });
-        it('should return true when accept header includes text/html', ()=>{
-            const req = buildRequest({
-                headers: {
-                    accept: 'text/html,application/xhtml+xml'
-                }
-            });
-            expect(isBrowserRequest(req)).toBe(true);
-        });
-        it('should return true for a recognized browser user-agent', ()=>{
-            const req = buildRequest({
-                headers: {
-                    'user-agent': 'Mozilla/5.0 Chrome/100.0 Safari/537.36'
-                }
-            });
-            expect(isBrowserRequest(req)).toBe(true);
-        });
-        it('should return false for Postman user-agent even if it matches browser patterns', ()=>{
-            const req = buildRequest({
-                headers: {
-                    'user-agent': 'PostmanRuntime/7.0 chrome'
-                }
-            });
-            expect(isBrowserRequest(req)).toBe(false);
-        });
-        it('should return false when no headers indicate a browser', ()=>{
-            const req = buildRequest({
-                headers: {
-                    'user-agent': 'curl/7.79.1'
-                }
-            });
-            expect(isBrowserRequest(req)).toBe(false);
-        });
-    });
-    describe('buildCookieOptions', ()=>{
-        it('should mark cookies secure and sameSite strict in production', ()=>{
-            isProductionMock.mockReturnValue(true);
-            const req = buildRequest({
-                headers: {}
-            });
-            const options = buildCookieOptions(req);
-            expect(options.secure).toBe(true);
-            expect(options.sameSite).toBe('strict');
-        });
-        it('should mark cookies insecure and sameSite lax in dev with no forwarded proto', ()=>{
-            isProductionMock.mockReturnValue(false);
-            const req = buildRequest({
-                headers: {}
-            });
-            const options = buildCookieOptions(req);
-            expect(options.secure).toBe(false);
-            expect(options.sameSite).toBe('lax');
-        });
-        it('should treat x-forwarded-proto: https as secure', ()=>{
-            isProductionMock.mockReturnValue(false);
-            const req = buildRequest({
-                headers: {
-                    'x-forwarded-proto': 'https'
-                }
-            });
-            const options = buildCookieOptions(req);
-            expect(options.secure).toBe(true);
-            expect(options.sameSite).toBe('strict');
-        });
-        it('should treat an https origin header as secure', ()=>{
-            isProductionMock.mockReturnValue(false);
-            const req = buildRequest({
-                headers: {
-                    origin: 'https://app.example.com'
-                }
-            });
-            const options = buildCookieOptions(req);
-            expect(options.secure).toBe(true);
-        });
-        it('should treat req.secure as secure', ()=>{
-            isProductionMock.mockReturnValue(false);
-            const req = buildRequest({
-                headers: {},
-                secure: true
-            });
-            const options = buildCookieOptions(req);
-            expect(options.secure).toBe(true);
-        });
-        it('should not set a domain for a localhost hostname', ()=>{
-            isProductionMock.mockReturnValue(false);
-            const req = buildRequest({
-                headers: {},
-                hostname: 'localhost'
-            });
-            const options = buildCookieOptions(req);
-            expect(options.domain).toBeUndefined();
-        });
-        it('should not set a domain for a bare two-part hostname', ()=>{
-            isProductionMock.mockReturnValue(false);
-            const req = buildRequest({
-                headers: {},
-                hostname: 'example.com'
-            });
-            const options = buildCookieOptions(req);
-            expect(options.domain).toBeUndefined();
-        });
-        it('should set a leading-dot domain for a subdomain hostname', ()=>{
-            isProductionMock.mockReturnValue(false);
-            const req = buildRequest({
-                headers: {},
-                hostname: 'app.example.com'
-            });
-            const options = buildCookieOptions(req);
-            expect(options.domain).toBe('.example.com');
-        });
-    });
-    describe('parseDurationToMs', ()=>{
-        it('should parse seconds', ()=>{
-            expect(parseDurationToMs('30s')).toBe(30 * 1000);
-        });
-        it('should parse minutes', ()=>{
-            expect(parseDurationToMs('15m')).toBe(15 * 60 * 1000);
-        });
-        it('should parse hours', ()=>{
-            expect(parseDurationToMs('2h')).toBe(2 * 60 * 60 * 1000);
-        });
-        it('should parse days', ()=>{
-            expect(parseDurationToMs('7d')).toBe(7 * 24 * 60 * 60 * 1000);
-        });
-        it('should parse weeks', ()=>{
-            expect(parseDurationToMs('2w')).toBe(2 * 7 * 24 * 60 * 60 * 1000);
-        });
-        it('should return the default when the string does not match the pattern', ()=>{
-            expect(parseDurationToMs('garbage')).toBe(7 * 24 * 60 * 60 * 1000);
-        });
-        it('should return a custom default when provided and pattern does not match', ()=>{
-            expect(parseDurationToMs('garbage', 12345)).toBe(12345);
-        });
-    });
-    describe('extractFrontendUrl', ()=>{
-        it('should return the matched allowed origin when the request origin starts with it', ()=>{
-            getOriginsMock.mockReturnValue([
-                'https://app.example.com'
-            ]);
-            const req = buildRequest({
-                headers: {
-                    origin: 'https://app.example.com'
-                },
-                get: jest.fn((name)=>{
-                    if (name === 'origin') return 'https://app.example.com';
-                    return undefined;
-                })
-            });
-            expect(extractFrontendUrl(req)).toBe('https://app.example.com');
-        });
-        it('should fall back to referer when origin header is absent', ()=>{
-            getOriginsMock.mockReturnValue([
-                'https://app.example.com'
-            ]);
-            const req = buildRequest({
-                get: jest.fn((name)=>{
-                    if (name === 'referer') return 'https://app.example.com/some/path';
-                    return undefined;
-                })
-            });
-            expect(extractFrontendUrl(req)).toBe('https://app.example.com');
-        });
-        it('should fall back to protocol + host when no origin matches an allowed origin', ()=>{
-            getOriginsMock.mockReturnValue([
-                'https://other.example.com'
-            ]);
-            const req = buildRequest({
-                get: jest.fn((name)=>{
-                    if (name === 'host') return 'app.example.com';
-                    return undefined;
-                }),
-                protocol: 'https'
-            });
-            expect(extractFrontendUrl(req)).toBe('https://app.example.com');
-        });
-        it('should throw when no origin/referer matches and no host header is present', ()=>{
-            getOriginsMock.mockReturnValue([]);
-            const req = buildRequest({
-                get: jest.fn(()=>undefined)
-            });
-            expect(()=>extractFrontendUrl(req)).toThrow('Unable to determine frontend URL from request');
-        });
-    });
-    describe('buildFrontendUrl', ()=>{
-        it('should append the path to the resolved frontend base URL', ()=>{
-            getOriginsMock.mockReturnValue([
-                'https://app.example.com'
-            ]);
-            const req = buildRequest({
-                get: jest.fn((name)=>{
-                    if (name === 'origin') return 'https://app.example.com';
-                    return undefined;
-                })
-            });
-            expect(buildFrontendUrl(req, '/reset-password?token=abc')).toBe('https://app.example.com/reset-password?token=abc');
-        });
-    });
-});

package/fesm/utils/string.util.js

@@ -1,71 +0,0 @@
-/**
- * String utility functions
- */ /**
- * Generate URL-friendly slug from a string
- * @param text - The text to convert to slug
- * @param maxLength - Maximum length of the slug (default: 100)
- * @returns URL-friendly slug
- *
- * @example
- * generateSlug('My Company Name') // 'my-company-name'
- * generateSlug('Hello World!') // 'hello-world'
- */ export function generateSlug(text, maxLength = 100) {
-    return text.toLowerCase().trim().replace(/[^a-z0-9\s-]/g, '') // Remove special characters
-    .replace(/\s+/g, '-') // Replace spaces with hyphens
-    .replace(/-+/g, '-') // Replace multiple hyphens with single
-    .replace(/^-+|-+$/g, '') // Remove leading/trailing hyphens
-    .substring(0, maxLength);
-}
-/**
- * Generate unique slug using single database query (optimized for large datasets)
- * Appends numeric suffix if collision exists (e.g., 'my-company-1', 'my-company-2')
- *
- * Performance: O(1) database query regardless of collision count
- * - Works efficiently with millions of records
- * - Requires index on slug column for best performance
- *
- * @param text - The text to convert to slug
- * @param findMatchingSlugs - Async function that returns all slugs matching base pattern
- *                            Should query: WHERE slug = baseSlug OR slug LIKE 'baseSlug-%'
- * @param maxLength - Maximum length of the base slug (default: 100)
- * @returns Unique URL-friendly slug
- *
- * @example
- * const slug = await generateUniqueSlug('My Company', async (baseSlug) => {
- *   return repo
- *     .createQueryBuilder('c')
- *     .select('c.slug')
- *     .where('c.slug = :base OR c.slug LIKE :pattern', {
- *       base: baseSlug,
- *       pattern: `${baseSlug}-%`,
- *     })
- *     .getMany()
- *     .then(rows => rows.map(r => r.slug));
- * });
- */ export async function generateUniqueSlug(text, findMatchingSlugs, maxLength = 100) {
-    const baseSlug = generateSlug(text, maxLength);
-    // Single query to get all matching slugs
-    const existingSlugs = await findMatchingSlugs(baseSlug);
-    // No collisions - base slug is available
-    if (existingSlugs.length === 0) {
-        return baseSlug;
-    }
-    // Build set for O(1) lookup
-    const existingSet = new Set(existingSlugs);
-    // Base slug not taken (only suffixed versions exist)
-    if (!existingSet.has(baseSlug)) {
-        return baseSlug;
-    }
-    // Find next available suffix in memory (fast)
-    let counter = 1;
-    while(counter < 10000){
-        const slugWithSuffix = `${baseSlug}-${counter}`;
-        if (!existingSet.has(slugWithSuffix)) {
-            return slugWithSuffix;
-        }
-        counter++;
-    }
-    // Fallback: append random string (extremely rare edge case)
-    const randomSuffix = Math.random().toString(36).substring(2, 8);
-    return `${baseSlug}-${randomSuffix}`;
-}

package/fesm/utils/string.util.spec.js

@@ -1,59 +0,0 @@
-import { generateSlug, generateUniqueSlug } from './string.util';
-describe('string.util', ()=>{
-    describe('generateSlug', ()=>{
-        it('should lowercase and hyphenate a plain string', ()=>{
-            expect(generateSlug('My Company Name')).toBe('my-company-name');
-        });
-        it('should strip special characters', ()=>{
-            expect(generateSlug('Hello World!')).toBe('hello-world');
-        });
-        it('should collapse repeated whitespace and hyphens', ()=>{
-            expect(generateSlug('Foo   Bar--Baz')).toBe('foo-bar-baz');
-        });
-        it('should trim leading/trailing hyphens produced by punctuation', ()=>{
-            expect(generateSlug('  -Hello-  ')).toBe('hello');
-        });
-        it('should truncate to maxLength', ()=>{
-            expect(generateSlug('abcdefghij', 5)).toBe('abcde');
-        });
-        it('should return an empty string for input that is only special characters', ()=>{
-            expect(generateSlug('!!!???')).toBe('');
-        });
-    });
-    describe('generateUniqueSlug', ()=>{
-        it('should return the base slug when there are no collisions', async ()=>{
-            const findMatchingSlugs = jest.fn().mockResolvedValue([]);
-            const slug = await generateUniqueSlug('My Company', findMatchingSlugs);
-            expect(slug).toBe('my-company');
-            expect(findMatchingSlugs).toHaveBeenCalledWith('my-company');
-        });
-        it('should return the base slug when only suffixed variants exist', async ()=>{
-            const findMatchingSlugs = jest.fn().mockResolvedValue([
-                'my-company-1'
-            ]);
-            const slug = await generateUniqueSlug('My Company', findMatchingSlugs);
-            expect(slug).toBe('my-company');
-        });
-        it('should append the next available numeric suffix on collision', async ()=>{
-            const findMatchingSlugs = jest.fn().mockResolvedValue([
-                'my-company',
-                'my-company-1',
-                'my-company-2'
-            ]);
-            const slug = await generateUniqueSlug('My Company', findMatchingSlugs);
-            expect(slug).toBe('my-company-3');
-        });
-        it('should fall back to a random suffix when all 9999 slots are taken', async ()=>{
-            const taken = [
-                'my-company',
-                ...Array.from({
-                    length: 9999
-                }, (_, i)=>`my-company-${i + 1}`)
-            ];
-            const findMatchingSlugs = jest.fn().mockResolvedValue(taken);
-            const slug = await generateUniqueSlug('My Company', findMatchingSlugs);
-            expect(slug).toMatch(/^my-company-[a-z0-9]+$/);
-            expect(taken).not.toContain(slug);
-        });
-    });
-});