@zenith-open/zenithcms-db-mongodb 0.1.0 → 1.0.0-beta.10

package/dist/MongooseAdapter.js

@@ -1,72 +1,11 @@
 import mongoose from 'mongoose';
 import { getModelForCollection } from './model-factory';
-import NodeCache from 'node-cache';
-import Redis from 'ioredis';
+import { createCacheLayer } from '@zenith-open/zenithcms-db-common';
 import pino from 'pino';
 const logger = pino();
 // Hard ceiling on query result size to prevent memory exhaustion / DoS
 const MAX_QUERY_LIMIT = 500;
 const DEFAULT_QUERY_LIMIT = 100;
-export class LocalCacheLayer {
-    cache;
-    constructor() {
-        this.cache = new NodeCache({ stdTTL: 60, checkperiod: 120 });
-    }
-    async get(key) {
-        return this.cache.get(key);
-    }
-    async set(key, value, collection) {
-        this.cache.set(key, value);
-    }
-    async invalidate(collection) {
-        const keys = this.cache.keys();
-        const targets = keys.filter((k) => k.startsWith(`${collection}:`));
-        this.cache.del(targets);
-    }
-}
-export class RedisCacheLayer {
-    redis;
-    constructor(redisUrl) {
-        this.redis = new Redis(redisUrl, {
-            maxRetriesPerRequest: 3,
-        });
-        logger.info('MongooseAdapter: Redis_Cache_Layer Initialized');
-    }
-    async get(key) {
-        try {
-            const data = await this.redis.get(key);
-            return data ? JSON.parse(data) : undefined;
-        }
-        catch (error) {
-            logger.warn({ error: error.message }, 'RedisCacheLayer: Get failed');
-            return undefined;
-        }
-    }
-    async set(key, value, collection) {
-        try {
-            const setKey = `zenith:cache:collection:${collection}`;
-            await this.redis.setex(key, 60, JSON.stringify(value));
-            await this.redis.sadd(setKey, key);
-            await this.redis.expire(setKey, 120);
-        }
-        catch (error) {
-            logger.warn({ error: error.message }, 'RedisCacheLayer: Set failed');
-        }
-    }
-    async invalidate(collection) {
-        try {
-            const setKey = `zenith:cache:collection:${collection}`;
-            const keys = await this.redis.smembers(setKey);
-            if (keys.length > 0) {
-                await this.redis.del(...keys);
-            }
-            await this.redis.del(setKey);
-        }
-        catch (error) {
-            logger.warn({ error: error.message }, 'RedisCacheLayer: Invalidate failed');
-        }
-    }
-}
 /**
  * Mongoose Database Adapter — Hardened Edition
  * ──────────────────────────────────────────
@@ -78,32 +17,74 @@ export class MongooseAdapter {
     name = 'mongoose';
     models = {};
     cache;
-    constructor(uri) {
-        this.uri = uri;
-        const redisUrl = process.env.REDIS_URL;
-        if (redisUrl) {
-            this.cache = new RedisCacheLayer(redisUrl);
+    consecutiveFailures = 0;
+    circuitBreakerCooldown = 0;
+    CIRCUIT_BREAKER_THRESHOLD = 10;
+    CIRCUIT_BREAKER_RESET_TIMEOUT_MS = 15000;
+    async _withCircuitBreaker(operation) {
+        if (this.consecutiveFailures >= this.CIRCUIT_BREAKER_THRESHOLD) {
+            if (Date.now() < this.circuitBreakerCooldown) {
+                throw new Error('Database Circuit Breaker Open: Too many consecutive failures. Rejecting request to prevent cascade overload.');
+            }
+            else {
+                // Half-open state
+                this.consecutiveFailures = this.CIRCUIT_BREAKER_THRESHOLD - 1;
+            }
         }
-        else {
-            this.cache = new LocalCacheLayer();
-            logger.warn('MongooseAdapter: Local_Cache_Layer Initialized (Warning: Cache desync risk under horizontal scaling)');
+        try {
+            const result = await operation();
+            this.consecutiveFailures = 0; // reset
+            return result;
+        }
+        catch (err) {
+            this.consecutiveFailures++;
+            if (this.consecutiveFailures === this.CIRCUIT_BREAKER_THRESHOLD) {
+                this.circuitBreakerCooldown = Date.now() + this.CIRCUIT_BREAKER_RESET_TIMEOUT_MS;
+                logger.error(`[MongooseAdapter] Circuit Breaker TRIPPED. DB operations suspended for ${this.CIRCUIT_BREAKER_RESET_TIMEOUT_MS}ms`);
+            }
+            throw err;
         }
+    }
+    constructor(uri) {
+        this.uri = uri;
+        this.cache = createCacheLayer('MongooseAdapter');
         logger.info('MongooseAdapter: Neural_Cache_Layer Initialized');
     }
+    getNativeClient() {
+        return mongoose.connection;
+    }
+    async executeRaw(query, params) {
+        // Mongoose adapter doesn't natively use raw SQL, so we'll throw or return null
+        // depending on usage. For now, just throw an unsupported error.
+        throw new Error('executeRaw is not supported on MongooseAdapter');
+    }
     async connect() {
-        try {
-            const poolMax = parseInt(process.env.DB_POOL_SIZE || '10', 10);
-            await mongoose.connect(this.uri, {
-                serverSelectionTimeoutMS: 5000,
-                socketTimeoutMS: 45000,
-                maxPoolSize: poolMax,
-            });
-            logger.info('MongooseAdapter: Connected to MongoDB');
-            this._initSystemModels();
-        }
-        catch (error) {
-            logger.error({ error: error.message }, 'MongooseAdapter: Connection failed');
-            throw error;
+        const poolMax = parseInt(process.env.DB_POOL_SIZE || '10', 10);
+        const maxRetries = parseInt(process.env.DB_CONNECT_MAX_RETRIES || '5', 10);
+        const retryDelay = parseInt(process.env.DB_CONNECT_RETRY_DELAY_MS || '3000', 10);
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                await mongoose.connect(this.uri, {
+                    serverSelectionTimeoutMS: parseInt(process.env.DB_SERVER_SELECTION_TIMEOUT_MS || '5000', 10),
+                    socketTimeoutMS: parseInt(process.env.DB_SOCKET_TIMEOUT_MS || '45000', 10),
+                    maxPoolSize: poolMax,
+                    autoIndex: process.env.ZENITH_AUTO_MIGRATE !== 'false',
+                });
+                logger.info({ attempt }, 'MongooseAdapter: Connected to MongoDB');
+                this._initSystemModels();
+                return;
+            }
+            catch (error) {
+                logger.error({ attempt, error: error.message }, 'MongooseAdapter: Connection failed');
+                if (attempt < maxRetries) {
+                    logger.info({ nextAttemptIn: retryDelay }, 'Retrying MongoDB connection...');
+                    await new Promise((resolve) => setTimeout(resolve, retryDelay));
+                }
+                else {
+                    logger.fatal('Could not connect to MongoDB after all retries. Exiting.');
+                    process.exit(1);
+                }
+            }
         }
     }
     async disconnect() {
@@ -175,6 +156,18 @@ export class MongooseAdapter {
             }, { strict: true });
             mongoose.model('z_migrations', schema);
         }
+        if (!mongoose.models['z_api_keys']) {
+            const schema = new mongoose.Schema({
+                name: { type: String, required: true },
+                key: { type: String, required: true, index: true },
+                role: { type: String, required: true },
+                expiresAt: { type: Date },
+                siteId: { type: String, index: true },
+                revoked: { type: Boolean, default: false },
+                lastUsed: { type: Date },
+            }, { timestamps: true, strict: true });
+            mongoose.model('z_api_keys', schema);
+        }
         if (!mongoose.models['z_collections']) {
             const schema = new mongoose.Schema({
                 name: { type: String, required: true },
@@ -203,8 +196,9 @@ export class MongooseAdapter {
                 email: { type: String, required: true },
                 collectionName: { type: String, required: true },
                 documentId: { type: String, required: true },
+                siteId: { type: String, required: false },
                 lastActive: { type: Number, required: true },
-            }, { timestamps: false, strict: true });
+            }, { timestamps: false, strict: true, collection: 'z_presence' });
             mongoose.model('z_presence', schema);
         }
         if (!mongoose.models['Lock']) {
@@ -266,12 +260,14 @@ export class MongooseAdapter {
             resolvedCollection = 'AuditLog';
         if (collection === 'versions' || collection === 'z_versions')
             resolvedCollection = 'Version';
+        if (collection === 'comments')
+            resolvedCollection = 'Comment';
         const model = this.models[resolvedCollection] || mongoose.models[resolvedCollection];
         if (!model)
             throw new Error(`Collection "${collection}" not registered`);
         return model;
     }
-    _getCacheKey(collection, query, options) {
+    _getCacheKey(method, collection, query, options) {
         const sortObject = (obj) => {
             if (obj === null || typeof obj !== 'object')
                 return obj;
@@ -284,168 +280,241 @@ export class MongooseAdapter {
         };
         const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
         const enrichedQuery = siteId ? { ...query, siteId } : query;
-        return `${collection}:${JSON.stringify(sortObject(enrichedQuery))}:${JSON.stringify(sortObject(options))}`;
+        return `${method}:${collection}:${JSON.stringify(sortObject(enrichedQuery))}:${JSON.stringify(sortObject(options))}`;
     }
     async find(collection, query, options = {}) {
-        const cacheKey = this._getCacheKey(collection, query, options);
-        const cached = await this.cache.get(cacheKey);
-        if (cached)
-            return cached;
-        const globalAot = globalThis.zenithAotBridge;
-        if (globalAot && globalAot.hasQuery(collection, 'find')) {
+        return this._withCircuitBreaker(async () => {
+            const cacheKey = this._getCacheKey('find', collection, query, options);
+            const cached = await this.cache.get(cacheKey);
+            if (cached)
+                return cached.map(doc => this._normalizeOutput(doc));
+            const globalAot = globalThis.zenithAotBridge;
+            if (globalAot && globalAot.hasQuery(collection, 'find')) {
+                const model = this.getModel(collection);
+                const docs = await globalAot.executeQuery(collection, 'find', mongoose.connection.db, model, this._normalizeQuery(query, options), options);
+                const mappedDocs = docs.map((doc) => this._normalizeOutput(doc));
+                await this.cache.set(cacheKey, mappedDocs, collection);
+                return mappedDocs;
+            }
             const model = this.getModel(collection);
-            const docs = await globalAot.executeQuery(collection, 'find', mongoose.connection.db, model, this._normalizeQuery(query, options), options);
-            await this.cache.set(cacheKey, docs, collection);
-            return docs;
-        }
-        const model = this.getModel(collection);
-        const normalizedQuery = this._normalizeQuery(query, options);
-        const q = model.find(normalizedQuery);
-        if (options.select)
-            q.select(options.select);
-        if (options.populate) {
-            const populateArr = Array.isArray(options.populate) ? options.populate : [options.populate];
-            populateArr.forEach((p) => q.populate(p));
-        }
-        const requestedLimit = options.limit ?? DEFAULT_QUERY_LIMIT;
-        const limit = Math.min(requestedLimit, MAX_QUERY_LIMIT);
-        const docs = (await q
-            .sort(options.sort || { createdAt: -1 })
-            .skip(options.skip || 0)
-            .limit(limit)
-            .session(options.session)
-            .lean()
-            .exec());
-        await this.cache.set(cacheKey, docs, collection);
-        return docs;
+            const normalizedQuery = this._normalizeQuery(query, options);
+            console.log(`[DEBUG] MongooseAdapter.find(${collection}):`, JSON.stringify(normalizedQuery));
+            const q = model.find(normalizedQuery).maxTimeMS(30000);
+            if (options.select)
+                q.select(options.select);
+            if (options.populate) {
+                const populateArr = Array.isArray(options.populate) ? options.populate : [options.populate];
+                populateArr.forEach((p) => q.populate(p));
+            }
+            const requestedLimit = options.limit ?? DEFAULT_QUERY_LIMIT;
+            const limit = Math.min(requestedLimit, MAX_QUERY_LIMIT);
+            const docs = (await q
+                .sort(options.sort || { createdAt: -1 })
+                .skip(options.skip || 0)
+                .limit(limit)
+                .session(options.session)
+                .lean()
+                .exec());
+            const mappedDocs = docs.map(doc => this._normalizeOutput(doc));
+            await this.cache.set(cacheKey, mappedDocs, collection);
+            return mappedDocs;
+        });
     }
     async findOne(collection, query, options = {}) {
-        const cacheKey = this._getCacheKey(collection, query, options);
-        const cached = await this.cache.get(cacheKey);
-        if (cached)
-            return cached;
-        const model = this.getModel(collection);
-        const q = model.findOne(this._normalizeQuery(query, options));
-        if (options.select)
-            q.select(options.select);
-        if (options.populate) {
-            const populateArr = Array.isArray(options.populate) ? options.populate : [options.populate];
-            populateArr.forEach((p) => q.populate(p));
-        }
-        const doc = (await q
-            .session(options.session)
-            .lean()
-            .exec());
-        if (doc)
-            await this.cache.set(cacheKey, doc, collection);
-        return doc;
+        return this._withCircuitBreaker(async () => {
+            const cacheKey = this._getCacheKey('findOne', collection, query, options);
+            const cached = await this.cache.get(cacheKey);
+            if (cached)
+                return this._normalizeOutput(cached);
+            const model = this.getModel(collection);
+            const q = model.findOne(this._normalizeQuery(query, options)).maxTimeMS(30000);
+            if (options.select)
+                q.select(options.select);
+            if (options.populate) {
+                const populateArr = Array.isArray(options.populate) ? options.populate : [options.populate];
+                populateArr.forEach((p) => q.populate(p));
+            }
+            const doc = (await q
+                .session(options.session)
+                .lean()
+                .exec());
+            if (doc) {
+                const mappedDoc = this._normalizeOutput(doc);
+                await this.cache.set(cacheKey, mappedDoc, collection);
+                return mappedDoc;
+            }
+            return null;
+        });
+    }
+    async findMany(collection, ids, options = {}) {
+        return this._withCircuitBreaker(async () => {
+            if (!ids || ids.length === 0)
+                return [];
+            const model = this.getModel(collection);
+            const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
+            const query = { _id: { $in: ids } };
+            if (siteId && siteId !== 'global') {
+                query.siteId = siteId;
+            }
+            const docs = await model
+                .find(query)
+                .session(options.session)
+                .maxTimeMS(30000)
+                .lean()
+                .exec();
+            return docs.map(doc => this._normalizeOutput(doc));
+        });
     }
     async _invalidateCache(collection) {
         await this.cache.invalidate(collection);
     }
     async create(collection, data, options = {}) {
-        // Inject tenant scoping into created documents
-        const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
-        const enrichedData = siteId && !data.siteId
-            ? { ...data, siteId }
-            : data;
-        const globalAot = globalThis.zenithAotBridge;
-        if (globalAot && globalAot.hasQuery(collection, 'create')) {
+        return this._withCircuitBreaker(async () => {
+            // Inject tenant scoping into created documents
+            const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
+            const enrichedData = siteId && !data.siteId
+                ? { ...data, siteId }
+                : data;
+            const globalAot = globalThis.zenithAotBridge;
+            if (globalAot && globalAot.hasQuery(collection, 'create')) {
+                const model = this.getModel(collection);
+                const doc = await globalAot.executeQuery(collection, 'create', mongoose.connection.db, model, enrichedData, options);
+                await this._invalidateCache(collection);
+                return doc;
+            }
             const model = this.getModel(collection);
-            const doc = await globalAot.executeQuery(collection, 'create', mongoose.connection.db, model, enrichedData, options);
+            const [doc] = await model.create([enrichedData], { session: options.session });
             await this._invalidateCache(collection);
-            return doc;
-        }
-        const model = this.getModel(collection);
-        const [doc] = await model.create([enrichedData], { session: options.session });
-        await this._invalidateCache(collection);
-        return doc.toObject();
+            return this._normalizeOutput(doc.toObject());
+        });
     }
     async update(collection, id, data, options = {}) {
-        const model = this.getModel(collection);
-        const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
-        const filter = { _id: id };
-        if (siteId)
-            filter.siteId = siteId;
-        // Atomic optimistic locking: include expected _version in the filter
-        if (options.expectedVersion !== undefined) {
-            filter._version = options.expectedVersion;
+        return this._withCircuitBreaker(async () => {
+            const model = this.getModel(collection);
+            const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
+            const objectId = mongoose.Types.ObjectId.isValid(id) && typeof id === 'string' && id.length === 24
+                ? new mongoose.Types.ObjectId(id)
+                : id;
+            const filter = { _id: objectId };
+            if (siteId)
+                filter.siteId = siteId;
+            // Atomic optimistic locking: include expected _version in the filter
+            if (options.expectedVersion !== undefined) {
+                filter._version = options.expectedVersion;
+            }
+            const doc = await model
+                .findOneAndUpdate(filter, { $set: data }, {
+                new: true,
+                session: options.session,
+                runValidators: true,
+            })
+                .maxTimeMS(30000)
+                .lean()
+                .exec();
+            await this._invalidateCache(collection);
+            return doc ? this._normalizeOutput(doc) : null;
+        });
+    }
+    _normalizeOutput(doc) {
+        if (!doc || typeof doc !== 'object')
+            return doc;
+        if ('_id' in doc) {
+            doc.id = doc._id?.toString() || doc._id;
+            delete doc._id;
         }
-        const doc = await model
-            .findOneAndUpdate(filter, { $set: data }, {
-            new: true,
-            session: options.session,
-            runValidators: true,
-        })
-            .lean()
-            .exec();
-        await this._invalidateCache(collection);
         return doc;
     }
     _normalizeQuery(query, options) {
-        const normalized = { ...query };
-        if ('id' in normalized) {
-            normalized._id = normalized.id;
-            delete normalized.id;
-        }
+        const processQuery = (q) => {
+            const normalized = { ...q };
+            if ('id' in normalized) {
+                normalized._id = normalized.id;
+                delete normalized.id;
+            }
+            for (const key of Object.keys(normalized)) {
+                if (key === '$or' || key === '$and') {
+                    normalized[key] = normalized[key].map((sub) => processQuery(sub));
+                }
+            }
+            return normalized;
+        };
+        const normalized = processQuery(query);
         // Inject tenant scoping from options to prevent cross-tenant data access
         const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
-        if (siteId && !normalized.siteId) {
+        if (siteId && siteId !== 'global' && !normalized.siteId) {
             normalized.siteId = siteId;
         }
         return normalized;
     }
     async findOneAndUpdate(collection, query, update, options) {
-        const model = this.getModel(collection);
-        const normalized = this._normalizeQuery(query, options);
-        const returnDoc = options?.returnDocument === 'after' ? true : false;
-        const doc = await model
-            .findOneAndUpdate(normalized, { $set: update }, {
-            new: returnDoc,
-            session: options?.session,
-            runValidators: true,
-        })
-            .lean()
-            .exec();
-        return doc;
+        return this._withCircuitBreaker(async () => {
+            const model = this.getModel(collection);
+            const normalized = this._normalizeQuery(query, options);
+            const returnDoc = options?.returnDocument === 'after' ? true : false;
+            const doc = await model
+                .findOneAndUpdate(normalized, { $set: update }, {
+                new: returnDoc,
+                session: options?.session,
+                runValidators: true,
+            })
+                .maxTimeMS(30000)
+                .lean()
+                .exec();
+            return doc ? this._normalizeOutput(doc) : null;
+        });
     }
     async updateMany(collection, query, data, options = {}) {
-        const model = this.getModel(collection);
-        const result = await model.updateMany(this._normalizeQuery(query, options), { $set: data }, {
-            session: options.session,
+        return this._withCircuitBreaker(async () => {
+            const model = this.getModel(collection);
+            const result = await model.updateMany(this._normalizeQuery(query, options), { $set: data }, {
+                session: options.session,
+            });
+            await this._invalidateCache(collection);
+            return result.modifiedCount;
         });
-        await this._invalidateCache(collection);
-        return result.modifiedCount;
     }
     async delete(collection, id, options = {}) {
-        const model = this.getModel(collection);
-        const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
-        const filter = { _id: id };
-        if (siteId)
-            filter.siteId = siteId;
-        const result = await model.findOneAndDelete(filter, { session: options.session });
-        await this._invalidateCache(collection);
-        return !!result;
+        return this._withCircuitBreaker(async () => {
+            const model = this.getModel(collection);
+            const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
+            const objectId = mongoose.Types.ObjectId.isValid(id) && typeof id === 'string' && id.length === 24
+                ? new mongoose.Types.ObjectId(id)
+                : id;
+            const filter = { _id: objectId };
+            if (siteId)
+                filter.siteId = siteId;
+            console.log(`[DEBUG DELETE] collection=${collection} resolvedCollection=${model.modelName} filter=`, filter);
+            const result = await model.findOneAndDelete(filter, { session: options.session }).maxTimeMS(30000);
+            console.log(`[DEBUG DELETE] result=`, !!result);
+            await this._invalidateCache(collection);
+            return !!result;
+        });
     }
     async deleteMany(collection, query, options = {}) {
-        const model = this.getModel(collection);
-        const result = await model.deleteMany(this._normalizeQuery(query, options), { session: options.session });
-        await this._invalidateCache(collection);
-        return result.deletedCount;
+        return this._withCircuitBreaker(async () => {
+            const model = this.getModel(collection);
+            const result = await model.deleteMany(this._normalizeQuery(query, options), { session: options.session });
+            await this._invalidateCache(collection);
+            return result.deletedCount;
+        });
     }
     async count(collection, query, options) {
-        const model = this.getModel(collection);
-        return model.countDocuments(this._normalizeQuery(query, options));
+        return this._withCircuitBreaker(async () => {
+            const model = this.getModel(collection);
+            return model.countDocuments(this._normalizeQuery(query, options)).maxTimeMS(30000);
+        });
     }
     async aggregate(collection, pipeline, options) {
-        const model = this.getModel(collection);
-        const enrichedPipeline = [...pipeline];
-        // Inject tenant scoping — prepend $match stage to prevent cross-tenant data leaks
-        const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
-        if (siteId) {
-            enrichedPipeline.unshift({ $match: { siteId } });
-        }
-        return model.aggregate(enrichedPipeline).exec();
+        return this._withCircuitBreaker(async () => {
+            const model = this.getModel(collection);
+            const enrichedPipeline = [...pipeline];
+            // Inject tenant scoping — prepend $match stage to prevent cross-tenant data leaks
+            const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
+            if (siteId) {
+                enrichedPipeline.unshift({ $match: { siteId } });
+            }
+            return model.aggregate(enrichedPipeline).option({ maxTimeMS: 30000 }).exec();
+        });
     }
     async transaction(fn) {
         try {
@@ -538,20 +607,23 @@ export class MongooseAdapter {
         }));
     }
     async search(collection, query, fields, limit = 10, options) {
-        const model = this.getModel(collection);
-        const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-        const regex = { $regex: escaped, $options: 'i' };
-        const orQuery = fields.map((f) => ({ [f]: regex }));
-        const findQuery = { $or: orQuery };
-        const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
-        if (siteId) {
-            findQuery.siteId = siteId;
-        }
-        return model
-            .find(findQuery)
-            .limit(Math.min(limit, 50))
-            .lean()
-            .exec();
+        return this._withCircuitBreaker(async () => {
+            const model = this.getModel(collection);
+            const escaped = query.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+            const regex = { $regex: escaped, $options: 'i' };
+            const orQuery = fields.map((f) => ({ [f]: regex }));
+            const findQuery = { $or: orQuery };
+            const siteId = options?.siteId || options?.tenantId || globalThis.zenithAls?.getStore()?.siteId;
+            if (siteId) {
+                findQuery.siteId = siteId;
+            }
+            return model
+                .find(findQuery)
+                .limit(Math.min(limit, 50))
+                .maxTimeMS(30000)
+                .lean()
+                .exec();
+        });
     }
 }
 //# sourceMappingURL=MongooseAdapter.js.map