@almatar/branding 1.0.0-beta.3.2 → 1.0.0-beta.3.4

package/lib/index.d.ts

@@ -8,6 +8,8 @@ import { TenantEntitySubscriber } from './lib/TenantModel/TypeORM/TenantEntitySu
 import { TenantHttpInterceptor } from './lib/TenantModel/TypeORM/TenantHttpInterceptor';
 import { MongooseTenantHelper } from './lib/TenantModel/MongooseTenantHelper';
 import { TenantMongooseRepository } from './lib/TenantModel/MongooseTenantRepository';
+import { JunctionTableTenantRepository, IJunctionTableBrandConfig } from './lib/TenantModel/TypeORM/JunctionTableTenantRepository';
+import { JunctionTableEntitySubscriber, IJunctionTableSyncConfig, IGenericJunctionTableConfig } from './lib/TenantModel/TypeORM/JunctionTableEntitySubscriber';
 declare const _default: {
     ContextNamespace: typeof ContextNamespace;
     MultiTenant: typeof MultiTenant;
@@ -19,5 +21,8 @@ declare const _default: {
     TenantHttpInterceptor: typeof TenantHttpInterceptor;
     MongooseTenantHelper: typeof MongooseTenantHelper;
     TenantMongooseRepository: typeof TenantMongooseRepository;
+    JunctionTableTenantRepository: typeof JunctionTableTenantRepository;
+    JunctionTableEntitySubscriber: typeof JunctionTableEntitySubscriber;
 };
 export = _default;
+export type { IJunctionTableBrandConfig, IJunctionTableSyncConfig, IGenericJunctionTableConfig };

package/lib/index.js

@@ -12,6 +12,8 @@ const TenantEntitySubscriber_1 = require("./lib/TenantModel/TypeORM/TenantEntity
 const TenantHttpInterceptor_1 = require("./lib/TenantModel/TypeORM/TenantHttpInterceptor");
 const MongooseTenantHelper_1 = require("./lib/TenantModel/MongooseTenantHelper");
 const MongooseTenantRepository_1 = require("./lib/TenantModel/MongooseTenantRepository");
+const JunctionTableTenantRepository_1 = require("./lib/TenantModel/TypeORM/JunctionTableTenantRepository");
+const JunctionTableEntitySubscriber_1 = require("./lib/TenantModel/TypeORM/JunctionTableEntitySubscriber");
 module.exports = {
     ContextNamespace: Storage_1.default,
     MultiTenant: MultiTenant_1.default,
@@ -23,4 +25,6 @@ module.exports = {
     TenantHttpInterceptor: TenantHttpInterceptor_1.TenantHttpInterceptor,
     MongooseTenantHelper: MongooseTenantHelper_1.MongooseTenantHelper,
     TenantMongooseRepository: MongooseTenantRepository_1.TenantMongooseRepository,
+    JunctionTableTenantRepository: JunctionTableTenantRepository_1.JunctionTableTenantRepository,
+    JunctionTableEntitySubscriber: JunctionTableEntitySubscriber_1.JunctionTableEntitySubscriber,
 };

package/lib/lib/BrandIdentifier.d.ts

@@ -4,5 +4,6 @@ export declare class BrandIdentifier {
     getBrand(req: any): Promise<string | string[] | null>;
     getBrands(): Promise<string[] | null>;
     getDefaultBrand(): string;
+    private getQueryBrand;
     private error;
 }

package/lib/lib/BrandIdentifier.js

@@ -22,12 +22,31 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BrandIdentifier = void 0;
 const Boom = __importStar(require("@hapi/boom"));
 const BrandManager_1 = require("./BrandManager");
+const url = __importStar(require("url"));
 class BrandIdentifier {
     constructor(type) {
         this.type = type;
     }
     async getBrand(req) {
+        var _a;
         const brandManager = new BrandManager_1.BrandManager(this.type);
+        // Priority 1: Query parameter brand (super admin override)
+        const queryBrand = this.getQueryBrand(req);
+        // Troubleshoot logs (keep while integrating across microservices)
+        // tslint:disable-next-line no-console
+        console.log('[BrandIdentifier] Query brand detection:', {
+            'req.query': req === null || req === void 0 ? void 0 : req.query,
+            'req.query.brand': (_a = req === null || req === void 0 ? void 0 : req.query) === null || _a === void 0 ? void 0 : _a.brand,
+            'req.url': req === null || req === void 0 ? void 0 : req.url,
+            'req.originalUrl': req === null || req === void 0 ? void 0 : req.originalUrl,
+            'queryBrand (final)': queryBrand,
+        });
+        if (queryBrand) {
+            // tslint:disable-next-line no-console
+            console.log('[BrandIdentifier] Using query parameter brand (overriding token brands):', queryBrand);
+            // Return as array so ContextNamespace stores it as employeeBrands (used by filters)
+            return [queryBrand];
+        }
         if (req.headers['x-brand']) {
             // B2C scenario - return the brand from x-brand header
             return brandManager.getB2CBrand(req);
@@ -36,12 +55,16 @@ class BrandIdentifier {
             // Employee/Console scenario - extract from token or x-employee-brands header
             const brand = await brandManager.getConsoleBrands(req);
             if (brand && brand.length > 0) {
+                // tslint:disable-next-line no-console
+                console.log('[BrandIdentifier] Using console/token brands:', brand);
                 return brand;
             }
             // If no brand found but we have authorization, try extracting from token directly
             if (req.headers.authorization) {
                 const tokenBrands = brandManager.extractBrandFromToken(req.headers.authorization);
                 if (tokenBrands && tokenBrands.length > 0) {
+                    // tslint:disable-next-line no-console
+                    console.log('[BrandIdentifier] Using brands extracted directly from token:', tokenBrands);
                     return tokenBrands;
                 }
             }
@@ -78,6 +101,29 @@ class BrandIdentifier {
         const brandManager = new BrandManager_1.BrandManager(this.type);
         return brandManager.getDefaultBrand();
     }
+    getQueryBrand(req) {
+        var _a, _b;
+        try {
+            // Express/NestJS typically populates req.query
+            const fromQuery = (_a = req === null || req === void 0 ? void 0 : req.query) === null || _a === void 0 ? void 0 : _a.brand;
+            if (typeof fromQuery === 'string' && fromQuery.trim()) {
+                return fromQuery.trim();
+            }
+            // Fallback to parsing URLs if req.query isn't populated yet
+            const urlToParse = (req === null || req === void 0 ? void 0 : req.originalUrl) || (req === null || req === void 0 ? void 0 : req.url);
+            if (typeof urlToParse === 'string' && urlToParse.includes('?')) {
+                const parsedUrl = url.parse(urlToParse, true);
+                const parsedBrand = (_b = parsedUrl.query) === null || _b === void 0 ? void 0 : _b.brand;
+                if (typeof parsedBrand === 'string' && parsedBrand.trim()) {
+                    return parsedBrand.trim();
+                }
+            }
+        }
+        catch (err) {
+            // ignore - fall back to other brand sources
+        }
+        return null;
+    }
     error(message) {
         switch (this.type) {
             case 'hapi':

package/lib/lib/JunctionTableBrandFilter.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Configuration interface for junction table filtering (internal use only)
+ * Not exported - use JunctionTableBrandConfig for automatic repository instead
+ */
+interface IJunctionTableFilterConfig {
+    /** Junction table name (e.g., 'role_brands', 'user_brands', 'permission_departments') */
+    junctionTableName: string;
+    /** Junction table alias for the query (e.g., 'rb', 'ub', 'pd') */
+    junctionTableAlias: string;
+    /** Foreign key column name in junction table that references the main entity (e.g., 'role_id', 'user_id', 'permission_id') */
+    foreignKeyColumn: string;
+    /** Primary key column name in the main entity table (usually 'id') */
+    primaryKeyColumn?: string;
+    /** Filter column name in junction table (e.g., 'brand', 'department_id') */
+    filterColumn: string;
+    /** Filter values to apply (e.g., brand names array or department IDs array) */
+    filterValues: string[] | number[];
+    /** Main entity table alias used in the query (e.g., 'role', 'employee', 'permission') */
+    entityAlias: string;
+}
+/**
+ * Helper class to apply brand/department filtering using junction tables (tenant scope only).
+ *
+ * This provides 10-100x faster queries compared to JSON_CONTAINS on JSON columns.
+ * Only uses tenant scope for brand filtering - no extra filtering.
+ *
+ * The tenant scope is automatically handled by ContextNamespace.getBrand() which
+ * retrieves brands from the request context (token/headers).
+ *
+ * This is an internal implementation used by JunctionTableTenantRepository.
+ * For automatic brand filtering, use JunctionTableTenantRepository instead.
+ *
+ * @internal - This class is for internal use only. Use JunctionTableTenantRepository for automatic filtering.
+ */
+export declare class JunctionTableBrandFilter {
+    /**
+     * Generic method to apply filtering using a junction table.
+     * This is the core method that all other methods use internally.
+     *
+     * @param query - The query builder to apply filtering to
+     * @param config - Configuration object specifying junction table structure
+     */
+    static applyGenericFilter(query: any, config: IJunctionTableFilterConfig): void;
+    /**
+     * Generic method to apply brand filtering using a junction table.
+     * Automatically gets brands from context (tenant scope).
+     *
+     * @param query - The query builder to apply filtering to
+     * @param config - Configuration object (without filterValues, as it's auto-retrieved from context)
+     */
+    static applyGenericBrandFilter(query: any, config: Omit<IJunctionTableFilterConfig, 'filterValues'>): void;
+    /**
+     * Generic method to apply numeric ID filtering using a junction table.
+     * Works for departments, categories, or any numeric ID-based filtering.
+     *
+     * @param query - The query builder to apply filtering to
+     * @param config - Configuration object with filterValues (departmentIds, categoryIds, etc.)
+     */
+    static applyGenericNumericFilter(query: any, config: Omit<IJunctionTableFilterConfig, 'filterValues'> & {
+        filterValues: number[];
+    }): void;
+    /**
+     * Get brands from context (tenant scope is handled by ContextNamespace).
+     * Returns null if no brands are available or if user is almatar admin.
+     *
+     * @returns Array of brand strings or null if no filtering needed
+     */
+    private static getBrandsFromContext;
+}
+export {};

package/lib/lib/JunctionTableBrandFilter.js

@@ -0,0 +1,85 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JunctionTableBrandFilter = void 0;
+const Storage_1 = __importDefault(require("./Storage"));
+/**
+ * Helper class to apply brand/department filtering using junction tables (tenant scope only).
+ *
+ * This provides 10-100x faster queries compared to JSON_CONTAINS on JSON columns.
+ * Only uses tenant scope for brand filtering - no extra filtering.
+ *
+ * The tenant scope is automatically handled by ContextNamespace.getBrand() which
+ * retrieves brands from the request context (token/headers).
+ *
+ * This is an internal implementation used by JunctionTableTenantRepository.
+ * For automatic brand filtering, use JunctionTableTenantRepository instead.
+ *
+ * @internal - This class is for internal use only. Use JunctionTableTenantRepository for automatic filtering.
+ */
+class JunctionTableBrandFilter {
+    /**
+     * Generic method to apply filtering using a junction table.
+     * This is the core method that all other methods use internally.
+     *
+     * @param query - The query builder to apply filtering to
+     * @param config - Configuration object specifying junction table structure
+     */
+    static applyGenericFilter(query, config) {
+        const { junctionTableName, junctionTableAlias, foreignKeyColumn, filterColumn, filterValues, entityAlias, primaryKeyColumn = 'id' } = config;
+        if (!filterValues || filterValues.length === 0) {
+            return; // No filtering needed
+        }
+        // Build the join condition
+        const joinCondition = `${junctionTableAlias}.${foreignKeyColumn} = ${entityAlias}.${primaryKeyColumn} AND ${junctionTableAlias}.${filterColumn} IN (:...filterValues)`;
+        // Use junction table for fast filtering
+        query.innerJoin(junctionTableName, junctionTableAlias, joinCondition, { filterValues });
+    }
+    /**
+     * Generic method to apply brand filtering using a junction table.
+     * Automatically gets brands from context (tenant scope).
+     *
+     * @param query - The query builder to apply filtering to
+     * @param config - Configuration object (without filterValues, as it's auto-retrieved from context)
+     */
+    static applyGenericBrandFilter(query, config) {
+        const brands = this.getBrandsFromContext();
+        if (!brands) {
+            return; // No brand filtering needed (no brands or almatar admin)
+        }
+        // Apply generic filter with brands from context
+        this.applyGenericFilter(query, Object.assign(Object.assign({}, config), { filterValues: brands }));
+    }
+    /**
+     * Generic method to apply numeric ID filtering using a junction table.
+     * Works for departments, categories, or any numeric ID-based filtering.
+     *
+     * @param query - The query builder to apply filtering to
+     * @param config - Configuration object with filterValues (departmentIds, categoryIds, etc.)
+     */
+    static applyGenericNumericFilter(query, config) {
+        this.applyGenericFilter(query, config);
+    }
+    /**
+     * Get brands from context (tenant scope is handled by ContextNamespace).
+     * Returns null if no brands are available or if user is almatar admin.
+     *
+     * @returns Array of brand strings or null if no filtering needed
+     */
+    static getBrandsFromContext() {
+        const contextEmployeeBrands = Storage_1.default.getEmployeeBrands();
+        const contextBrand = Storage_1.default.getBrand();
+        const brands = contextEmployeeBrands || (contextBrand ? [contextBrand] : null);
+        if (!brands || brands.length === 0) {
+            return null; // No brand filtering needed
+        }
+        // Check if user is almatar admin - bypass filtering
+        if (brands.includes('almatar')) {
+            return null; // Almatar admin can see all brands
+        }
+        return brands;
+    }
+}
+exports.JunctionTableBrandFilter = JunctionTableBrandFilter;

package/lib/lib/Storage.d.ts

@@ -14,4 +14,5 @@ export default class ContextNamespace {
     static getDefaultBrand(): string | null;
     static isValidBrand(brand: string): boolean;
     static isBrandIncludesProduct(brandKey: string, product: string): boolean;
+    private static getQueryBrand;
 }

package/lib/lib/Storage.js

@@ -1,6 +1,26 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const BrandIdentifier_1 = require("./BrandIdentifier");
+const url = __importStar(require("url"));
 const createNamespace = require('cls-hooked').createNamespace;
 const namespaceName = 'request';
 const ns = createNamespace(namespaceName);
@@ -16,19 +36,52 @@ class ContextNamespace {
         });
     }
     static async setEBrand(req, res, next) {
+        var _a, _b, _c;
         const brandIdentifier = new BrandIdentifier_1.BrandIdentifier('express');
         const brand = await brandIdentifier.getBrand(req);
+        // Check if query parameter brand was used (allows super admin to query specific brand)
+        const queryBrand = ContextNamespace.getQueryBrand(req);
+        const isQueryParameterBrand = !!queryBrand;
+        // Troubleshoot logs (keep while integrating across microservices)
+        // tslint:disable-next-line no-console
+        console.log('[ContextNamespace] setEBrand request snapshot:', {
+            'req.url': req === null || req === void 0 ? void 0 : req.url,
+            'req.originalUrl': req === null || req === void 0 ? void 0 : req.originalUrl,
+            'req.query': req === null || req === void 0 ? void 0 : req.query,
+            'queryBrand (final)': queryBrand,
+            'hasAuthorization': !!((_a = req === null || req === void 0 ? void 0 : req.headers) === null || _a === void 0 ? void 0 : _a.authorization),
+            'incoming x-brand': (_b = req === null || req === void 0 ? void 0 : req.headers) === null || _b === void 0 ? void 0 : _b['x-brand'],
+            'incoming x-employee-brands': (_c = req === null || req === void 0 ? void 0 : req.headers) === null || _c === void 0 ? void 0 : _c['x-employee-brands'],
+        });
         // Check if this is a B2C request (x-brand header) - don't set x-employee-brands for B2C
-        const isB2CRequest = !!req.headers['x-brand'];
-        // Check if this is an employee/console request (authorization token)
-        const isEmployeeRequest = !!req.headers.authorization || !!req.headers['x-employee-brands'];
+        const isB2CRequest = !!req.headers['x-brand'] && !isQueryParameterBrand;
+        // Check if this is an employee/console request (authorization token or query parameter brand)
+        const isEmployeeRequest = !!req.headers.authorization || !!req.headers['x-employee-brands'] || isQueryParameterBrand;
         if (Array.isArray(brand)) {
-            // Employee/Console scenario with multiple brands
+            // Employee/Console scenario with multiple brands (or query parameter brand)
             // tslint:disable-next-line no-console
-            console.log('[ContextNamespace] Setting employeeBrands in context:', brand);
+            console.log('[ContextNamespace] Setting employeeBrands in context:', brand, isQueryParameterBrand ? '(from query parameter)' : '');
+            // IMPORTANT: If query parameter brand is used, clear any existing brand context first
+            // This ensures query parameter brand takes absolute priority
+            if (isQueryParameterBrand) {
+                // Clear any existing brand context to ensure query parameter brand is used
+                ns.set('brand', null);
+                // tslint:disable-next-line no-console
+                console.log('[ContextNamespace] Cleared existing brand context to prioritize query parameter brand');
+            }
+            // IMPORTANT: Set employeeBrands in context - this is what MongooseModel pre-hooks will read
             ns.set('employeeBrands', brand);
-            // Only set x-employee-brands header for employee requests (not B2C)
-            if (isEmployeeRequest && brand.length > 0) {
+            // Troubleshoot: verify it was set
+            // tslint:disable-next-line no-console
+            console.log('[ContextNamespace] employeeBrands in context now:', ns.get('employeeBrands'));
+            // If query parameter brand is used with authorization token, always set x-employee-brands header
+            if (isQueryParameterBrand && req.headers.authorization && brand.length > 0) {
+                req.headers['x-employee-brands'] = brand.join(',');
+                // tslint:disable-next-line no-console
+                console.log('[ContextNamespace] Set x-employee-brands from query brand (with token):', req.headers['x-employee-brands']);
+            }
+            else if (isEmployeeRequest && brand.length > 0) {
+                // Set x-employee-brands header for employee requests (normal flow)
                 req.headers['x-employee-brands'] = brand.join(',');
                 // tslint:disable-next-line no-console
                 console.log('[ContextNamespace] Setting x-employee-brands header on request:', req.headers['x-employee-brands']);
@@ -49,10 +102,18 @@ class ContextNamespace {
                 // tslint:disable-next-line no-console
                 console.log('[ContextNamespace] Setting brand in context (Employee):', brand);
                 ns.set('brand', brand);
-                // Set x-employee-brands header for employee requests
-                req.headers['x-employee-brands'] = brand;
-                // tslint:disable-next-line no-console
-                console.log('[ContextNamespace] Setting x-employee-brands header on request:', req.headers['x-employee-brands']);
+                // If query parameter brand is used with authorization token, always set x-employee-brands header
+                if (isQueryParameterBrand && req.headers.authorization) {
+                    req.headers['x-employee-brands'] = brand;
+                    // tslint:disable-next-line no-console
+                    console.log('[ContextNamespace] Set x-employee-brands from query brand (with token):', req.headers['x-employee-brands']);
+                }
+                else {
+                    // Set x-employee-brands header for employee requests (normal flow)
+                    req.headers['x-employee-brands'] = brand;
+                    // tslint:disable-next-line no-console
+                    console.log('[ContextNamespace] Setting x-employee-brands header on request:', req.headers['x-employee-brands']);
+                }
                 next();
             }
             else {
@@ -83,9 +144,16 @@ class ContextNamespace {
         });
     }
     static async setHBrand(req, reply) {
+        var _a;
         const brandIdentifier = new BrandIdentifier_1.BrandIdentifier('hapi');
         const brand = await brandIdentifier.getBrand(req);
+        // Check if query parameter brand was used
+        const queryBrand = (_a = req.query) === null || _a === void 0 ? void 0 : _a.brand;
+        const isQueryParameterBrand = !!queryBrand;
         if (Array.isArray(brand)) {
+            // Employee/Console scenario with multiple brands (or query parameter brand)
+            // tslint:disable-next-line no-console
+            console.log('[ContextNamespace] Setting employeeBrands in context (Hapi):', brand, isQueryParameterBrand ? '(from query parameter)' : '');
             ns.set('employeeBrands', brand);
             reply();
         }
@@ -137,5 +205,26 @@ class ContextNamespace {
         const brand = (_a = ns.get('brandsList')) === null || _a === void 0 ? void 0 : _a.filter((b) => b.key === brandKey)[0];
         return (_b = brand.products) === null || _b === void 0 ? void 0 : _b.includes(product);
     }
+    static getQueryBrand(req) {
+        var _a, _b;
+        try {
+            const fromQuery = (_a = req === null || req === void 0 ? void 0 : req.query) === null || _a === void 0 ? void 0 : _a.brand;
+            if (typeof fromQuery === 'string' && fromQuery.trim()) {
+                return fromQuery.trim();
+            }
+            const urlToParse = (req === null || req === void 0 ? void 0 : req.originalUrl) || (req === null || req === void 0 ? void 0 : req.url);
+            if (typeof urlToParse === 'string' && urlToParse.includes('?')) {
+                const parsedUrl = url.parse(urlToParse, true);
+                const parsedBrand = (_b = parsedUrl.query) === null || _b === void 0 ? void 0 : _b.brand;
+                if (typeof parsedBrand === 'string' && parsedBrand.trim()) {
+                    return parsedBrand.trim();
+                }
+            }
+        }
+        catch (err) {
+            // ignore
+        }
+        return null;
+    }
 }
 exports.default = ContextNamespace;

package/lib/lib/TenantModel/MongooseModel.js

@@ -38,6 +38,13 @@ class MongooseModel {
                 const employeeBrands = Storage_1.default.getEmployeeBrands();
                 const brand = Storage_1.default.getBrand();
                 const contextBrands = employeeBrands || (brand ? [brand] : null);
+                // Troubleshoot logs (keep while integrating across microservices)
+                // tslint:disable-next-line no-console
+                console.log('[MongooseModel] addPreCondition - Context:', {
+                    employeeBrands,
+                    brand,
+                    contextBrands,
+                });
                 // Only apply filter if brands are explicitly set (not null/undefined)
                 if (contextBrands && contextBrands.length > 0) {
                     // Use $in to check if entity's brand is in the user's brands array

package/lib/lib/TenantModel/TypeORM/JunctionTableEntitySubscriber.d.ts

@@ -0,0 +1,107 @@
+import { EntitySubscriberInterface, InsertEvent, UpdateEvent, RemoveEvent } from 'typeorm';
+/**
+ * Configuration for a generic junction table sync (for numeric IDs like departments, categories, etc.)
+ */
+export interface IGenericJunctionTableConfig {
+    /** Junction table name (e.g., 'user_departments', 'permission_categories') */
+    junctionTableName: string;
+    /** Foreign key column name in junction table (e.g., 'user_id', 'permission_id') */
+    foreignKeyColumn: string;
+    /** Filter column name in junction table (e.g., 'department_id', 'category_id') */
+    filterColumn: string;
+    /** Entity property name that contains the filter values (e.g., 'departmentId', 'categoryId') */
+    entityPropertyName: string;
+}
+/**
+ * Configuration for automatic junction table syncing
+ */
+export interface IJunctionTableSyncConfig {
+    /** Entity table name (e.g., 'users', 'roles') */
+    entityTableName: string;
+    /** Junction table name for brands (e.g., 'user_brands', 'role_brands') */
+    brandJunctionTable?: string;
+    /** Foreign key column name in brand junction table (e.g., 'user_id', 'role_id') */
+    brandForeignKeyColumn?: string;
+    /** Generic junction table configurations for numeric ID filters (departments, categories, etc.) */
+    genericJunctionTables?: IGenericJunctionTableConfig[];
+}
+/**
+ * TypeORM EntitySubscriber that AUTOMATICALLY syncs junction tables when entities are saved.
+ *
+ * This ensures that whenever you create or update a role/employee/user, the junction tables
+ * are automatically updated based on the brand/departmentId properties you provide.
+ *
+ * Configuration is done via a static map that maps entity table names to junction table configs.
+ *
+ * Usage:
+ * ```typescript
+ * import { JunctionTableEntitySubscriber } from '@almatar/branding';
+ *
+ * // Configure junction tables for your entities
+ * JunctionTableEntitySubscriber.configure({
+ *   entityTableName: 'roles',
+ *   brandJunctionTable: 'role_brands',
+ *   brandForeignKeyColumn: 'role_id',
+ * });
+ *
+ * JunctionTableEntitySubscriber.configure({
+ *   entityTableName: 'users',
+ *   brandJunctionTable: 'user_brands',
+ *   brandForeignKeyColumn: 'user_id',
+ *   genericJunctionTables: [
+ *     {
+ *       junctionTableName: 'user_departments',
+ *       foreignKeyColumn: 'user_id',
+ *       filterColumn: 'department_id',
+ *       entityPropertyName: 'departmentId',
+ *     },
+ *   ],
+ * });
+ *
+ * // Register in DataSource
+ * export const dataSourceOptions: DataSourceOptions = {
+ *   subscribers: [JunctionTableEntitySubscriber],
+ * };
+ * ```
+ */
+export declare class JunctionTableEntitySubscriber implements EntitySubscriberInterface {
+    /**
+     * Configure junction table syncing for an entity
+     */
+    static configure(config: IJunctionTableSyncConfig): void;
+    /**
+     * Static configuration map: entity table name -> junction table config
+     */
+    private static configMap;
+    /**
+     * Get configuration for an entity table
+     */
+    private static getConfig;
+    /**
+     * Called after an entity is inserted
+     * Automatically syncs junction tables if entity has brand/departmentId properties
+     */
+    afterInsert(event: InsertEvent<any>): Promise<void>;
+    /**
+     * Called after an entity is updated
+     * Automatically syncs junction tables if entity has brand/departmentId properties
+     */
+    afterUpdate(event: UpdateEvent<any>): Promise<void>;
+    /**
+     * Called after an entity is removed
+     * Automatically cleans up junction table entries
+     */
+    afterRemove(event: RemoveEvent<any>): Promise<void>;
+    /**
+     * Sync junction tables based on entity properties
+     */
+    private syncJunctionTables;
+    /**
+     * Sync brand junction table
+     */
+    private syncBrandJunctionTable;
+    /**
+     * Sync generic junction table for numeric ID filters (departments, categories, etc.)
+     */
+    private syncGenericJunctionTable;
+}

package/lib/lib/TenantModel/TypeORM/JunctionTableEntitySubscriber.js

@@ -0,0 +1,175 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var JunctionTableEntitySubscriber_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JunctionTableEntitySubscriber = void 0;
+const typeorm_1 = require("typeorm");
+/**
+ * TypeORM EntitySubscriber that AUTOMATICALLY syncs junction tables when entities are saved.
+ *
+ * This ensures that whenever you create or update a role/employee/user, the junction tables
+ * are automatically updated based on the brand/departmentId properties you provide.
+ *
+ * Configuration is done via a static map that maps entity table names to junction table configs.
+ *
+ * Usage:
+ * ```typescript
+ * import { JunctionTableEntitySubscriber } from '@almatar/branding';
+ *
+ * // Configure junction tables for your entities
+ * JunctionTableEntitySubscriber.configure({
+ *   entityTableName: 'roles',
+ *   brandJunctionTable: 'role_brands',
+ *   brandForeignKeyColumn: 'role_id',
+ * });
+ *
+ * JunctionTableEntitySubscriber.configure({
+ *   entityTableName: 'users',
+ *   brandJunctionTable: 'user_brands',
+ *   brandForeignKeyColumn: 'user_id',
+ *   genericJunctionTables: [
+ *     {
+ *       junctionTableName: 'user_departments',
+ *       foreignKeyColumn: 'user_id',
+ *       filterColumn: 'department_id',
+ *       entityPropertyName: 'departmentId',
+ *     },
+ *   ],
+ * });
+ *
+ * // Register in DataSource
+ * export const dataSourceOptions: DataSourceOptions = {
+ *   subscribers: [JunctionTableEntitySubscriber],
+ * };
+ * ```
+ */
+let JunctionTableEntitySubscriber = JunctionTableEntitySubscriber_1 = class JunctionTableEntitySubscriber {
+    /**
+     * Configure junction table syncing for an entity
+     */
+    static configure(config) {
+        this.configMap.set(config.entityTableName, config);
+    }
+    /**
+     * Get configuration for an entity table
+     */
+    static getConfig(tableName) {
+        return this.configMap.get(tableName);
+    }
+    /**
+     * Called after an entity is inserted
+     * Automatically syncs junction tables if entity has brand/departmentId properties
+     */
+    async afterInsert(event) {
+        await this.syncJunctionTables(event.entity, event.metadata.tableName, event.manager);
+    }
+    /**
+     * Called after an entity is updated
+     * Automatically syncs junction tables if entity has brand/departmentId properties
+     */
+    async afterUpdate(event) {
+        if (event.entity) {
+            await this.syncJunctionTables(event.entity, event.metadata.tableName, event.manager);
+        }
+    }
+    /**
+     * Called after an entity is removed
+     * Automatically cleans up junction table entries
+     */
+    async afterRemove(event) {
+        var _a, _b;
+        const config = JunctionTableEntitySubscriber_1.getConfig(event.metadata.tableName);
+        if (!config) {
+            return;
+        }
+        const entityId = ((_a = event.entity) === null || _a === void 0 ? void 0 : _a.id) || ((_b = event.databaseEntity) === null || _b === void 0 ? void 0 : _b.id);
+        if (!entityId) {
+            return;
+        }
+        // Clean up brand junction table
+        if (config.brandJunctionTable && config.brandForeignKeyColumn) {
+            await event.manager.query(`DELETE FROM ${config.brandJunctionTable} WHERE ${config.brandForeignKeyColumn} = ?`, [entityId]);
+        }
+        // Clean up generic junction tables
+        if (config.genericJunctionTables) {
+            for (const genericConfig of config.genericJunctionTables) {
+                await event.manager.query(`DELETE FROM ${genericConfig.junctionTableName} WHERE ${genericConfig.foreignKeyColumn} = ?`, [entityId]);
+            }
+        }
+    }
+    /**
+     * Sync junction tables based on entity properties
+     */
+    async syncJunctionTables(entity, tableName, manager) {
+        const config = JunctionTableEntitySubscriber_1.getConfig(tableName);
+        if (!config) {
+            return; // No configuration for this entity
+        }
+        const entityId = entity === null || entity === void 0 ? void 0 : entity.id;
+        if (!entityId) {
+            return; // Entity doesn't have an ID yet
+        }
+        // Sync brand junction table if entity has brand property
+        if (config.brandJunctionTable && config.brandForeignKeyColumn && entity.brand) {
+            await this.syncBrandJunctionTable(manager, entityId, entity.brand, config.brandJunctionTable, config.brandForeignKeyColumn);
+        }
+        // Sync generic junction tables (departments, categories, etc.)
+        if (config.genericJunctionTables) {
+            for (const genericConfig of config.genericJunctionTables) {
+                const filterValues = entity[genericConfig.entityPropertyName];
+                if (filterValues) {
+                    await this.syncGenericJunctionTable(manager, entityId, filterValues, genericConfig.junctionTableName, genericConfig.foreignKeyColumn, genericConfig.filterColumn);
+                }
+            }
+        }
+    }
+    /**
+     * Sync brand junction table
+     */
+    async syncBrandJunctionTable(manager, entityId, brands, junctionTableName, foreignKeyColumn) {
+        // Normalize to array
+        const brandArray = Array.isArray(brands) ? brands : [brands].filter(Boolean);
+        // Delete existing entries
+        await manager.query(`DELETE FROM ${junctionTableName} WHERE ${foreignKeyColumn} = ?`, [entityId]);
+        // Insert new entries
+        if (brandArray.length > 0) {
+            const placeholders = brandArray.map(() => '(?, ?)').join(',');
+            const values = [];
+            brandArray.forEach((brand) => {
+                values.push(entityId, brand);
+            });
+            await manager.query(`INSERT INTO ${junctionTableName} (${foreignKeyColumn}, brand) VALUES ${placeholders}`, values);
+        }
+    }
+    /**
+     * Sync generic junction table for numeric ID filters (departments, categories, etc.)
+     */
+    async syncGenericJunctionTable(manager, entityId, filterValues, junctionTableName, foreignKeyColumn, filterColumn) {
+        // Normalize to array
+        const filterArray = Array.isArray(filterValues) ? filterValues : [filterValues].filter(Boolean);
+        // Delete existing entries
+        await manager.query(`DELETE FROM ${junctionTableName} WHERE ${foreignKeyColumn} = ?`, [entityId]);
+        // Insert new entries
+        if (filterArray.length > 0) {
+            const placeholders = filterArray.map(() => '(?, ?)').join(',');
+            const values = [];
+            filterArray.forEach((filterValue) => {
+                values.push(entityId, filterValue);
+            });
+            await manager.query(`INSERT INTO ${junctionTableName} (${foreignKeyColumn}, ${filterColumn}) VALUES ${placeholders}`, values);
+        }
+    }
+};
+/**
+ * Static configuration map: entity table name -> junction table config
+ */
+JunctionTableEntitySubscriber.configMap = new Map();
+JunctionTableEntitySubscriber = JunctionTableEntitySubscriber_1 = __decorate([
+    typeorm_1.EventSubscriber()
+], JunctionTableEntitySubscriber);
+exports.JunctionTableEntitySubscriber = JunctionTableEntitySubscriber;

package/lib/lib/TenantModel/TypeORM/JunctionTableTenantRepository.d.ts

@@ -0,0 +1,66 @@
+import { SelectQueryBuilder, ObjectLiteral } from 'typeorm';
+import { TenantRepository } from './TenantRepository';
+/**
+ * Configuration for junction table brand filtering
+ */
+export interface IJunctionTableBrandConfig {
+    /** Junction table name (e.g., 'role_brands', 'user_brands', 'hotel_brands') */
+    junctionTableName: string;
+    /** Junction table alias for the query (e.g., 'rb', 'ub', 'hb') */
+    junctionTableAlias: string;
+    /** Foreign key column name in junction table that references the main entity (e.g., 'role_id', 'user_id', 'hotel_id') */
+    foreignKeyColumn: string;
+    /** Primary key column name in the main entity table (usually 'id', defaults to 'id') */
+    primaryKeyColumn?: string;
+    /** Property name on entity to store brand array (defaults to 'brand') */
+    brandPropertyName?: string;
+}
+/**
+ * Base Repository class for TypeORM that AUTOMATICALLY applies brand filtering using junction tables.
+ *
+ * This extends TenantRepository and automatically uses junction tables for 10-100x faster queries
+ * compared to JSON_CONTAINS. No code changes needed in service layer - just configure once!
+ *
+ * Usage:
+ * ```typescript
+ * import { JunctionTableTenantRepository } from '@almatar/branding';
+ *
+ * export class RoleRepository extends JunctionTableTenantRepository<RoleEntity> {
+ *   constructor(@InjectRepository(RoleEntity) repository: Repository<RoleEntity>) {
+ *     super(repository.target, repository.manager, repository.queryRunner, {
+ *       junctionTableName: 'role_brands',
+ *       junctionTableAlias: 'rb',
+ *       foreignKeyColumn: 'role_id'
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * Brand filtering is automatically applied to ALL queries:
+ * - createQueryBuilder() - automatically adds junction table filter
+ * - find() - automatically filters by brand via junction table
+ * - findOne() - automatically filters by brand via junction table
+ * - findOneBy() - automatically filters by brand via junction table
+ * - findAndCount() - automatically filters by brand via junction table
+ *
+ * No need to call any methods - it just works automatically!
+ */
+export declare class JunctionTableTenantRepository<T extends ObjectLiteral> extends TenantRepository<T> {
+    protected readonly junctionTableConfig: IJunctionTableBrandConfig | null;
+    constructor(target: any, manager: any, queryRunner?: any, junctionTableConfig?: IJunctionTableBrandConfig);
+    /**
+     * Override createQueryBuilder to automatically apply junction table brand filtering
+     * Bypasses parent's JSON_CONTAINS filter since brand column doesn't exist (it's in junction tables)
+     * Also wraps getOne() and getMany() to automatically load brands from junction table
+     */
+    createQueryBuilder(alias?: string): SelectQueryBuilder<T>;
+    /**
+     * Apply brand filtering using junction table (automatic, no service code needed)
+     */
+    private applyJunctionTableBrandFilter;
+    /**
+     * Automatically load brand data from junction table for entities
+     * This is called automatically after fetching entities via query builder - no manual code needed!
+     */
+    private loadBrandsFromJunctionTable;
+}

package/lib/lib/TenantModel/TypeORM/JunctionTableTenantRepository.js

@@ -0,0 +1,140 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JunctionTableTenantRepository = void 0;
+const typeorm_1 = require("typeorm");
+const TenantRepository_1 = require("./TenantRepository");
+const JunctionTableBrandFilter_1 = require("../../JunctionTableBrandFilter");
+/**
+ * Base Repository class for TypeORM that AUTOMATICALLY applies brand filtering using junction tables.
+ *
+ * This extends TenantRepository and automatically uses junction tables for 10-100x faster queries
+ * compared to JSON_CONTAINS. No code changes needed in service layer - just configure once!
+ *
+ * Usage:
+ * ```typescript
+ * import { JunctionTableTenantRepository } from '@almatar/branding';
+ *
+ * export class RoleRepository extends JunctionTableTenantRepository<RoleEntity> {
+ *   constructor(@InjectRepository(RoleEntity) repository: Repository<RoleEntity>) {
+ *     super(repository.target, repository.manager, repository.queryRunner, {
+ *       junctionTableName: 'role_brands',
+ *       junctionTableAlias: 'rb',
+ *       foreignKeyColumn: 'role_id'
+ *     });
+ *   }
+ * }
+ * ```
+ *
+ * Brand filtering is automatically applied to ALL queries:
+ * - createQueryBuilder() - automatically adds junction table filter
+ * - find() - automatically filters by brand via junction table
+ * - findOne() - automatically filters by brand via junction table
+ * - findOneBy() - automatically filters by brand via junction table
+ * - findAndCount() - automatically filters by brand via junction table
+ *
+ * No need to call any methods - it just works automatically!
+ */
+class JunctionTableTenantRepository extends TenantRepository_1.TenantRepository {
+    constructor(target, manager, queryRunner, junctionTableConfig) {
+        super(target, manager, queryRunner);
+        this.junctionTableConfig = junctionTableConfig || null;
+    }
+    /**
+     * Override createQueryBuilder to automatically apply junction table brand filtering
+     * Bypasses parent's JSON_CONTAINS filter since brand column doesn't exist (it's in junction tables)
+     * Also wraps getOne() and getMany() to automatically load brands from junction table
+     */
+    createQueryBuilder(alias) {
+        // Call base TypeORM Repository.createQueryBuilder() directly to bypass parent's JSON_CONTAINS filter
+        // The parent's applyBrandFilter() uses JSON_CONTAINS on 'brand' column which doesn't exist anymore
+        const query = typeorm_1.Repository.prototype.createQueryBuilder.call(this, alias);
+        const tableAlias = alias || this.tableName;
+        // If junction table is configured, use it for fast filtering
+        if (this.junctionTableConfig) {
+            this.applyJunctionTableBrandFilter(query, tableAlias);
+        }
+        // Otherwise, no filtering (backward compatible - but junction table should always be configured)
+        // Wrap getOne() and getMany() to automatically load brands
+        if (this.junctionTableConfig) {
+            const originalGetOne = query.getOne.bind(query);
+            const originalGetMany = query.getMany.bind(query);
+            query.getOne = async () => {
+                const entity = await originalGetOne();
+                if (entity) {
+                    await this.loadBrandsFromJunctionTable([entity]);
+                }
+                return entity;
+            };
+            query.getMany = async () => {
+                const entities = await originalGetMany();
+                if (entities.length > 0) {
+                    await this.loadBrandsFromJunctionTable(entities);
+                }
+                return entities;
+            };
+        }
+        return query;
+    }
+    /**
+     * Apply brand filtering using junction table (automatic, no service code needed)
+     */
+    applyJunctionTableBrandFilter(query, tableAlias) {
+        if (!this.junctionTableConfig) {
+            return;
+        }
+        const { junctionTableName, junctionTableAlias, foreignKeyColumn, primaryKeyColumn = 'id', } = this.junctionTableConfig;
+        // Use the generic brand filter from JunctionTableBrandFilter
+        // This automatically gets brands from context (tenant scope)
+        JunctionTableBrandFilter_1.JunctionTableBrandFilter.applyGenericBrandFilter(query, {
+            junctionTableName,
+            junctionTableAlias,
+            foreignKeyColumn,
+            filterColumn: 'brand',
+            entityAlias: tableAlias,
+            primaryKeyColumn,
+        });
+    }
+    /**
+     * Automatically load brand data from junction table for entities
+     * This is called automatically after fetching entities via query builder - no manual code needed!
+     */
+    async loadBrandsFromJunctionTable(entities) {
+        if (!this.junctionTableConfig || entities.length === 0) {
+            return;
+        }
+        const { junctionTableName, foreignKeyColumn, primaryKeyColumn = 'id', brandPropertyName = 'brand', } = this.junctionTableConfig;
+        // Get all entity IDs
+        const entityIds = entities
+            .map((entity) => entity[primaryKeyColumn])
+            .filter((id) => id !== undefined && id !== null);
+        if (entityIds.length === 0) {
+            return;
+        }
+        // Load brands from junction table in a single query
+        const brandMappings = await this.manager
+            .createQueryBuilder()
+            .select(foreignKeyColumn, foreignKeyColumn)
+            .addSelect('brand', 'brand')
+            .from(junctionTableName, 'jt')
+            .where(`jt.${foreignKeyColumn} IN (:...entityIds)`, { entityIds })
+            .getRawMany();
+        // Group brands by entity ID
+        const brandsByEntityId = new Map();
+        brandMappings.forEach((mapping) => {
+            const entityId = mapping[foreignKeyColumn];
+            const brand = mapping.brand;
+            if (entityId && brand) {
+                if (!brandsByEntityId.has(entityId)) {
+                    brandsByEntityId.set(entityId, []);
+                }
+                brandsByEntityId.get(entityId).push(brand);
+            }
+        });
+        // Assign brands to entities
+        entities.forEach((entity) => {
+            const entityId = entity[primaryKeyColumn];
+            entity[brandPropertyName] = brandsByEntityId.get(entityId) || [];
+        });
+    }
+}
+exports.JunctionTableTenantRepository = JunctionTableTenantRepository;

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@almatar/branding",
-  "version": "1.0.0-beta.3.2",
+  "version": "1.0.0-beta.3.4",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
+  "type": "commonjs",
   "files": [
     "lib/**/*"
   ],