@almatar/branding 0.2.0 → 1.0.0-beta.3

package/lib/lib/Storage.js

@@ -1,181 +1,108 @@
 "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 });
-var BrandIdentifier_1 = require("./BrandIdentifier");
-var createNamespace = require('cls-hooked').createNamespace;
-var namespaceName = 'request';
-var ns = createNamespace(namespaceName);
-var ContextNamespace = /** @class */ (function () {
-    function ContextNamespace() {
-    }
+const BrandIdentifier_1 = require("./BrandIdentifier");
+const createNamespace = require('cls-hooked').createNamespace;
+const namespaceName = 'request';
+const ns = createNamespace(namespaceName);
+class ContextNamespace {
     /* Express Start */
-    ContextNamespace.bindENamespace = function (req, res, next) {
-        var _this = this;
+    static bindENamespace(req, res, next) {
         ns.bindEmitter(req);
         ns.bindEmitter(res);
-        ns.run(function () { return __awaiter(_this, void 0, void 0, function () {
-            var brandIdentifier;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        brandIdentifier = new BrandIdentifier_1.BrandIdentifier('express');
-                        return [4 /*yield*/, brandIdentifier.getBrands()];
-                    case 1:
-                        _a.sent();
-                        next();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    };
-    ContextNamespace.setEBrand = function (req, res, next) {
-        return __awaiter(this, void 0, void 0, function () {
-            var brandIdentifier, brand;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        brandIdentifier = new BrandIdentifier_1.BrandIdentifier('express');
-                        return [4 /*yield*/, brandIdentifier.getBrand(req)];
-                    case 1:
-                        brand = _a.sent();
-                        if (Array.isArray(brand)) {
-                            ns.set('employeeBrands', brand);
-                            next();
-                        }
-                        else if (typeof brand === 'string') {
-                            ns.set('brand', brand);
-                            next();
-                        }
-                        else {
-                            next(brand);
-                        }
-                        return [2 /*return*/];
-                }
-            });
+        ns.run(async () => {
+            const brandIdentifier = new BrandIdentifier_1.BrandIdentifier('express');
+            await brandIdentifier.getBrands();
+            next();
         });
-    };
+    }
+    static async setEBrand(req, res, next) {
+        const brandIdentifier = new BrandIdentifier_1.BrandIdentifier('express');
+        const brand = await brandIdentifier.getBrand(req);
+        if (Array.isArray(brand)) {
+            // tslint:disable-next-line no-console
+            console.log('[ContextNamespace] Setting employeeBrands in context:', brand);
+            ns.set('employeeBrands', brand);
+            next();
+        }
+        else if (typeof brand === 'string') {
+            // tslint:disable-next-line no-console
+            console.log('[ContextNamespace] Setting brand in context:', brand);
+            ns.set('brand', brand);
+            next();
+        }
+        else {
+            // Brand is null or undefined - set empty array for employeeBrands
+            // tslint:disable-next-line no-console
+            console.log('[ContextNamespace] No brand found, setting empty array for employeeBrands');
+            ns.set('employeeBrands', []);
+            next();
+        }
+    }
     /* Express End */
     /* Hapi Start */
-    ContextNamespace.bindHNamespace = function (req, reply) {
-        var _this = this;
+    static bindHNamespace(req, reply) {
         ns.bindEmitter(req.raw.req);
         ns.bindEmitter(req.raw.res);
-        ns.run(function () { return __awaiter(_this, void 0, void 0, function () {
-            var brandIdentifier;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        brandIdentifier = new BrandIdentifier_1.BrandIdentifier('hapi');
-                        return [4 /*yield*/, brandIdentifier.getBrands()];
-                    case 1:
-                        _a.sent();
-                        reply();
-                        return [2 /*return*/];
-                }
-            });
-        }); });
-    };
-    ContextNamespace.setHBrand = function (req, reply) {
-        return __awaiter(this, void 0, void 0, function () {
-            var brandIdentifier, brand;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
-                    case 0:
-                        brandIdentifier = new BrandIdentifier_1.BrandIdentifier('hapi');
-                        return [4 /*yield*/, brandIdentifier.getBrand(req)];
-                    case 1:
-                        brand = _a.sent();
-                        if (Array.isArray(brand)) {
-                            ns.set('employeeBrands', brand);
-                            reply();
-                        }
-                        else if (typeof brand === 'string') {
-                            ns.set('brand', brand);
-                            reply();
-                        }
-                        else {
-                            reply(brand);
-                        }
-                        return [2 /*return*/];
-                }
-            });
+        ns.run(async () => {
+            const brandIdentifier = new BrandIdentifier_1.BrandIdentifier('hapi');
+            await brandIdentifier.getBrands();
+            reply();
         });
-    };
+    }
+    static async setHBrand(req, reply) {
+        const brandIdentifier = new BrandIdentifier_1.BrandIdentifier('hapi');
+        const brand = await brandIdentifier.getBrand(req);
+        if (Array.isArray(brand)) {
+            ns.set('employeeBrands', brand);
+            reply();
+        }
+        else if (typeof brand === 'string') {
+            ns.set('brand', brand);
+            reply();
+        }
+        else {
+            reply(brand);
+        }
+    }
     /* Hapi End */
-    ContextNamespace.setBrand = function (brand) {
+    static setBrand(brand) {
         if (Array.isArray(brand)) {
             return ns.set('employeeBrands', brand);
         }
         else {
             return ns.set('brand', brand);
         }
-    };
-    ContextNamespace.getBrand = function () {
+    }
+    static getBrand() {
         return ns.get('brand');
-    };
-    ContextNamespace.getEmployeeBrands = function () {
+    }
+    static getEmployeeBrands() {
         return ns.get('employeeBrands');
-    };
-    ContextNamespace.getNamespace = function () {
+    }
+    static getNamespace() {
         return ns;
-    };
-    ContextNamespace.setBrandsList = function (brandList) {
+    }
+    static setBrandsList(brandList) {
         return ns.set('brandsList', brandList);
-    };
-    ContextNamespace.setBrands = function (brands) {
+    }
+    static setBrands(brands) {
         return ns.set('brands', brands);
-    };
-    ContextNamespace.getBrands = function () {
+    }
+    static getBrands() {
         return ns.get('brands');
-    };
-    ContextNamespace.getDefaultBrand = function () {
-        var brandIdentifier = new BrandIdentifier_1.BrandIdentifier('hapi');
+    }
+    static getDefaultBrand() {
+        const brandIdentifier = new BrandIdentifier_1.BrandIdentifier('hapi');
         return brandIdentifier.getDefaultBrand();
-    };
-    ContextNamespace.isValidBrand = function (brand) {
+    }
+    static isValidBrand(brand) {
         var _a;
         return (_a = ns.get('brands')) === null || _a === void 0 ? void 0 : _a.includes(brand);
-    };
-    ContextNamespace.isBrandIncludesProduct = function (brandKey, product) {
+    }
+    static isBrandIncludesProduct(brandKey, product) {
         var _a, _b;
-        var brand = (_a = ns.get('brandsList')) === null || _a === void 0 ? void 0 : _a.filter(function (b) { return b.key === brandKey; })[0];
+        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);
-    };
-    return ContextNamespace;
-}());
+    }
+}
 exports.default = ContextNamespace;

package/lib/lib/TenantModel/Mongoose/MultiTenant.js

@@ -1,24 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-var MongooseModel_1 = require("../MongooseModel");
-var MultiTenant = /** @class */ (function () {
-    function MultiTenant(mongoose) {
+const MongooseModel_1 = require("../MongooseModel");
+class MultiTenant {
+    constructor(mongoose) {
         this.mongoose = mongoose;
         this.models = {};
     }
-    MultiTenant.prototype.tenantModel = function (name, schema, options) {
-        var _this = this;
-        return function (props) {
-            if (props === void 0) { props = {}; }
-            var skipBrand = props.skipBrand;
-            var mongooseModel = new MongooseModel_1.MongooseModel(_this.mongoose);
-            return mongooseModel.createModel(name, schema, options, _this.models, skipBrand);
+    tenantModel(name, schema, options) {
+        return (props = {}) => {
+            const { skipBrand } = props;
+            const mongooseModel = new MongooseModel_1.MongooseModel(this.mongoose);
+            return mongooseModel.createModel(name, schema, options, this.models, skipBrand);
         };
-    };
-    MultiTenant.prototype.tenantlessModel = function (name, schema, options) {
-        var _this = this;
-        return function () { return _this.mongoose.model(name, schema, options); };
-    };
-    return MultiTenant;
-}());
+    }
+    tenantlessModel(name, schema, options) {
+        return () => this.mongoose.model(name, schema, options);
+    }
+}
 exports.default = MultiTenant;

package/lib/lib/TenantModel/MongooseModel.js

@@ -1,40 +1,52 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongooseModel = void 0;
-var Storage_1 = require("../Storage");
-var MongooseModel = /** @class */ (function () {
-    function MongooseModel(mongoose) {
+const Storage_1 = __importDefault(require("../Storage"));
+class MongooseModel {
+    constructor(mongoose) {
         this.mongoose = mongoose;
     }
-    MongooseModel.prototype.createModel = function (name, schema, options, existingModels, skipBrand) {
-        var brands = [];
+    createModel(name, schema, options, existingModels, skipBrand) {
+        let brands = [];
         if (!skipBrand) {
-            brands = Storage_1.default.getEmployeeBrands()
-                ? Storage_1.default.getEmployeeBrands()
-                : [Storage_1.default.getBrand()];
+            // Check both x-employee-brands and x-brand from context
+            const employeeBrands = Storage_1.default.getEmployeeBrands();
+            const brand = Storage_1.default.getBrand();
+            brands = employeeBrands && employeeBrands.length > 0
+                ? employeeBrands
+                : (brand ? [brand] : []);
             schema.add({ brand: String });
             this.addPreReadQueries(schema);
             this.addPreAggregateQueries(schema);
             this.addPreSaveQueries(schema);
             this.addPreInsertManyQueries(schema);
         }
-        var modelName = skipBrand || !Array.isArray(brands) ? name : "".concat(name, "-").concat(brands.join('-'));
+        const modelName = skipBrand || !Array.isArray(brands) ? name : `${name}-${brands.join('-')}`;
         if (!existingModels[modelName]) {
             existingModels[modelName] = this.mongoose.model(modelName, schema, options);
         }
         return existingModels[modelName];
-    };
-    MongooseModel.prototype.addPreCondition = function (next) {
-        var brands = Storage_1.default.getEmployeeBrands()
-            ? Storage_1.default.getEmployeeBrands()
-            : [Storage_1.default.getBrand()];
-        if (Array.isArray(brands)) {
+    }
+    addPreCondition(next) {
+        // Check both x-employee-brands and x-brand from context
+        // x-employee-brands can contain multiple brands (comma-separated), so use $in
+        const employeeBrands = Storage_1.default.getEmployeeBrands();
+        const brand = Storage_1.default.getBrand();
+        const brands = employeeBrands && employeeBrands.length > 0
+            ? employeeBrands
+            : (brand ? [brand] : []);
+        if (Array.isArray(brands) && brands.length > 0) {
+            // Use $in to check if entity's brand (string or array element) is in the user's brands array
+            // This handles both: brand as string and brand as array element
             // @ts-ignore
             this.where({ brand: { $in: brands } });
         }
         next();
-    };
-    MongooseModel.prototype.addPreReadQueries = function (schema) {
+    }
+    addPreReadQueries(schema) {
         schema.pre('count', this.addPreCondition);
         schema.pre('find', this.addPreCondition);
         schema.pre('findOne', this.addPreCondition);
@@ -47,44 +59,49 @@ var MongooseModel = /** @class */ (function () {
         schema.pre('deleteMany', this.addPreCondition);
         schema.pre('deleteOne', this.addPreCondition);
         schema.pre('remove', this.addPreCondition);
-    };
-    MongooseModel.prototype.addPreAggregate = function (next) {
-        var brands = Storage_1.default.getEmployeeBrands()
-            ? Storage_1.default.getEmployeeBrands()
-            : [Storage_1.default.getBrand()];
-        if (Array.isArray(brands)) {
+    }
+    addPreAggregate(next) {
+        // Check both x-employee-brands and x-brand from context
+        // x-employee-brands can contain multiple brands (comma-separated), so use $in
+        const employeeBrands = Storage_1.default.getEmployeeBrands();
+        const brand = Storage_1.default.getBrand();
+        const brands = employeeBrands && employeeBrands.length > 0
+            ? employeeBrands
+            : (brand ? [brand] : []);
+        if (Array.isArray(brands) && brands.length > 0) {
+            // Use $in to check if entity's brand (string or array element) is in the user's brands array
+            // This handles both: brand as string and brand as array element
             // @ts-ignore
             this.pipeline().unshift({ $match: { brand: { $in: brands } } });
         }
         next();
-    };
-    MongooseModel.prototype.addPreAggregateQueries = function (schema) {
+    }
+    addPreAggregateQueries(schema) {
         schema.pre('aggregate', this.addPreAggregate);
-    };
-    MongooseModel.prototype.addPreSave = function (next) {
-        var brand = Storage_1.default.getBrand();
+    }
+    addPreSave(next) {
+        const brand = Storage_1.default.getBrand();
         // @ts-ignore
         if (!this.brand && brand) {
             // @ts-ignore
             this.brand = brand;
         }
         next();
-    };
-    MongooseModel.prototype.addPreSaveQueries = function (schema) {
+    }
+    addPreSaveQueries(schema) {
         schema.pre('save', this.addPreSave);
-    };
-    MongooseModel.prototype.addPreInsertMany = function (next, dataArray) {
-        var brand = Storage_1.default.getBrand();
-        dataArray.forEach(function (data) {
+    }
+    addPreInsertMany(next, dataArray) {
+        const brand = Storage_1.default.getBrand();
+        dataArray.forEach((data) => {
             if (!data.tanentId && brand) {
                 data.brand = brand;
             }
         });
         next();
-    };
-    MongooseModel.prototype.addPreInsertManyQueries = function (schema) {
+    }
+    addPreInsertManyQueries(schema) {
         schema.pre('insertMany', this.addPreInsertMany);
-    };
-    return MongooseModel;
-}());
+    }
+}
 exports.MongooseModel = MongooseModel;

package/lib/lib/TenantModel/NestMongoose/TenantMongooseModule.js

@@ -1,19 +1,4 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 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);
@@ -21,27 +6,21 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-var common_1 = require("@nestjs/common");
-var mongoose_1 = require("@nestjs/mongoose");
-var mongoose_providers_1 = require("./mongoose.providers");
-var TenantMongooseModule = /** @class */ (function (_super) {
-    __extends(TenantMongooseModule, _super);
-    function TenantMongooseModule() {
-        return _super !== null && _super.apply(this, arguments) || this;
-    }
-    TenantMongooseModule.forFeature = function (models, connectionName) {
-        if (models === void 0) { models = []; }
-        connectionName = connectionName ? "".concat(connectionName, "Connection") : 'MongooseConnectionName';
-        var modelProviders = (0, mongoose_providers_1.createMongooseProviders)(connectionName, models);
+const common_1 = require("@nestjs/common");
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_providers_1 = require("./mongoose.providers");
+let TenantMongooseModule = class TenantMongooseModule extends mongoose_1.MongooseModule {
+    static forFeature(models = [], connectionName) {
+        connectionName = connectionName ? `${connectionName}Connection` : 'MongooseConnectionName';
+        const modelProviders = mongoose_providers_1.createMongooseProviders(connectionName, models);
         return {
             module: mongoose_1.MongooseModule,
             providers: modelProviders,
             exports: modelProviders,
         };
-    };
-    TenantMongooseModule = __decorate([
-        (0, common_1.Module)({})
-    ], TenantMongooseModule);
-    return TenantMongooseModule;
-}(mongoose_1.MongooseModule));
+    }
+};
+TenantMongooseModule = __decorate([
+    common_1.Module({})
+], TenantMongooseModule);
 exports.default = TenantMongooseModule;

package/lib/lib/TenantModel/NestMongoose/mongoose.providers.d.ts

@@ -1,27 +1,3 @@
-/// <reference types="mongoose/types/aggregate" />
-/// <reference types="mongoose/types/callback" />
-/// <reference types="mongoose/types/collection" />
-/// <reference types="mongoose/types/connection" />
-/// <reference types="mongoose/types/cursor" />
-/// <reference types="mongoose/types/document" />
-/// <reference types="mongoose/types/error" />
-/// <reference types="mongoose/types/expressions" />
-/// <reference types="mongoose/types/helpers" />
-/// <reference types="mongoose/types/middlewares" />
-/// <reference types="mongoose/types/indexes" />
-/// <reference types="mongoose/types/models" />
-/// <reference types="mongoose/types/mongooseoptions" />
-/// <reference types="mongoose/types/pipelinestage" />
-/// <reference types="mongoose/types/populate" />
-/// <reference types="mongoose/types/query" />
-/// <reference types="mongoose/types/schemaoptions" />
-/// <reference types="mongoose/types/schematypes" />
-/// <reference types="mongoose/types/session" />
-/// <reference types="mongoose/types/types" />
-/// <reference types="mongoose/types/utility" />
-/// <reference types="mongoose/types/validation" />
-/// <reference types="mongoose/types/virtuals" />
-/// <reference types="mongoose/types/inferschematype" />
 import { Connection, Schema } from 'mongoose';
 export declare function createMongooseProviders(connectionName?: string, models?: {
     name: string;

package/lib/lib/TenantModel/NestMongoose/mongoose.providers.js

@@ -1,17 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createMongooseProviders = void 0;
-var MongooseModel_1 = require("../MongooseModel");
-function createMongooseProviders(connectionName, models) {
-    if (models === void 0) { models = []; }
-    var providers = (models || []).map(function (model) { return ({
-        provide: "".concat(model.name, "Model"),
-        useFactory: function (connection) {
-            var mongooseModel = new MongooseModel_1.MongooseModel(connection);
+const MongooseModel_1 = require("../MongooseModel");
+function createMongooseProviders(connectionName, models = []) {
+    const providers = (models || []).map(model => ({
+        provide: `${model.name}Model`,
+        useFactory: (connection) => {
+            const mongooseModel = new MongooseModel_1.MongooseModel(connection);
             return mongooseModel.createModel(model.name, model.schema, model.collection, {});
         },
-        inject: ["".concat(connectionName, "Connection")],
-    }); });
+        inject: [`${connectionName}Connection`],
+    }));
     return providers;
 }
 exports.createMongooseProviders = createMongooseProviders;

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

@@ -0,0 +1,27 @@
+import { EntitySubscriberInterface, InsertEvent, LoadEvent } from 'typeorm';
+/**
+ * TypeORM EntitySubscriber that automatically handles brand in all entities
+ * Similar to TenantModel in PHP/MongoDB - automatically adds brand on insert
+ *
+ * Register this subscriber in your DataSource options:
+ * ```typescript
+ * import { TenantEntitySubscriber } from '@almatar/branding';
+ *
+ * export const dataSourceOptions: DataSourceOptions = {
+ *   // ... other options
+ *   subscribers: [TenantEntitySubscriber],
+ * };
+ * ```
+ */
+export declare class TenantEntitySubscriber implements EntitySubscriberInterface {
+    /**
+     * Called before an entity is inserted
+     * Automatically adds brand from context if not provided
+     */
+    beforeInsert(event: InsertEvent<any>): void | Promise<any>;
+    /**
+     * Called after an entity is loaded from the database
+     * Validates that loaded entities match brand context (for debugging)
+     */
+    afterLoad(entity: any, event: LoadEvent<any>): void | Promise<any>;
+}

package/lib/lib/TenantModel/TypeORM/TenantEntitySubscriber.js

@@ -0,0 +1,68 @@
+"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.TenantEntitySubscriber = void 0;
+const typeorm_1 = require("typeorm");
+const Storage_1 = __importDefault(require("../../Storage"));
+/**
+ * TypeORM EntitySubscriber that automatically handles brand in all entities
+ * Similar to TenantModel in PHP/MongoDB - automatically adds brand on insert
+ *
+ * Register this subscriber in your DataSource options:
+ * ```typescript
+ * import { TenantEntitySubscriber } from '@almatar/branding';
+ *
+ * export const dataSourceOptions: DataSourceOptions = {
+ *   // ... other options
+ *   subscribers: [TenantEntitySubscriber],
+ * };
+ * ```
+ */
+let TenantEntitySubscriber = class TenantEntitySubscriber {
+    /**
+     * Called before an entity is inserted
+     * Automatically adds brand from context if not provided
+     */
+    beforeInsert(event) {
+        const employeeBrands = Storage_1.default.getEmployeeBrands();
+        const brand = Storage_1.default.getBrand();
+        const contextBrands = employeeBrands || (brand ? [brand] : null);
+        // Only apply if entity has brand column and brand is not already set
+        if (event.metadata.columns.find((col) => col.propertyName === 'brand')) {
+            if (contextBrands && contextBrands.length > 0 && !event.entity.brand) {
+                event.entity.brand = contextBrands;
+            }
+        }
+    }
+    /**
+     * Called after an entity is loaded from the database
+     * Validates that loaded entities match brand context (for debugging)
+     */
+    afterLoad(entity, event) {
+        const employeeBrands = Storage_1.default.getEmployeeBrands();
+        const brand = Storage_1.default.getBrand();
+        const contextBrands = employeeBrands || (brand ? [brand] : null);
+        if (contextBrands && contextBrands.length > 0 && entity.brand) {
+            const entityBrands = Array.isArray(entity.brand) ? entity.brand : [entity.brand];
+            const hasMatchingBrand = contextBrands.some((b) => entityBrands.includes(b));
+            if (!hasMatchingBrand) {
+                // Entity doesn't match brand - this shouldn't happen if TenantRepository is used
+                // Log for debugging (optional - can be removed)
+                // tslint:disable-next-line no-console
+                console.warn(`[TenantEntitySubscriber] Entity ${event.metadata.name} (id: ${entity.id}) doesn't match brand context`);
+            }
+        }
+    }
+};
+TenantEntitySubscriber = __decorate([
+    typeorm_1.EventSubscriber()
+], TenantEntitySubscriber);
+exports.TenantEntitySubscriber = TenantEntitySubscriber;