@almatar/branding 1.0.0-beta.3.7 → 1.0.0-beta.3.8

package/lib/lib/TenantModel/MongooseTenantHelper.d.ts

@@ -1,7 +1,15 @@
+/**
+ * Options for tenant scope when schema uses 'brands' (array) instead of 'brand' (single).
+ */
+export interface IMongooseTenantOptions {
+    /** Column name: 'brand' (default) or 'brands'. Use 'brands' when schema has an array of brands. */
+    brandColumn?: 'brand' | 'brands';
+}
 /**
  * Utility class for manually applying tenant scoping in Mongoose repositories
  * This allows you to use regular MongooseModule and apply brand filters manually
  * when needed, giving you more control over when tenant scoping is applied.
+ * Supports both 'brand' (single) and 'brands' (array) schema fields.
  */
 export declare class MongooseTenantHelper {
     /**
@@ -15,33 +23,35 @@ export declare class MongooseTenantHelper {
      */
     static getBrandForDocument(): string | null;
     /**
-     * Add brand filter to a query object
-     * Use this when building find() queries manually
+     * Add brand filter to a query object.
+     * Supports both 'brand' (single) and 'brands' (array) - filter is always fieldName: { $in: contextBrands }.
      * @param query - The query object to add brand filter to
+     * @param options - Optional. Use { brandColumn: 'brands' } when schema has brands array
      * @returns The query object with brand filter added (if brand context exists)
      */
-    static addBrandFilter(query: any): any;
+    static addBrandFilter(query: any, options?: IMongooseTenantOptions): any;
     /**
-     * Add brand filter to an aggregation pipeline
-     * Use this when building aggregate() queries manually
+     * Add brand filter to an aggregation pipeline.
      * @param pipeline - The aggregation pipeline array
+     * @param options - Optional. Use { brandColumn: 'brands' } when schema has brands array
      * @returns The pipeline with brand filter added (if brand context exists)
      */
-    static addBrandFilterToPipeline(pipeline: any[]): any[];
+    static addBrandFilterToPipeline(pipeline?: any[], options?: IMongooseTenantOptions): any[];
     /**
-     * Set brand on a document before save
-     * Use this when creating/updating documents manually
+     * Set brand on a document before save.
+     * For 'brand': sets document.brand. For 'brands': ensures context brand is in document.brands array.
      * @param document - The document object to set brand on
-     * @returns The document with brand set (if brand context exists and brand not already set)
+     * @param options - Optional. Use { brandColumn: 'brands' } when schema has brands array
+     * @returns The document with brand set (if brand context exists)
      */
-    static setBrandOnDocument(document: any): any;
+    static setBrandOnDocument(document: any, options?: IMongooseTenantOptions): any;
     /**
-     * Set brand on multiple documents before insertMany
-     * Use this when inserting multiple documents manually
+     * Set brand on multiple documents before insertMany.
      * @param documents - Array of document objects to set brand on
+     * @param options - Optional. Use { brandColumn: 'brands' } when schema has brands array
      * @returns The documents array with brand set (if brand context exists)
      */
-    static setBrandOnDocuments(documents: any[]): any[];
+    static setBrandOnDocuments(documents: any[], options?: IMongooseTenantOptions): any[];
     /**
      * Check if brand context exists
      * @returns true if brand context is available, false otherwise

package/lib/lib/TenantModel/MongooseTenantHelper.js

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.MongooseTenantHelper = void 0;
 const AlmatarBranding_1 = __importDefault(require("../AlmatarBranding"));
 const Storage_1 = __importDefault(require("../Storage"));
+const DEFAULT_BRAND_COLUMN = 'brand';
 /**
  * Utility class for manually applying tenant scoping in Mongoose repositories
  * This allows you to use regular MongooseModule and apply brand filters manually
  * when needed, giving you more control over when tenant scoping is applied.
+ * Supports both 'brand' (single) and 'brands' (array) schema fields.
  */
 class MongooseTenantHelper {
     /**
@@ -30,27 +32,28 @@ class MongooseTenantHelper {
         return contextBrands && contextBrands.length > 0 ? contextBrands[0] : null;
     }
     /**
-     * Add brand filter to a query object
-     * Use this when building find() queries manually
+     * Add brand filter to a query object.
+     * Supports both 'brand' (single) and 'brands' (array) - filter is always fieldName: { $in: contextBrands }.
      * @param query - The query object to add brand filter to
+     * @param options - Optional. Use { brandColumn: 'brands' } when schema has brands array
      * @returns The query object with brand filter added (if brand context exists)
      */
-    static addBrandFilter(query) {
+    static addBrandFilter(query, options) {
+        var _a;
         const contextBrands = this.getBrandContext();
+        const column = (_a = options === null || options === void 0 ? void 0 : options.brandColumn) !== null && _a !== void 0 ? _a : DEFAULT_BRAND_COLUMN;
         if (contextBrands && contextBrands.length > 0) {
-            // If query already has $and, add brand filter to it
+            const brandFilter = { [column]: { $in: contextBrands } };
             if (query.$and) {
-                query.$and.push({ brand: { $in: contextBrands } });
+                query.$and.push(brandFilter);
             }
             else if (Object.keys(query).length > 0) {
-                // If query has other conditions, wrap in $and
-                query = { $and: [query, { brand: { $in: contextBrands } }] };
+                query = { $and: [query, brandFilter] };
             }
             else {
-                // If query is empty, just add brand filter
-                query.brand = { $in: contextBrands };
+                query[column] = { $in: contextBrands };
             }
-            AlmatarBranding_1.default.log('[MongooseTenantHelper] Added brand filter to query:', { brand: { $in: contextBrands } });
+            AlmatarBranding_1.default.log('[MongooseTenantHelper] Added brand filter to query:', brandFilter);
         }
         else {
             AlmatarBranding_1.default.log('[MongooseTenantHelper] No brand context, skipping brand filter');
@@ -58,27 +61,26 @@ class MongooseTenantHelper {
         return query;
     }
     /**
-     * Add brand filter to an aggregation pipeline
-     * Use this when building aggregate() queries manually
+     * Add brand filter to an aggregation pipeline.
      * @param pipeline - The aggregation pipeline array
+     * @param options - Optional. Use { brandColumn: 'brands' } when schema has brands array
      * @returns The pipeline with brand filter added (if brand context exists)
      */
-    static addBrandFilterToPipeline(pipeline) {
+    static addBrandFilterToPipeline(pipeline = [], options) {
+        var _a;
         const contextBrands = this.getBrandContext();
+        const column = (_a = options === null || options === void 0 ? void 0 : options.brandColumn) !== null && _a !== void 0 ? _a : DEFAULT_BRAND_COLUMN;
         if (contextBrands && contextBrands.length > 0) {
-            const brandFilter = { brand: { $in: contextBrands } };
-            // Try to merge with existing $match stage if it exists
+            const brandFilter = { [column]: { $in: contextBrands } };
             let mergedMatch = false;
             for (const stage of pipeline) {
                 if (stage.$match) {
-                    // Merge brand filter with existing $match
                     stage.$match = Object.assign(Object.assign({}, stage.$match), brandFilter);
                     mergedMatch = true;
                     AlmatarBranding_1.default.log('[MongooseTenantHelper] Merged brand filter with existing $match:', stage.$match);
                     break;
                 }
             }
-            // If no $match stage exists, add brand filter at the beginning
             if (!mergedMatch) {
                 pipeline.unshift({ $match: brandFilter });
                 AlmatarBranding_1.default.log('[MongooseTenantHelper] Added brand filter to pipeline:', brandFilter);
@@ -90,37 +92,57 @@ class MongooseTenantHelper {
         return pipeline;
     }
     /**
-     * Set brand on a document before save
-     * Use this when creating/updating documents manually
+     * Set brand on a document before save.
+     * For 'brand': sets document.brand. For 'brands': ensures context brand is in document.brands array.
      * @param document - The document object to set brand on
-     * @returns The document with brand set (if brand context exists and brand not already set)
+     * @param options - Optional. Use { brandColumn: 'brands' } when schema has brands array
+     * @returns The document with brand set (if brand context exists)
      */
-    static setBrandOnDocument(document) {
+    static setBrandOnDocument(document, options) {
+        var _a;
         const brand = this.getBrandForDocument();
-        if (brand && !document.brand) {
-            document.brand = brand;
-            AlmatarBranding_1.default.log('[MongooseTenantHelper] Set brand on document:', brand);
+        const column = (_a = options === null || options === void 0 ? void 0 : options.brandColumn) !== null && _a !== void 0 ? _a : DEFAULT_BRAND_COLUMN;
+        if (brand) {
+            if (column === 'brands') {
+                document.brands = document.brands || [];
+                if (!document.brands.includes(brand)) {
+                    document.brands.push(brand);
+                }
+                AlmatarBranding_1.default.log('[MongooseTenantHelper] Set brand on document.brands:', brand);
+            }
+            else if (!document.brand) {
+                document.brand = brand;
+                AlmatarBranding_1.default.log('[MongooseTenantHelper] Set brand on document:', brand);
+            }
         }
-        else if (!brand) {
+        else {
             AlmatarBranding_1.default.log('[MongooseTenantHelper] No brand context, skipping brand on document');
         }
         return document;
     }
     /**
-     * Set brand on multiple documents before insertMany
-     * Use this when inserting multiple documents manually
+     * Set brand on multiple documents before insertMany.
      * @param documents - Array of document objects to set brand on
+     * @param options - Optional. Use { brandColumn: 'brands' } when schema has brands array
      * @returns The documents array with brand set (if brand context exists)
      */
-    static setBrandOnDocuments(documents) {
+    static setBrandOnDocuments(documents, options) {
+        var _a;
         const brand = this.getBrandForDocument();
+        const column = (_a = options === null || options === void 0 ? void 0 : options.brandColumn) !== null && _a !== void 0 ? _a : DEFAULT_BRAND_COLUMN;
         if (brand) {
             documents.forEach((doc) => {
-                if (!doc.brand) {
+                if (column === 'brands') {
+                    doc.brands = doc.brands || [];
+                    if (!doc.brands.includes(brand)) {
+                        doc.brands.push(brand);
+                    }
+                }
+                else if (!doc.brand) {
                     doc.brand = brand;
                 }
             });
-            AlmatarBranding_1.default.log('[MongooseTenantHelper] Set brand on documents:', brand);
+            AlmatarBranding_1.default.log('[MongooseTenantHelper] Set brand on documents:', { column, brand });
         }
         else {
             AlmatarBranding_1.default.log('[MongooseTenantHelper] No brand context, skipping brand on documents');

package/lib/lib/TenantModel/MongooseTenantRepository.d.ts

@@ -1,33 +1,35 @@
 import { Model, Document, FilterQuery, QueryOptions, UpdateQuery, UpdateWithAggregationPipeline } from 'mongoose';
+import { IMongooseTenantOptions } from './MongooseTenantHelper';
+/**
+ * Options for TenantMongooseRepository when schema uses 'brands' (array) instead of 'brand'.
+ */
+export interface ITenantMongooseRepositoryOptions {
+    /** Use 'brands' when your schema has an array of brands; default is 'brand'. */
+    brandColumn?: 'brand' | 'brands';
+}
 /**
  * Base Repository class for Mongoose that AUTOMATICALLY applies brand filtering to ALL queries
  * Similar to TenantRepository for TypeORM - just extend this class and everything works!
  *
- * Usage:
+ * Use the second constructor argument when your schema has a `brands` (array) field:
  * ```typescript
- * import { TenantMongooseRepository } from '@almatar/branding';
- *
- * export class BookingItemRepository extends TenantMongooseRepository<BookingItem> {
- *   constructor(@InjectModel(BookingItem.name) private readonly model: Model<BookingItem>) {
- *     super(model);
- *   }
- * }
+ * super(model, { brandColumn: 'brands' });
  * ```
  *
  * Brand filtering is automatically applied to:
- * - find() - automatically filters by brand
- * - findOne() - automatically filters by brand
- * - findOneAndUpdate() - automatically filters by brand
- * - findOneAndDelete() - automatically filters by brand
- * - countDocuments() - automatically filters by brand
- * - aggregate() - automatically filters by brand
- * - save() - automatically sets brand on document
- * - create() - automatically sets brand on document
+ * - find() - automatically filters by brand/brands
+ * - findOne() - automatically filters by brand/brands
+ * - findOneAndUpdate() - automatically filters by brand/brands
+ * - findOneAndDelete() - automatically filters by brand/brands
+ * - countDocuments() - automatically filters by brand/brands
+ * - aggregate() - automatically filters by brand/brands
+ * - save() - automatically sets brand/brands on document
+ * - create() - automatically sets brand/brands on document
  */
 export declare class TenantMongooseRepository<T extends Document> {
     protected readonly model: Model<T>;
-    protected readonly brandColumn: string;
-    constructor(model: Model<T>);
+    protected readonly tenantOptions: IMongooseTenantOptions;
+    constructor(model: Model<T>, options?: ITenantMongooseRepositoryOptions);
     /**
      * Override find to automatically apply brand filtering
      */

package/lib/lib/TenantModel/MongooseTenantRepository.js

@@ -6,120 +6,114 @@ const MongooseTenantHelper_1 = require("./MongooseTenantHelper");
  * Base Repository class for Mongoose that AUTOMATICALLY applies brand filtering to ALL queries
  * Similar to TenantRepository for TypeORM - just extend this class and everything works!
  *
- * Usage:
+ * Use the second constructor argument when your schema has a `brands` (array) field:
  * ```typescript
- * import { TenantMongooseRepository } from '@almatar/branding';
- *
- * export class BookingItemRepository extends TenantMongooseRepository<BookingItem> {
- *   constructor(@InjectModel(BookingItem.name) private readonly model: Model<BookingItem>) {
- *     super(model);
- *   }
- * }
+ * super(model, { brandColumn: 'brands' });
  * ```
  *
  * Brand filtering is automatically applied to:
- * - find() - automatically filters by brand
- * - findOne() - automatically filters by brand
- * - findOneAndUpdate() - automatically filters by brand
- * - findOneAndDelete() - automatically filters by brand
- * - countDocuments() - automatically filters by brand
- * - aggregate() - automatically filters by brand
- * - save() - automatically sets brand on document
- * - create() - automatically sets brand on document
+ * - find() - automatically filters by brand/brands
+ * - findOne() - automatically filters by brand/brands
+ * - findOneAndUpdate() - automatically filters by brand/brands
+ * - findOneAndDelete() - automatically filters by brand/brands
+ * - countDocuments() - automatically filters by brand/brands
+ * - aggregate() - automatically filters by brand/brands
+ * - save() - automatically sets brand/brands on document
+ * - create() - automatically sets brand/brands on document
  */
 class TenantMongooseRepository {
-    constructor(model) {
-        this.brandColumn = 'brand';
+    constructor(model, options) {
         this.model = model;
+        this.tenantOptions = (options === null || options === void 0 ? void 0 : options.brandColumn) ? { brandColumn: options.brandColumn } : {};
     }
     /**
      * Override find to automatically apply brand filtering
      */
     find(filter = {}, projection, options) {
-        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
         return this.model.find(filteredQuery, projection, options);
     }
     /**
      * Override findOne to automatically apply brand filtering
      */
     findOne(filter = {}, projection, options) {
-        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
         return this.model.findOne(filteredQuery, projection, options);
     }
     /**
      * Override findOneAndUpdate to automatically apply brand filtering
      */
     findOneAndUpdate(filter, update, options) {
-        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
         return this.model.findOneAndUpdate(filteredQuery, update, options);
     }
     /**
      * Override findOneAndDelete to automatically apply brand filtering
      */
     findOneAndDelete(filter = {}, options) {
-        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
         return this.model.findOneAndDelete(filteredQuery, options);
     }
     /**
      * Override findOneAndReplace to automatically apply brand filtering
      */
     findOneAndReplace(filter, replacement, options) {
-        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
         return this.model.findOneAndReplace(filteredQuery, replacement, options);
     }
     /**
      * Override countDocuments to automatically apply brand filtering
      */
     countDocuments(filter = {}, options) {
-        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
         return this.model.countDocuments(filteredQuery, options);
     }
     /**
      * Override deleteOne to automatically apply brand filtering
      */
     deleteOne(filter = {}, options) {
-        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
         return this.model.deleteOne(filteredQuery, options);
     }
     /**
      * Override deleteMany to automatically apply brand filtering
      */
     deleteMany(filter = {}, options) {
-        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
         return this.model.deleteMany(filteredQuery, options);
     }
     /**
      * Override updateOne to automatically apply brand filtering
      */
     updateOne(filter, update, options) {
-        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
         return this.model.updateOne(filteredQuery, update, options);
     }
     /**
      * Override updateMany to automatically apply brand filtering
      */
     updateMany(filter, update, options) {
-        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        const filteredQuery = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
         return this.model.updateMany(filteredQuery, update, options);
     }
     /**
      * Override aggregate to automatically apply brand filtering
      */
     aggregate(pipeline = []) {
-        const filteredPipeline = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilterToPipeline([...pipeline]);
+        const filteredPipeline = MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilterToPipeline([...pipeline], this.tenantOptions);
         return this.model.aggregate(filteredPipeline);
     }
     async create(doc, ...docs) {
         if (Array.isArray(doc)) {
-            const documents = MongooseTenantHelper_1.MongooseTenantHelper.setBrandOnDocuments([...doc]);
+            const documents = MongooseTenantHelper_1.MongooseTenantHelper.setBrandOnDocuments([...doc], this.tenantOptions);
             return this.model.create(documents);
         }
         else if (docs.length > 0) {
-            const documents = MongooseTenantHelper_1.MongooseTenantHelper.setBrandOnDocuments([doc, ...docs]);
+            const documents = MongooseTenantHelper_1.MongooseTenantHelper.setBrandOnDocuments([doc, ...docs], this.tenantOptions);
             return this.model.create(documents);
         }
         else {
-            const document = MongooseTenantHelper_1.MongooseTenantHelper.setBrandOnDocument(Object.assign({}, doc));
+            const document = MongooseTenantHelper_1.MongooseTenantHelper.setBrandOnDocument(Object.assign({}, doc), this.tenantOptions);
             return this.model.create(document);
         }
     }
@@ -127,14 +121,14 @@ class TenantMongooseRepository {
      * Override insertMany to automatically set brand on documents
      */
     insertMany(docs, options) {
-        const documents = MongooseTenantHelper_1.MongooseTenantHelper.setBrandOnDocuments([...docs]);
+        const documents = MongooseTenantHelper_1.MongooseTenantHelper.setBrandOnDocuments([...docs], this.tenantOptions);
         return this.model.insertMany(documents, options);
     }
     /**
      * Save method that automatically sets brand on document
      */
     async save(document) {
-        MongooseTenantHelper_1.MongooseTenantHelper.setBrandOnDocument(document);
+        MongooseTenantHelper_1.MongooseTenantHelper.setBrandOnDocument(document, this.tenantOptions);
         return document.save();
     }
     /**
@@ -148,14 +142,14 @@ class TenantMongooseRepository {
      * Useful for building complex queries
      */
     createQuery(filter = {}) {
-        return MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter);
+        return MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilter(filter, this.tenantOptions);
     }
     /**
      * Create an aggregation pipeline with brand filter applied
      * Useful for building complex aggregations
      */
     createPipeline(pipeline = []) {
-        return MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilterToPipeline([...pipeline]);
+        return MongooseTenantHelper_1.MongooseTenantHelper.addBrandFilterToPipeline([...pipeline], this.tenantOptions);
     }
 }
 exports.TenantMongooseRepository = TenantMongooseRepository;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@almatar/branding",
-  "version": "1.0.0-beta.3.7",
+  "version": "1.0.0-beta.3.8",
   "description": "",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",