@flusys/nestjs-shared 7.0.2 → 8.0.0-beta.1

package/fesm/utils/html-sanitizer.util.js

@@ -1,69 +0,0 @@
-/**
- * HTML Sanitizer Utilities
- *
- * Provides functions for escaping HTML content to prevent XSS attacks.
- * Use these utilities when interpolating user-provided variables into HTML content.
- */ /**
- * HTML entity mapping for escaping special characters
- */ const HTML_ESCAPE_MAP = {
-    '&': '&',
-    '<': '&lt;',
-    '>': '&gt;',
-    '"': '&quot;',
-    "'": '&#x27;',
-    '/': '&#x2F;',
-    '`': '&#x60;',
-    '=': '&#x3D;'
-};
-/**
- * Regex pattern matching characters that need HTML escaping
- */ const HTML_ESCAPE_REGEX = /[&<>"'`=/]/g;
-/**
- * Escapes HTML special characters to prevent XSS attacks.
- *
- * @param str - The string to escape
- * @returns The escaped string safe for HTML insertion
- *
- * @example
- * ```typescript
- * escapeHtml('<script>alert("xss")</script>')
- * // Returns: '&lt;script&gt;alert(&quot;xss&quot;)&lt;/script&gt;'
- * ```
- */ export function escapeHtml(str) {
-    if (!str || typeof str !== 'string') {
-        return str ?? '';
-    }
-    return str.replace(HTML_ESCAPE_REGEX, (char)=>HTML_ESCAPE_MAP[char]);
-}
-/**
- * Escapes all string values in a variables object for safe HTML interpolation.
- * Non-string values are converted to strings and escaped.
- *
- * @param variables - Object containing template variables
- * @returns New object with all string values HTML-escaped
- *
- * @example
- * ```typescript
- * escapeHtmlVariables({ name: '<script>xss</script>', count: 5 })
- * // Returns: { name: '&lt;script&gt;xss&lt;/script&gt;', count: '5' }
- * ```
- */ export function escapeHtmlVariables(variables) {
-    if (!variables || typeof variables !== 'object') {
-        return {};
-    }
-    const escaped = {};
-    for (const [key, value] of Object.entries(variables)){
-        if (value === null || value === undefined) {
-            escaped[key] = '';
-        } else if (typeof value === 'string') {
-            escaped[key] = escapeHtml(value);
-        } else if (typeof value === 'object') {
-            // For objects/arrays, stringify and escape
-            escaped[key] = escapeHtml(JSON.stringify(value));
-        } else {
-            // For numbers, booleans, etc., convert to string (no escaping needed)
-            escaped[key] = String(value);
-        }
-    }
-    return escaped;
-}

package/fesm/utils/html-sanitizer.util.spec.js

@@ -1,72 +0,0 @@
-import { escapeHtml, escapeHtmlVariables } from './html-sanitizer.util';
-describe('html-sanitizer.util', ()=>{
-    describe('escapeHtml', ()=>{
-        it('should escape all special HTML characters', ()=>{
-            expect(escapeHtml('<script>alert("xss")</script>')).toBe('&lt;script&gt;alert(&quot;xss&quot;)&lt;&#x2F;script&gt;');
-        });
-        it('should escape ampersands', ()=>{
-            expect(escapeHtml('a & b')).toBe('a &amp; b');
-        });
-        it('should escape single quotes, backticks, and equals signs', ()=>{
-            expect(escapeHtml(`a='b' c=\`d\``)).toBe('a&#x3D;&#x27;b&#x27; c&#x3D;&#x60;d&#x60;');
-        });
-        it('should return an empty string for empty input', ()=>{
-            expect(escapeHtml('')).toBe('');
-        });
-        it('should return input unchanged when it has no special characters', ()=>{
-            expect(escapeHtml('Hello World 123')).toBe('Hello World 123');
-        });
-        it('should return non-string input coerced via nullish fallback', ()=>{
-            expect(escapeHtml(null)).toBe('');
-            expect(escapeHtml(undefined)).toBe('');
-        });
-        it('should return non-string, truthy input unchanged (not throw)', ()=>{
-            // e.g. a number passed at runtime despite the TS signature
-            expect(escapeHtml(42)).toBe(42);
-        });
-    });
-    describe('escapeHtmlVariables', ()=>{
-        it('should escape string values', ()=>{
-            expect(escapeHtmlVariables({
-                name: '<b>bold</b>'
-            })).toEqual({
-                name: '&lt;b&gt;bold&lt;&#x2F;b&gt;'
-            });
-        });
-        it('should convert numbers and booleans to strings without escaping', ()=>{
-            expect(escapeHtmlVariables({
-                count: 5,
-                active: true
-            })).toEqual({
-                count: '5',
-                active: 'true'
-            });
-        });
-        it('should stringify and escape object/array values', ()=>{
-            const result = escapeHtmlVariables({
-                meta: {
-                    a: '<x>'
-                }
-            });
-            expect(result.meta).toBe(escapeHtml(JSON.stringify({
-                a: '<x>'
-            })));
-        });
-        it('should convert null/undefined values to empty string', ()=>{
-            expect(escapeHtmlVariables({
-                a: null,
-                b: undefined
-            })).toEqual({
-                a: '',
-                b: ''
-            });
-        });
-        it('should return an empty object for null/non-object input', ()=>{
-            expect(escapeHtmlVariables(null)).toEqual({});
-            expect(escapeHtmlVariables(undefined)).toEqual({});
-        });
-        it('should return an empty object for an empty input object', ()=>{
-            expect(escapeHtmlVariables({})).toEqual({});
-        });
-    });
-});

package/fesm/utils/optional-module.util.js

@@ -1,25 +0,0 @@
-/**
- * Loads an optional peer dependency at runtime.
- *
- * The specifier has to stay invisible to the bundler. A plain `import(name)`
- * looks dynamic in source but webpack rewrites it into a context module rooted
- * at this directory - one that can only ever resolve files sitting next to this
- * one - so `amqplib` and `kafkajs` fail to load in the bundled app no matter how
- * correctly they are installed. Both lookups below are assembled at runtime,
- * where no bundler can rewrite them.
- *
- * `require` is used first because it is what the CommonJS builds actually run
- * on; native ESM has no `require`, and there `import()` is the only way in.
- */ export async function loadOptionalModule(name) {
-    const runtimeRequire = resolveRuntimeRequire();
-    if (runtimeRequire) return runtimeRequire(name);
-    const runtimeImport = new Function('specifier', 'return import(specifier);');
-    return runtimeImport(name);
-}
-/** Undefined under native ESM and inside a bundle that shadows nothing back */ function resolveRuntimeRequire() {
-    try {
-        return eval('typeof require === "function" ? require : undefined');
-    } catch  {
-        return undefined;
-    }
-}

package/fesm/utils/optional-module.util.spec.js

@@ -1,10 +0,0 @@
-import { loadOptionalModule } from './optional-module.util';
-describe('loadOptionalModule', ()=>{
-    it('should resolve an installed module', async ()=>{
-        const events = await loadOptionalModule('events');
-        expect(typeof events.EventEmitter).toBe('function');
-    });
-    it('should reject for a module that is not installed', async ()=>{
-        await expect(loadOptionalModule('definitely-not-installed-pkg')).rejects.toThrow();
-    });
-});

package/fesm/utils/permission-cache-key.util.js

@@ -1,10 +0,0 @@
-import { PERMISSIONS_CACHE_PREFIX } from '../constants';
-export const DEFAULT_USER_PERMISSION_KEY_FORMAT = `${PERMISSIONS_CACHE_PREFIX}:user:{userId}`;
-export const DEFAULT_COMPANY_PERMISSION_KEY_FORMAT = `${PERMISSIONS_CACHE_PREFIX}:company:{companyId}:branch:{branchId}:user:{userId}`;
-/** Single source of truth for permission cache keys, shared by the guard (reader) and cache service (writer) so a config override can't desync them; company scope requires enableCompanyFeature, not just a companyId */ export function buildPermissionCacheKey(options, config) {
-    const isCompanyScope = Boolean(config?.enableCompanyFeature && options.companyId);
-    if (isCompanyScope) {
-        return (config?.companyPermissionKeyFormat || DEFAULT_COMPANY_PERMISSION_KEY_FORMAT).replace('{userId}', options.userId).replace('{companyId}', options.companyId).replace('{branchId}', options.branchId || 'null');
-    }
-    return (config?.userPermissionKeyFormat || DEFAULT_USER_PERMISSION_KEY_FORMAT).replace('{userId}', options.userId);
-}

package/fesm/utils/permission-cache-key.util.spec.js

@@ -1,84 +0,0 @@
-import { buildPermissionCacheKey, DEFAULT_COMPANY_PERMISSION_KEY_FORMAT, DEFAULT_USER_PERMISSION_KEY_FORMAT } from './permission-cache-key.util';
-describe('permission-cache-key.util', ()=>{
-    describe('buildPermissionCacheKey', ()=>{
-        it('should build a user-scoped key when no config is provided', ()=>{
-            const key = buildPermissionCacheKey({
-                userId: 'user-1'
-            });
-            expect(key).toBe(DEFAULT_USER_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1'));
-        });
-        it('should build a user-scoped key when company feature is disabled', ()=>{
-            const key = buildPermissionCacheKey({
-                userId: 'user-1',
-                companyId: 'company-1'
-            }, {
-                enableCompanyFeature: false
-            });
-            expect(key).toBe(DEFAULT_USER_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1'));
-        });
-        it('should build a user-scoped key when company feature enabled but no companyId given', ()=>{
-            const key = buildPermissionCacheKey({
-                userId: 'user-1'
-            }, {
-                enableCompanyFeature: true
-            });
-            expect(key).toBe(DEFAULT_USER_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1'));
-        });
-        it('should build a company-scoped key when company feature is enabled and companyId is present', ()=>{
-            const key = buildPermissionCacheKey({
-                userId: 'user-1',
-                companyId: 'company-1',
-                branchId: 'branch-1'
-            }, {
-                enableCompanyFeature: true
-            });
-            expect(key).toBe(DEFAULT_COMPANY_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1').replace('{companyId}', 'company-1').replace('{branchId}', 'branch-1'));
-        });
-        it('should default branchId placeholder to "null" when branchId is missing', ()=>{
-            const key = buildPermissionCacheKey({
-                userId: 'user-1',
-                companyId: 'company-1'
-            }, {
-                enableCompanyFeature: true
-            });
-            expect(key).toContain(':branch:null:');
-        });
-        it('should default branchId placeholder to "null" when branchId is explicitly null', ()=>{
-            const key = buildPermissionCacheKey({
-                userId: 'user-1',
-                companyId: 'company-1',
-                branchId: null
-            }, {
-                enableCompanyFeature: true
-            });
-            expect(key).toContain(':branch:null:');
-        });
-        it('should use a custom userPermissionKeyFormat when provided', ()=>{
-            const key = buildPermissionCacheKey({
-                userId: 'user-1'
-            }, {
-                userPermissionKeyFormat: 'custom:{userId}'
-            });
-            expect(key).toBe('custom:user-1');
-        });
-        it('should use a custom companyPermissionKeyFormat when provided', ()=>{
-            const key = buildPermissionCacheKey({
-                userId: 'user-1',
-                companyId: 'company-1'
-            }, {
-                enableCompanyFeature: true,
-                companyPermissionKeyFormat: 'custom:{companyId}:{userId}:{branchId}'
-            });
-            expect(key).toBe('custom:company-1:user-1:null');
-        });
-        it('should treat an empty-string companyId as no company scope', ()=>{
-            const key = buildPermissionCacheKey({
-                userId: 'user-1',
-                companyId: ''
-            }, {
-                enableCompanyFeature: true
-            });
-            expect(key).toBe(DEFAULT_USER_PERMISSION_KEY_FORMAT.replace('{userId}', 'user-1'));
-        });
-    });
-});

package/fesm/utils/query-helpers.util.js

@@ -1,85 +0,0 @@
-import { BadRequestException } from '@nestjs/common';
-import { AUTH_MESSAGES } from '../constants';
-/**
- * Apply company filter to a query builder if company feature is enabled.
- * Centralizes the common pattern of filtering by user's company.
- *
- * @param query - TypeORM SelectQueryBuilder
- * @param config - Company filter configuration
- * @param user - Current logged user (may be null)
- * @returns The modified query builder
- *
- * @example
- * ```typescript
- * applyCompanyFilter(query, {
- *   isCompanyFeatureEnabled: this.config.isCompanyFeatureEnabled(),
- *   entityAlias: 'file_manager',
- * }, user);
- * ```
- */ export function applyCompanyFilter(query, config, user) {
-    const columnName = config.columnName ?? 'companyId';
-    if (config.isCompanyFeatureEnabled && user?.companyId) {
-        query.andWhere(`${config.entityAlias}.${columnName} = :companyId`, {
-            companyId: user.companyId
-        });
-    }
-    return query;
-}
-/**
- * Build a where condition object with optional company filter.
- *
- * @param baseWhere - Base where condition object
- * @param isCompanyFeatureEnabled - Whether company feature is enabled
- * @param user - Current logged user
- * @returns Where condition with companyId added if applicable
- *
- * @example
- * ```typescript
- * const where = buildCompanyWhereCondition(
- *   { id: dto.id },
- *   this.config.isCompanyFeatureEnabled(),
- *   user
- * );
- * // Returns { id: dto.id, companyId: user.companyId } if company feature enabled
- * ```
- */ export function buildCompanyWhereCondition(baseWhere, isCompanyFeatureEnabled, user) {
-    if (isCompanyFeatureEnabled && user?.companyId) {
-        return {
-            ...baseWhere,
-            companyId: user.companyId
-        };
-    }
-    return baseWhere;
-}
-/**
- * Type guard to check if entity has companyId property
- */ export function hasCompanyId(entity) {
-    return entity !== null && typeof entity === 'object' && 'companyId' in entity;
-}
-/**
- * Validates that an entity with companyId belongs to the user's company.
- * Throws BadRequestException if the entity belongs to another company.
- *
- * @param entity - Entity to validate
- * @param user - Current logged user
- * @param isCompanyFeatureEnabled - Whether company feature is enabled
- * @param entityName - Name of entity for error message (e.g., 'Email configuration')
- * @throws BadRequestException if entity belongs to another company
- *
- * @example
- * ```typescript
- * validateCompanyOwnership(config, user, this.config.isCompanyFeatureEnabled(), 'Email configuration');
- * ```
- */ export function validateCompanyOwnership(entity, user, isCompanyFeatureEnabled, entityName) {
-    if (isCompanyFeatureEnabled && user?.companyId && hasCompanyId(entity)) {
-        if (entity.companyId && entity.companyId !== user.companyId) {
-            throw new BadRequestException({
-                message: `${entityName} belongs to another company`,
-                messageKey: AUTH_MESSAGES.ENTITY_BELOG_ANOTHER_COMPANY,
-                messageVariables: {
-                    entity: entityName
-                }
-            });
-        }
-    }
-}

package/fesm/utils/query-helpers.util.spec.js

@@ -1,205 +0,0 @@
-import { BadRequestException } from '@nestjs/common';
-import { buildMockUser } from '@test-utils/mocks/logged-user.mock';
-import { applyCompanyFilter, buildCompanyWhereCondition, hasCompanyId, validateCompanyOwnership } from './query-helpers.util';
-function createMockQueryBuilder() {
-    return {
-        andWhere: jest.fn().mockReturnThis()
-    };
-}
-describe('query-helpers.util', ()=>{
-    describe('applyCompanyFilter', ()=>{
-        it('should apply the company filter when feature enabled and user has companyId', ()=>{
-            const query = createMockQueryBuilder();
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            applyCompanyFilter(query, {
-                isCompanyFeatureEnabled: true,
-                entityAlias: 'file'
-            }, user);
-            expect(query.andWhere).toHaveBeenCalledWith('file.companyId = :companyId', {
-                companyId: 'company-1'
-            });
-        });
-        it('should use a custom column name when provided', ()=>{
-            const query = createMockQueryBuilder();
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            applyCompanyFilter(query, {
-                isCompanyFeatureEnabled: true,
-                entityAlias: 'file',
-                columnName: 'company_id'
-            }, user);
-            expect(query.andWhere).toHaveBeenCalledWith('file.company_id = :companyId', {
-                companyId: 'company-1'
-            });
-        });
-        it('should not apply filter when feature disabled', ()=>{
-            const query = createMockQueryBuilder();
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            applyCompanyFilter(query, {
-                isCompanyFeatureEnabled: false,
-                entityAlias: 'file'
-            }, user);
-            expect(query.andWhere).not.toHaveBeenCalled();
-        });
-        it('should not apply filter when user is null', ()=>{
-            const query = createMockQueryBuilder();
-            applyCompanyFilter(query, {
-                isCompanyFeatureEnabled: true,
-                entityAlias: 'file'
-            }, null);
-            expect(query.andWhere).not.toHaveBeenCalled();
-        });
-        it('should not apply filter when user has no companyId', ()=>{
-            const query = createMockQueryBuilder();
-            const user = buildMockUser({
-                companyId: undefined
-            });
-            applyCompanyFilter(query, {
-                isCompanyFeatureEnabled: true,
-                entityAlias: 'file'
-            }, user);
-            expect(query.andWhere).not.toHaveBeenCalled();
-        });
-        it('should return the same query builder instance', ()=>{
-            const query = createMockQueryBuilder();
-            const result = applyCompanyFilter(query, {
-                isCompanyFeatureEnabled: false,
-                entityAlias: 'file'
-            }, null);
-            expect(result).toBe(query);
-        });
-    });
-    describe('buildCompanyWhereCondition', ()=>{
-        it('should add companyId when feature enabled and user has one', ()=>{
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            const result = buildCompanyWhereCondition({
-                id: '1'
-            }, true, user);
-            expect(result).toEqual({
-                id: '1',
-                companyId: 'company-1'
-            });
-        });
-        it('should return base where unchanged when feature disabled', ()=>{
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            const result = buildCompanyWhereCondition({
-                id: '1'
-            }, false, user);
-            expect(result).toEqual({
-                id: '1'
-            });
-        });
-        it('should return base where unchanged when user is null', ()=>{
-            const result = buildCompanyWhereCondition({
-                id: '1'
-            }, true, null);
-            expect(result).toEqual({
-                id: '1'
-            });
-        });
-        it('should return base where unchanged when user has no companyId', ()=>{
-            const user = buildMockUser({
-                companyId: undefined
-            });
-            const result = buildCompanyWhereCondition({
-                id: '1'
-            }, true, user);
-            expect(result).toEqual({
-                id: '1'
-            });
-        });
-    });
-    describe('hasCompanyId', ()=>{
-        it('should return true for an object with a companyId property', ()=>{
-            expect(hasCompanyId({
-                companyId: 'company-1'
-            })).toBe(true);
-        });
-        it('should return true even when companyId is explicitly undefined but present', ()=>{
-            expect(hasCompanyId({
-                companyId: undefined
-            })).toBe(true);
-        });
-        it('should return false for an object without a companyId property', ()=>{
-            expect(hasCompanyId({
-                id: '1'
-            })).toBe(false);
-        });
-        it('should return false for null', ()=>{
-            expect(hasCompanyId(null)).toBe(false);
-        });
-        it('should return false for non-object values', ()=>{
-            expect(hasCompanyId('string')).toBe(false);
-            expect(hasCompanyId(42)).toBe(false);
-        });
-    });
-    describe('validateCompanyOwnership', ()=>{
-        it('should not throw when feature disabled', ()=>{
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            expect(()=>validateCompanyOwnership({
-                    companyId: 'company-2'
-                }, user, false, 'Entity')).not.toThrow();
-        });
-        it('should not throw when user is null', ()=>{
-            expect(()=>validateCompanyOwnership({
-                    companyId: 'company-2'
-                }, null, true, 'Entity')).not.toThrow();
-        });
-        it('should not throw when entity has no companyId', ()=>{
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            expect(()=>validateCompanyOwnership({
-                    id: '1'
-                }, user, true, 'Entity')).not.toThrow();
-        });
-        it('should not throw when entity companyId is falsy', ()=>{
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            expect(()=>validateCompanyOwnership({
-                    companyId: null
-                }, user, true, 'Entity')).not.toThrow();
-        });
-        it('should not throw when entity companyId matches user companyId', ()=>{
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            expect(()=>validateCompanyOwnership({
-                    companyId: 'company-1'
-                }, user, true, 'Entity')).not.toThrow();
-        });
-        it('should throw BadRequestException when entity belongs to a different company', ()=>{
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            expect(()=>validateCompanyOwnership({
-                    companyId: 'company-2'
-                }, user, true, 'Email configuration')).toThrow(BadRequestException);
-        });
-        it('should include the entity name in the thrown exception message', ()=>{
-            const user = buildMockUser({
-                companyId: 'company-1'
-            });
-            try {
-                validateCompanyOwnership({
-                    companyId: 'company-2'
-                }, user, true, 'Email configuration');
-                fail('expected to throw');
-            } catch (error) {
-                expect(error.getResponse().message).toContain('Email configuration');
-            }
-        });
-    });
-});

package/fesm/utils/request.util.js

@@ -1,81 +0,0 @@
-import { envConfig } from '@flusys/nestjs-core/config';
-import { CLIENT_TYPE_HEADER } from '../constants';
-/** Time unit multipliers in milliseconds */ const TIME_UNIT_MS = {
-    s: 1000,
-    m: 60 * 1000,
-    h: 60 * 60 * 1000,
-    d: 24 * 60 * 60 * 1000,
-    w: 7 * 24 * 60 * 60 * 1000
-};
-/** Get normalized client type from request header */ function getClientType(req) {
-    const clientType = req.headers[CLIENT_TYPE_HEADER];
-    return clientType ? clientType.toLowerCase() : null;
-}
-/**
- * Detect if request is from a browser client.
- * Uses x-client-type header first, then falls back to user-agent detection.
- */ export function isBrowserRequest(req) {
-    const clientType = getClientType(req);
-    if (clientType) {
-        return clientType === 'browser' || clientType === 'web';
-    }
-    const accept = req.headers['accept'] || '';
-    if (accept.includes('text/html')) return true;
-    const userAgent = req.headers['user-agent'] || '';
-    const browserPatterns = /mozilla|chrome|safari|firefox|edge|opera|msie/i;
-    return browserPatterns.test(userAgent) && !userAgent.includes('Postman');
-}
-/**
- * Build secure cookie options based on request context.
- * Handles HTTPS detection for TLS-terminating proxies.
- */ export function buildCookieOptions(req) {
-    const hostname = req.hostname || '';
-    const origin = req.headers.origin || '';
-    const isProduction = envConfig.isProduction();
-    const forwardedProto = req.headers['x-forwarded-proto'];
-    const isHttps = isProduction || forwardedProto === 'https' || origin.startsWith('https://') || req.secure;
-    let domain;
-    const domainParts = hostname.split('.');
-    if (domainParts.length > 2 && !hostname.includes('localhost')) {
-        domain = '.' + domainParts.slice(-2).join('.');
-    }
-    return {
-        secure: isHttps,
-        sameSite: isHttps ? 'strict' : 'lax',
-        ...domain && {
-            domain
-        }
-    };
-}
-/**
- * Parse duration string to milliseconds.
- * @example '7d' → 604800000, '24h' → 86400000, '30m' → 1800000
- */ export function parseDurationToMs(duration, defaultMs = TIME_UNIT_MS.w) {
-    const match = duration.match(/^(\d+)(s|m|h|d|w)$/);
-    if (!match) return defaultMs;
-    const value = parseInt(match[1], 10);
-    const unit = match[2];
-    return value * (TIME_UNIT_MS[unit] ?? TIME_UNIT_MS.d);
-}
-/**
- * Determine the frontend base URL for auth-related links.
- * Uses allowed origins from envConfig first, then falls back to request host.
- */ export function extractFrontendUrl(req) {
-    const allowedOrigins = envConfig.getOrigins();
-    const origin = (req.get('origin') ?? req.get('referer') ?? '').trim();
-    if (origin && allowedOrigins.length) {
-        const matched = allowedOrigins.find((u)=>origin.startsWith(u));
-        if (matched) {
-            return matched;
-        }
-    }
-    const host = req.get('host');
-    if (!host) {
-        throw new Error('Unable to determine frontend URL from request');
-    }
-    return `${req.protocol}://${host}`;
-}
-export function buildFrontendUrl(req, path) {
-    const baseUrl = extractFrontendUrl(req);
-    return `${baseUrl}${path}`;
-}