@almatar/branding 0.2.0 → 1.0.0-beta.3

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

@@ -0,0 +1,26 @@
+import { OnModuleInit } from '@nestjs/common';
+/**
+ * HTTP Interceptor that automatically adds x-brand and x-employee-brands headers
+ * to ALL outgoing HTTP requests, similar to holiday-consumer-service
+ *
+ * Usage in app.module.ts:
+ * ```typescript
+ * import { TenantHttpInterceptor } from '@almatar/branding';
+ * import { HttpModule } from '@nestjs/axios';
+ *
+ * @Module({
+ *   imports: [HttpModule],
+ *   providers: [
+ *     {
+ *       provide: APP_INTERCEPTOR,
+ *       useClass: TenantHttpInterceptor,
+ *     },
+ *   ],
+ * })
+ * ```
+ */
+export declare class TenantHttpInterceptor implements OnModuleInit {
+    private readonly httpService?;
+    constructor(httpService?: any);
+    onModuleInit(): void;
+}

package/lib/lib/TenantModel/TypeORM/TenantHttpInterceptor.js

@@ -0,0 +1,92 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantHttpInterceptor = void 0;
+const common_1 = require("@nestjs/common");
+const Storage_1 = __importDefault(require("../../Storage"));
+/**
+ * HTTP Interceptor that automatically adds x-brand and x-employee-brands headers
+ * to ALL outgoing HTTP requests, similar to holiday-consumer-service
+ *
+ * Usage in app.module.ts:
+ * ```typescript
+ * import { TenantHttpInterceptor } from '@almatar/branding';
+ * import { HttpModule } from '@nestjs/axios';
+ *
+ * @Module({
+ *   imports: [HttpModule],
+ *   providers: [
+ *     {
+ *       provide: APP_INTERCEPTOR,
+ *       useClass: TenantHttpInterceptor,
+ *     },
+ *   ],
+ * })
+ * ```
+ */
+let TenantHttpInterceptor = class TenantHttpInterceptor {
+    // Use any type to avoid requiring @nestjs/axios at compile time (it's a peer dependency)
+    // HttpService will be injected by NestJS when HttpModule is imported
+    // We use a factory function in app.module.ts to inject HttpService
+    constructor(httpService) {
+        this.httpService = httpService;
+    }
+    onModuleInit() {
+        // Intercept ALL axios requests and add brand headers automatically
+        // Checks both x-brand and x-employee-brands from context
+        // Try to get HttpService if not injected
+        let httpService = this.httpService;
+        if (!httpService) {
+            try {
+                // Dynamic require to avoid compile-time dependency
+                const axios = require('axios');
+                // Use axios directly if HttpService not available
+                httpService = { axiosRef: axios };
+            }
+            catch (e) {
+                // HttpService not available - skip interceptor setup
+                // tslint:disable-next-line no-console
+                console.warn('[TenantHttpInterceptor] HttpService not available, skipping axios interceptor setup');
+                return;
+            }
+        }
+        if (!httpService.axiosRef) {
+            // tslint:disable-next-line no-console
+            console.warn('[TenantHttpInterceptor] HttpService.axiosRef not available, skipping axios interceptor setup');
+            return;
+        }
+        httpService.axiosRef.interceptors.request.use((config) => {
+            const employeeBrands = Storage_1.default.getEmployeeBrands();
+            const brand = Storage_1.default.getBrand();
+            // Add x-employee-brands header (priority: employeeBrands > brand)
+            if (employeeBrands && employeeBrands.length > 0) {
+                config.headers = config.headers || {};
+                config.headers['x-employee-brands'] = employeeBrands.join(',');
+            }
+            else if (brand) {
+                config.headers = config.headers || {};
+                config.headers['x-employee-brands'] = brand;
+            }
+            // Add x-brand header (for backward compatibility)
+            if (brand) {
+                config.headers = config.headers || {};
+                config.headers['x-brand'] = brand;
+            }
+            return config;
+        }, (error) => {
+            return Promise.reject(error);
+        });
+    }
+};
+TenantHttpInterceptor = __decorate([
+    common_1.Injectable()
+], TenantHttpInterceptor);
+exports.TenantHttpInterceptor = TenantHttpInterceptor;

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

@@ -0,0 +1,58 @@
+import { Repository, SelectQueryBuilder, FindOptionsWhere, FindManyOptions, FindOneOptions, ObjectLiteral } from 'typeorm';
+/**
+ * Base Repository class for TypeORM that AUTOMATICALLY applies brand filtering to ALL queries
+ * Similar to TenantModel in PHP/MongoDB - just extend this class and everything works!
+ *
+ * Usage:
+ * ```typescript
+ * import { TenantRepository } from '@almatar/branding';
+ *
+ * export class EmployeeRepository extends TenantRepository<EmployeeEntity> {
+ *   constructor(@InjectRepository(EmployeeEntity) repository: Repository<EmployeeEntity>) {
+ *     super(repository.target, repository.manager, repository.queryRunner);
+ *   }
+ * }
+ * ```
+ *
+ * Brand filtering is automatically applied to:
+ * - createQueryBuilder() - automatically adds brand filter
+ * - find() - automatically filters by brand
+ * - findOne() - automatically filters by brand
+ * - findOneBy() - automatically filters by brand
+ * - findAndCount() - automatically filters by brand
+ */
+export declare class TenantRepository<T extends ObjectLiteral> extends Repository<T> {
+    protected readonly brandColumn: string;
+    protected readonly tableName: string;
+    constructor(target: any, manager: any, queryRunner?: any);
+    /**
+     * Override createQueryBuilder to automatically apply brand filtering
+     */
+    createQueryBuilder(alias?: string): SelectQueryBuilder<T>;
+    /**
+     * Override find to automatically apply brand filtering
+     */
+    find(options?: FindManyOptions<T>): Promise<T[]>;
+    /**
+     * Override findOne to automatically apply brand filtering
+     */
+    findOne(options?: FindOneOptions<T>): Promise<T | null>;
+    /**
+     * Override findOneBy to automatically apply brand filtering
+     */
+    findOneBy(where: FindOptionsWhere<T> | FindOptionsWhere<T>[]): Promise<T | null>;
+    /**
+     * Override findAndCount to automatically apply brand filtering
+     */
+    findAndCount(options?: FindManyOptions<T>): Promise<[T[], number]>;
+    /**
+     * Get brands from context (from token/headers)
+     */
+    private getBrandsFromContext;
+    /**
+     * Apply brand filter to query builder
+     * Handles both cases: brand as JSON array and brand as string
+     * Uses $in equivalent for multiple brands from x-employee-brands
+     */
+    private applyBrandFilter;
+}

package/lib/lib/TenantModel/TypeORM/TenantRepository.js

@@ -0,0 +1,281 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TenantRepository = void 0;
+const typeorm_1 = require("typeorm");
+const Storage_1 = __importDefault(require("../../Storage"));
+/**
+ * Base Repository class for TypeORM that AUTOMATICALLY applies brand filtering to ALL queries
+ * Similar to TenantModel in PHP/MongoDB - just extend this class and everything works!
+ *
+ * Usage:
+ * ```typescript
+ * import { TenantRepository } from '@almatar/branding';
+ *
+ * export class EmployeeRepository extends TenantRepository<EmployeeEntity> {
+ *   constructor(@InjectRepository(EmployeeEntity) repository: Repository<EmployeeEntity>) {
+ *     super(repository.target, repository.manager, repository.queryRunner);
+ *   }
+ * }
+ * ```
+ *
+ * Brand filtering is automatically applied to:
+ * - createQueryBuilder() - automatically adds brand filter
+ * - find() - automatically filters by brand
+ * - findOne() - automatically filters by brand
+ * - findOneBy() - automatically filters by brand
+ * - findAndCount() - automatically filters by brand
+ */
+class TenantRepository extends typeorm_1.Repository {
+    constructor(target, manager, queryRunner) {
+        super(target, manager, queryRunner);
+        this.brandColumn = 'brand';
+        // Get table name from metadata
+        this.tableName = this.metadata.tableName;
+    }
+    /**
+     * Override createQueryBuilder to automatically apply brand filtering
+     */
+    createQueryBuilder(alias) {
+        const query = super.createQueryBuilder(alias);
+        const tableAlias = alias || this.tableName;
+        // Automatically apply brand filter
+        return this.applyBrandFilter(query, tableAlias);
+    }
+    /**
+     * Override find to automatically apply brand filtering
+     */
+    async find(options) {
+        const brands = this.getBrandsFromContext();
+        if (brands && brands.length > 0) {
+            // Use query builder to support JSON_CONTAINS
+            const alias = this.tableName;
+            let query = this.createQueryBuilder(alias);
+            // Apply existing where conditions
+            if (options === null || options === void 0 ? void 0 : options.where) {
+                if (Array.isArray(options.where)) {
+                    options.where.forEach((where, index) => {
+                        Object.keys(where).forEach(key => {
+                            query = query.andWhere(`${alias}.${key} = :${key}_${index}`, { [`${key}_${index}`]: where[key] });
+                        });
+                    });
+                }
+                else {
+                    Object.keys(options.where).forEach(key => {
+                        query = query.andWhere(`${alias}.${key} = :${key}`, { [key]: options.where[key] });
+                    });
+                }
+            }
+            // Apply relations
+            if (options === null || options === void 0 ? void 0 : options.relations) {
+                const relations = Array.isArray(options.relations)
+                    ? options.relations
+                    : Object.keys(options.relations).filter(key => options.relations[key]);
+                relations.forEach((relation) => {
+                    query = query.leftJoinAndSelect(`${alias}.${relation}`, relation);
+                });
+            }
+            // Apply select
+            if (options === null || options === void 0 ? void 0 : options.select) {
+                const selectCols = Array.isArray(options.select)
+                    ? options.select
+                    : Object.keys(options.select).filter(key => options.select[key]);
+                const selectPaths = selectCols.map((col) => `${alias}.${String(col)}`);
+                query = query.select(selectPaths);
+            }
+            // Apply order
+            if (options === null || options === void 0 ? void 0 : options.order) {
+                if (typeof options.order === 'object' && !Array.isArray(options.order)) {
+                    Object.keys(options.order).forEach(key => {
+                        const orderValue = options.order[key];
+                        if (orderValue) {
+                            query = query.orderBy(`${alias}.${key}`, orderValue);
+                        }
+                    });
+                }
+            }
+            // Apply skip/take
+            if (options === null || options === void 0 ? void 0 : options.skip) {
+                query = query.skip(options.skip);
+            }
+            if (options === null || options === void 0 ? void 0 : options.take) {
+                query = query.take(options.take);
+            }
+            return query.getMany();
+        }
+        return super.find(options);
+    }
+    /**
+     * Override findOne to automatically apply brand filtering
+     */
+    async findOne(options) {
+        const brands = this.getBrandsFromContext();
+        if (brands && brands.length > 0) {
+            const alias = this.tableName;
+            let query = this.createQueryBuilder(alias);
+            if (options === null || options === void 0 ? void 0 : options.where) {
+                if (Array.isArray(options.where)) {
+                    options.where.forEach((where, index) => {
+                        Object.keys(where).forEach(key => {
+                            query = query.andWhere(`${alias}.${key} = :${key}_${index}`, { [`${key}_${index}`]: where[key] });
+                        });
+                    });
+                }
+                else {
+                    Object.keys(options.where).forEach(key => {
+                        query = query.andWhere(`${alias}.${key} = :${key}`, { [key]: options.where[key] });
+                    });
+                }
+            }
+            if (options === null || options === void 0 ? void 0 : options.relations) {
+                const relations = Array.isArray(options.relations)
+                    ? options.relations
+                    : Object.keys(options.relations).filter(key => options.relations[key]);
+                relations.forEach((relation) => {
+                    query = query.leftJoinAndSelect(`${alias}.${relation}`, relation);
+                });
+            }
+            if (options === null || options === void 0 ? void 0 : options.select) {
+                const selectCols = Array.isArray(options.select)
+                    ? options.select
+                    : Object.keys(options.select).filter(key => options.select[key]);
+                const selectPaths = selectCols.map((col) => `${alias}.${String(col)}`);
+                query = query.select(selectPaths);
+            }
+            if (options === null || options === void 0 ? void 0 : options.order) {
+                if (typeof options.order === 'object' && !Array.isArray(options.order)) {
+                    Object.keys(options.order).forEach(key => {
+                        const orderValue = options.order[key];
+                        if (orderValue) {
+                            query = query.orderBy(`${alias}.${key}`, orderValue);
+                        }
+                    });
+                }
+            }
+            return query.getOne();
+        }
+        return super.findOne(options || {});
+    }
+    /**
+     * Override findOneBy to automatically apply brand filtering
+     */
+    async findOneBy(where) {
+        const brands = this.getBrandsFromContext();
+        if (brands && brands.length > 0) {
+            const alias = this.tableName;
+            let query = this.createQueryBuilder(alias);
+            if (Array.isArray(where)) {
+                where.forEach((w, index) => {
+                    Object.keys(w).forEach(key => {
+                        query = query.andWhere(`${alias}.${key} = :${key}_${index}`, { [`${key}_${index}`]: w[key] });
+                    });
+                });
+            }
+            else {
+                Object.keys(where).forEach(key => {
+                    query = query.andWhere(`${alias}.${key} = :${key}`, { [key]: where[key] });
+                });
+            }
+            return query.getOne();
+        }
+        return super.findOneBy(where);
+    }
+    /**
+     * Override findAndCount to automatically apply brand filtering
+     */
+    async findAndCount(options) {
+        const brands = this.getBrandsFromContext();
+        if (brands && brands.length > 0) {
+            const alias = this.tableName;
+            let query = this.createQueryBuilder(alias);
+            if (options === null || options === void 0 ? void 0 : options.where) {
+                if (Array.isArray(options.where)) {
+                    options.where.forEach((where, index) => {
+                        Object.keys(where).forEach(key => {
+                            query = query.andWhere(`${alias}.${key} = :${key}_${index}`, { [`${key}_${index}`]: where[key] });
+                        });
+                    });
+                }
+                else {
+                    Object.keys(options.where).forEach(key => {
+                        query = query.andWhere(`${alias}.${key} = :${key}`, { [key]: options.where[key] });
+                    });
+                }
+            }
+            if (options === null || options === void 0 ? void 0 : options.relations) {
+                const relations = Array.isArray(options.relations)
+                    ? options.relations
+                    : Object.keys(options.relations).filter(key => options.relations[key]);
+                relations.forEach((relation) => {
+                    query = query.leftJoinAndSelect(`${alias}.${relation}`, relation);
+                });
+            }
+            if (options === null || options === void 0 ? void 0 : options.select) {
+                const selectCols = Array.isArray(options.select)
+                    ? options.select
+                    : Object.keys(options.select).filter(key => options.select[key]);
+                const selectPaths = selectCols.map((col) => `${alias}.${String(col)}`);
+                query = query.select(selectPaths);
+            }
+            if (options === null || options === void 0 ? void 0 : options.order) {
+                if (typeof options.order === 'object' && !Array.isArray(options.order)) {
+                    Object.keys(options.order).forEach(key => {
+                        const orderValue = options.order[key];
+                        if (orderValue) {
+                            query = query.orderBy(`${alias}.${key}`, orderValue);
+                        }
+                    });
+                }
+            }
+            if (options === null || options === void 0 ? void 0 : options.skip) {
+                query = query.skip(options.skip);
+            }
+            if (options === null || options === void 0 ? void 0 : options.take) {
+                query = query.take(options.take);
+            }
+            return query.getManyAndCount();
+        }
+        return super.findAndCount(options);
+    }
+    /**
+     * Get brands from context (from token/headers)
+     */
+    getBrandsFromContext() {
+        const contextEmployeeBrands = Storage_1.default.getEmployeeBrands();
+        const contextBrand = Storage_1.default.getBrand();
+        return contextEmployeeBrands || (contextBrand ? [contextBrand] : null);
+    }
+    /**
+     * Apply brand filter to query builder
+     * Handles both cases: brand as JSON array and brand as string
+     * Uses $in equivalent for multiple brands from x-employee-brands
+     */
+    applyBrandFilter(query, tableAlias) {
+        const brands = this.getBrandsFromContext();
+        if (brands && brands.length > 0) {
+            // Handle both cases for multiple brands (x-employee-brands can have many):
+            // 1. Brand column is JSON array: Check if ANY of the user's brands exist in the entity's brand array
+            //    Using JSON_CONTAINS for each brand (equivalent to $in for arrays)
+            // 2. Brand column is string: Check if entity's brand is IN the user's brands array
+            //    Using IN clause (equivalent to $in for strings)
+            // For JSON array: Check if any user brand is contained in entity's brand array
+            const jsonArrayConditions = brands.map((brandItem, index) => {
+                return `JSON_CONTAINS(${tableAlias}.${this.brandColumn}, :brand${index})`;
+            }).join(' OR ');
+            // For string: Check if entity's brand is in user's brands (IN clause)
+            const stringInPlaceholders = brands.map((brandItem, index) => `:brandStr${index}`).join(', ');
+            // Combine both conditions: (JSON array match) OR (string IN match)
+            const brandConditions = `(${jsonArrayConditions}) OR (${tableAlias}.${this.brandColumn} IN (${stringInPlaceholders}))`;
+            const brandParams = {};
+            brands.forEach((brand, index) => {
+                brandParams[`brand${index}`] = JSON.stringify(brand);
+                brandParams[`brandStr${index}`] = brand;
+            });
+            query.andWhere(`(${brandConditions})`, brandParams);
+        }
+        return query;
+    }
+}
+exports.TenantRepository = TenantRepository;

package/lib/lib/request/PromiseRequest.js

@@ -1,61 +1,42 @@
 "use strict";
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PromiseRequest = void 0;
-var request = require("request");
-var PromiseRequest = /** @class */ (function () {
-    function PromiseRequest() {
-    }
-    PromiseRequest.request = function (options) {
-        return __awaiter(this, void 0, void 0, function () {
-            return __generator(this, function (_a) {
-                return [2 /*return*/, new Promise(function (resolve, reject) {
-                        request(options, function (err, response, body) {
-                            if (err) {
-                                reject(err);
-                            }
-                            body = body ? JSON.parse(body) : null;
-                            resolve(body);
-                        });
-                    })];
+class PromiseRequest {
+    static async request(options) {
+        try {
+            const url = options.url || options.uri;
+            const method = options.method || 'GET';
+            const headers = options.headers || {};
+            const body = options.body ? JSON.stringify(options.body) : undefined;
+            // tslint:disable-next-line no-console
+            console.log('[PromiseRequest] Making request:', { url, method, headers: Object.assign(Object.assign({}, headers), { authorization: headers.authorization ? 'Bearer ***' : undefined }) });
+            const response = await fetch(url, {
+                method,
+                headers: Object.assign({ 'Content-Type': 'application/json' }, headers),
+                body,
             });
-        });
-    };
-    return PromiseRequest;
-}());
+            const responseData = await response.text();
+            let parsedBody;
+            try {
+                parsedBody = responseData ? JSON.parse(responseData) : null;
+            }
+            catch (parseError) {
+                // tslint:disable-next-line no-console
+                console.log('[PromiseRequest] Failed to parse response as JSON:', parseError);
+                parsedBody = responseData;
+            }
+            // Return in the same format as the old request library
+            return {
+                status: response.status,
+                data: parsedBody,
+                body: parsedBody,
+            };
+        }
+        catch (err) {
+            // tslint:disable-next-line no-console
+            console.log('[PromiseRequest] Request error:', err);
+            throw err;
+        }
+    }
+}
 exports.PromiseRequest = PromiseRequest;

package/lib/lib/request/TenantRequest.d.ts

@@ -1,4 +1,7 @@
 declare class TenantRequest {
-    static request(options: any): Promise<any>;
+    static request(options: any): Promise<{
+        status: number;
+        data: any;
+    } | null>;
 }
 export default TenantRequest;