@flowerforce/flowerbase 1.7.5-beta.2 → 1.7.5-beta.4

package/dist/features/functions/controller.d.ts

@@ -1,4 +1,6 @@
 import { FunctionController } from './interface';
+export declare const mapWatchFilterToChangeStreamMatch: (value: unknown) => unknown;
+export declare const mapWatchFilterToDocumentQuery: (value: unknown) => unknown;
 /**
  * > Creates a pre handler for every query
  * @param app -> the fastify instance

package/dist/features/functions/controller.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/features/functions/controller.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAoFhD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,kBAqPjC,CAAA"}
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/features/functions/controller.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAmHhD,eAAO,MAAM,iCAAiC,GAAI,OAAO,OAAO,KAAG,OA0BlE,CAAA;AAID,eAAO,MAAM,6BAA6B,GAAI,OAAO,OAAO,KAAG,OAgD9D,CAAA;AAqHD;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,kBAuRjC,CAAA"}

package/dist/features/functions/controller.js

@@ -20,7 +20,7 @@ var __rest = (this && this.__rest) || function (s, e) {
     return t;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.functionsController = void 0;
+exports.functionsController = exports.mapWatchFilterToDocumentQuery = exports.mapWatchFilterToChangeStreamMatch = void 0;
 const bson_1 = require("bson");
 const services_1 = require("../../services");
 const context_1 = require("../../utils/context");
@@ -58,14 +58,205 @@ const isReturnedError = (value) => {
 };
 const serializeEjson = (value) => JSON.stringify(bson_1.EJSON.serialize(value, { relaxed: false }));
 const isRecord = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const isPlainRecord = (value) => {
+    if (!isRecord(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
+const isCursorLike = (value) => {
+    if (!value || typeof value !== 'object')
+        return false;
+    return typeof value.toArray === 'function';
+};
+const normalizeFunctionResult = (value) => __awaiter(void 0, void 0, void 0, function* () {
+    if (!isCursorLike(value))
+        return value;
+    return yield value.toArray();
+});
 const sharedWatchStreams = new Map();
 let watchSubscriberCounter = 0;
+const maxSharedWatchStreams = Number(process.env.MAX_SHARED_WATCH_STREAMS || 200);
+const debugWatchStreams = process.env.DEBUG_FUNCTIONS === 'true';
+const changeEventRootKeys = new Set([
+    '_id',
+    'operationType',
+    'clusterTime',
+    'txnNumber',
+    'lsid',
+    'ns',
+    'documentKey',
+    'fullDocument',
+    'updateDescription'
+]);
+const isChangeEventPath = (key) => {
+    if (changeEventRootKeys.has(key))
+        return true;
+    return (key.startsWith('ns.') ||
+        key.startsWith('documentKey.') ||
+        key.startsWith('fullDocument.') ||
+        key.startsWith('updateDescription.'));
+};
+const isOpaqueChangeEventObjectKey = (key) => key === 'ns' || key === 'documentKey' || key === 'fullDocument' || key === 'updateDescription';
+const mapWatchFilterToChangeStreamMatch = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((item) => (0, exports.mapWatchFilterToChangeStreamMatch)(item));
+    }
+    if (!isPlainRecord(value))
+        return value;
+    return Object.entries(value).reduce((acc, [key, current]) => {
+        if (key.startsWith('$')) {
+            acc[key] = (0, exports.mapWatchFilterToChangeStreamMatch)(current);
+            return acc;
+        }
+        if (isOpaqueChangeEventObjectKey(key)) {
+            acc[key] = current;
+            return acc;
+        }
+        if (isChangeEventPath(key)) {
+            acc[key] = (0, exports.mapWatchFilterToChangeStreamMatch)(current);
+            return acc;
+        }
+        acc[`fullDocument.${key}`] = (0, exports.mapWatchFilterToChangeStreamMatch)(current);
+        return acc;
+    }, {});
+};
+exports.mapWatchFilterToChangeStreamMatch = mapWatchFilterToChangeStreamMatch;
+const isLogicalOperator = (key) => key === '$and' || key === '$or' || key === '$nor';
+const mapWatchFilterToDocumentQuery = (value) => {
+    if (Array.isArray(value)) {
+        const mapped = value
+            .map((item) => (0, exports.mapWatchFilterToDocumentQuery)(item))
+            .filter((item) => !(isRecord(item) && Object.keys(item).length === 0));
+        return mapped;
+    }
+    if (!isPlainRecord(value))
+        return value;
+    return Object.entries(value).reduce((acc, [key, current]) => {
+        if (key.startsWith('$')) {
+            const mapped = (0, exports.mapWatchFilterToDocumentQuery)(current);
+            if (isLogicalOperator(key) && Array.isArray(mapped)) {
+                if (mapped.length > 0) {
+                    acc[key] = mapped;
+                }
+                return acc;
+            }
+            if (typeof mapped !== 'undefined') {
+                acc[key] = mapped;
+            }
+            return acc;
+        }
+        if (key === 'fullDocument') {
+            if (!isPlainRecord(current))
+                return acc;
+            const mapped = (0, exports.mapWatchFilterToDocumentQuery)(current);
+            if (isRecord(mapped)) {
+                Object.assign(acc, mapped);
+            }
+            return acc;
+        }
+        if (key.startsWith('fullDocument.')) {
+            const docKey = key.slice('fullDocument.'.length);
+            if (!docKey)
+                return acc;
+            acc[docKey] = (0, exports.mapWatchFilterToDocumentQuery)(current);
+            return acc;
+        }
+        if (isChangeEventPath(key)) {
+            return acc;
+        }
+        acc[key] = (0, exports.mapWatchFilterToDocumentQuery)(current);
+        return acc;
+    }, {});
+};
+exports.mapWatchFilterToDocumentQuery = mapWatchFilterToDocumentQuery;
+const toStableValue = (value) => {
+    if (Array.isArray(value)) {
+        return value.map((item) => toStableValue(item));
+    }
+    if (!isPlainRecord(value))
+        return value;
+    const sortedEntries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+    return sortedEntries.reduce((acc, [key, current]) => {
+        acc[key] = toStableValue(current);
+        return acc;
+    }, {});
+};
+const stableSerialize = (value) => {
+    const serialized = bson_1.EJSON.serialize(value, { relaxed: false });
+    return JSON.stringify(toStableValue(serialized));
+};
+const getWatchPermissionContext = (user) => ({
+    role: user.role,
+    roles: user.roles,
+    data: user.data,
+    custom_data: user.custom_data,
+    user_data: user.user_data
+});
+const resolveWatchStream = (database, collection, watchArgs, user) => {
+    const keys = Object.keys(watchArgs);
+    const hasOnlyAllowedKeys = keys.every((key) => key === 'filter' || key === 'ids');
+    if (!hasOnlyAllowedKeys) {
+        throw new Error('watch options support only "filter" or "ids"');
+    }
+    const extraFilter = parseWatchFilter(watchArgs);
+    const ids = watchArgs.ids;
+    if (extraFilter && typeof ids !== 'undefined') {
+        throw new Error('watch options cannot include both "ids" and "filter"');
+    }
+    const pipeline = [];
+    if (extraFilter) {
+        pipeline.push({ $match: (0, exports.mapWatchFilterToChangeStreamMatch)(extraFilter) });
+    }
+    if (typeof ids !== 'undefined') {
+        if (!Array.isArray(ids)) {
+            throw new Error('watch ids must be an array');
+        }
+        pipeline.push({
+            $match: {
+                $or: [
+                    { 'documentKey._id': { $in: ids } },
+                    { 'fullDocument._id': { $in: ids } }
+                ]
+            }
+        });
+    }
+    const options = { fullDocument: 'updateLookup' };
+    const streamKey = stableSerialize({
+        database,
+        collection,
+        pipeline,
+        options,
+        permissionContext: getWatchPermissionContext(user)
+    });
+    return { extraFilter, options, pipeline, streamKey };
+};
+const getWatchStats = () => {
+    let subscribers = 0;
+    for (const hub of sharedWatchStreams.values()) {
+        subscribers += hub.subscribers.size;
+    }
+    return {
+        hubs: sharedWatchStreams.size,
+        subscribers
+    };
+};
+const logWatchStats = (event, details) => {
+    if (!debugWatchStreams)
+        return;
+    const stats = getWatchStats();
+    console.log('[watch-pool]', event, Object.assign({ hubs: stats.hubs, subscribers: stats.subscribers }, details));
+};
 const parseWatchFilter = (args) => {
-    var _a;
     if (!isRecord(args))
         return undefined;
-    const candidate = (_a = (isRecord(args.filter) ? args.filter : undefined)) !== null && _a !== void 0 ? _a : (isRecord(args.query) ? args.query : undefined);
-    return candidate ? candidate : undefined;
+    const candidate = isRecord(args.filter) ? args.filter : undefined;
+    if (!candidate)
+        return undefined;
+    if ('$match' in candidate) {
+        throw new Error('watch filter must be a query object, not a $match stage');
+    }
+    return candidate;
 };
 const isReadableDocumentResult = (value) => !!value &&
     typeof value === 'object' &&
@@ -136,12 +327,13 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
                 functionsList,
                 services: services_1.services
             });
-            if (isReturnedError(result)) {
+            const normalizedResult = yield normalizeFunctionResult(result);
+            if (isReturnedError(normalizedResult)) {
                 res.type('application/json');
-                return JSON.stringify({ message: result.message, name: result.name });
+                return JSON.stringify({ message: normalizedResult.message, name: normalizedResult.name });
             }
             res.type('application/json');
-            return serializeEjson(result);
+            return serializeEjson(normalizedResult);
         }
         catch (error) {
             res.status(400);
@@ -165,7 +357,9 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
         const { baas_request, stitch_request } = query;
         const decodedConfig = JSON.parse(Buffer.from(baas_request || stitch_request || '', 'base64').toString('utf8'));
         const config = bson_1.EJSON.deserialize(decodedConfig);
-        const [_a] = config.arguments, { database, collection } = _a, watchArgs = __rest(_a, ["database", "collection"]);
+        const [_a] = config.arguments, { database, collection } = _a, watchArgsInput = __rest(_a, ["database", "collection"]);
+        const watchArgs = isRecord(watchArgsInput) ? watchArgsInput : {};
+        console.log("🚀 ~ functionsController ~ watchArgs:", watchArgs);
         const headers = {
             'Content-Type': 'text/event-stream',
             'Cache-Control': 'no-cache',
@@ -174,17 +368,27 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
             "access-control-allow-origin": '*',
             "access-control-allow-headers": "X-Stitch-Location, X-Baas-Location, Location",
         };
-        res.raw.writeHead(200, headers);
-        res.raw.flushHeaders();
-        const streamKey = `${database}::${collection}`;
         const subscriberId = `${Date.now()}-${watchSubscriberCounter++}`;
-        const extraFilter = parseWatchFilter(watchArgs);
-        const mongoClient = app.mongo.client;
+        const { streamKey, extraFilter, options: watchOptions, pipeline: watchPipeline } = resolveWatchStream(database, collection, watchArgs, user);
         let hub = sharedWatchStreams.get(streamKey);
         if (!hub) {
-            const stream = mongoClient.db(database).collection(collection).watch([], {
-                fullDocument: 'whenAvailable'
-            });
+            if (sharedWatchStreams.size >= maxSharedWatchStreams) {
+                res.status(503);
+                return JSON.stringify({
+                    error: JSON.stringify({
+                        message: 'Watch stream limit reached',
+                        name: 'WatchStreamLimitError'
+                    }),
+                    error_code: 'WatchStreamLimitError'
+                });
+            }
+            const stream = services_1.services['mongodb-atlas'](app, {
+                user,
+                rules
+            })
+                .db(database)
+                .collection(collection)
+                .watch(watchPipeline, watchOptions);
             hub = {
                 database,
                 collection,
@@ -192,7 +396,13 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
                 subscribers: new Map()
             };
             sharedWatchStreams.set(streamKey, hub);
+            logWatchStats('hub-created', { streamKey, database, collection });
+        }
+        else {
+            logWatchStats('hub-reused', { streamKey, database, collection });
         }
+        res.raw.writeHead(200, headers);
+        res.raw.flushHeaders();
         const ensureHubListeners = (currentHub) => {
             if (currentHub.listenersBound) {
                 return;
@@ -201,6 +411,7 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
                 currentHub.stream.off('change', onHubChange);
                 currentHub.stream.off('error', onHubError);
                 sharedWatchStreams.delete(streamKey);
+                logWatchStats('hub-closed', { streamKey, database, collection });
                 try {
                     yield currentHub.stream.close();
                 }
@@ -209,19 +420,21 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
                 }
             });
             const onHubChange = (change) => __awaiter(void 0, void 0, void 0, function* () {
+                console.log("🚀 ~ onHubChange ~ change:", change);
                 const subscribers = Array.from(currentHub.subscribers.values());
                 yield Promise.all(subscribers.map((subscriber) => __awaiter(void 0, void 0, void 0, function* () {
                     var _a, _b, _c;
                     const subscriberRes = subscriber.response;
                     if (subscriberRes.writableEnded || subscriberRes.destroyed) {
                         currentHub.subscribers.delete(subscriber.id);
+                        logWatchStats('subscriber-auto-removed', { streamKey, subscriberId: subscriber.id });
                         return;
                     }
                     const docId = (_b = (_a = change === null || change === void 0 ? void 0 : change.documentKey) === null || _a === void 0 ? void 0 : _a._id) !== null && _b !== void 0 ? _b : (_c = change === null || change === void 0 ? void 0 : change.fullDocument) === null || _c === void 0 ? void 0 : _c._id;
                     if (typeof docId === 'undefined')
                         return;
-                    const readQuery = subscriber.extraFilter
-                        ? { $and: [subscriber.extraFilter, { _id: docId }] }
+                    const readQuery = subscriber.documentFilter
+                        ? { $and: [subscriber.documentFilter, { _id: docId }] }
                         : { _id: docId };
                     try {
                         const readableDoc = yield services_1.services['mongodb-atlas'](app, {
@@ -231,6 +444,7 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
                             .db(currentHub.database)
                             .collection(currentHub.collection)
                             .findOne(readQuery);
+                        console.log("🚀 ~ onHubChange ~ readableDoc:", readableDoc);
                         if (!isReadableDocumentResult(readableDoc))
                             return;
                         subscriberRes.write(`data: ${serializeEjson(change)}\n\n`);
@@ -239,6 +453,7 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
                         subscriberRes.write(`event: error\ndata: ${formatFunctionExecutionError(error)}\n\n`);
                         subscriberRes.end();
                         currentHub.subscribers.delete(subscriber.id);
+                        logWatchStats('subscriber-error-removed', { streamKey, subscriberId: subscriber.id });
                     }
                 })));
                 if (!currentHub.subscribers.size) {
@@ -265,17 +480,27 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
             id: subscriberId,
             user,
             response: res.raw,
-            extraFilter
+            documentFilter: (() => {
+                if (!extraFilter)
+                    return undefined;
+                const mapped = (0, exports.mapWatchFilterToDocumentQuery)(extraFilter);
+                if (!isRecord(mapped) || Object.keys(mapped).length === 0)
+                    return undefined;
+                return mapped;
+            })()
         };
         hub.subscribers.set(subscriberId, subscriber);
+        logWatchStats('subscriber-added', { streamKey, subscriberId });
         req.raw.on('close', () => {
             const currentHub = sharedWatchStreams.get(streamKey);
             if (!currentHub)
                 return;
             currentHub.subscribers.delete(subscriberId);
+            logWatchStats('subscriber-closed', { streamKey, subscriberId });
             if (!currentHub.subscribers.size) {
                 void currentHub.stream.close();
                 sharedWatchStreams.delete(streamKey);
+                logWatchStats('hub-empty-closed', { streamKey });
             }
         });
     }));

package/dist/services/api/index.d.ts

@@ -30,6 +30,7 @@ declare const Api: (_app?: unknown, opt?: {
             bytes: () => Uint8Array<ArrayBuffer>;
         };
         statusCode: number;
+        statusText: string;
         headers: import("undici/types/header").IncomingHttpHeaders;
         trailers: Record<string, string>;
         opaque: T;
@@ -58,6 +59,7 @@ declare const Api: (_app?: unknown, opt?: {
             bytes: () => Uint8Array<ArrayBuffer>;
         };
         statusCode: number;
+        statusText: string;
         headers: import("undici/types/header").IncomingHttpHeaders;
         trailers: Record<string, string>;
         opaque: T;
@@ -86,6 +88,7 @@ declare const Api: (_app?: unknown, opt?: {
             bytes: () => Uint8Array<ArrayBuffer>;
         };
         statusCode: number;
+        statusText: string;
         headers: import("undici/types/header").IncomingHttpHeaders;
         trailers: Record<string, string>;
         opaque: T;
@@ -114,6 +117,7 @@ declare const Api: (_app?: unknown, opt?: {
             bytes: () => Uint8Array<ArrayBuffer>;
         };
         statusCode: number;
+        statusText: string;
         headers: import("undici/types/header").IncomingHttpHeaders;
         trailers: Record<string, string>;
         opaque: T;

package/dist/services/api/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/api/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGxE;;GAEG;AACH,QAAA,MAAM,GAAG,GAAI,OAAO,OAAO,EAAE,MAAM;IAAE,UAAU,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE;UAG5D,CAAC,wCAAoD,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuB7D,CAAC,gGASX,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+BD,CAAC,gGASV,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA+BG,CAAC,wEAOb,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAA;AAED,eAAe,GAAG,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/api/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,SAAS,EAAE,MAAM,SAAS,CAAA;AAGxE;;GAEG;AACH,QAAA,MAAM,GAAG,GAAI,OAAO,OAAO,EAAE,MAAM;IAAE,UAAU,CAAC,EAAE;QAAE,WAAW,CAAC,EAAE,MAAM,CAAA;KAAE,CAAA;CAAE;UAG5D,CAAC,wCAAoD,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;WAuB7D,CAAC,gGASX,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;UA+BD,CAAC,gGASV,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aA+BG,CAAC,wEAOb,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyBlB,CAAA;AAED,eAAe,GAAG,CAAA"}

package/dist/services/api/utils.d.ts

@@ -29,6 +29,7 @@ export declare const makeRequest: <T = null>({ method, url, headers, body, resol
         bytes: () => Uint8Array<ArrayBuffer>;
     };
     statusCode: number;
+    statusText: string;
     headers: import("undici/types/header").IncomingHttpHeaders;
     trailers: Record<string, string>;
     opaque: T;

package/dist/services/api/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/services/api/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAS,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAgBlD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAU,CAAC,GAAG,IAAI,EAAE,6CAMzC,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBnB,CAAA"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/services/api/utils.ts"],"names":[],"mappings":"AAEA,OAAO,EAAS,iBAAiB,EAAE,MAAM,SAAS,CAAA;AAgBlD;;;;;;GAMG;AACH,eAAO,MAAM,WAAW,GAAU,CAAC,GAAG,IAAI,EAAE,6CAMzC,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgBnB,CAAA"}

package/dist/services/index.d.ts

@@ -27,6 +27,7 @@ export declare const services: {
                 bytes: () => Uint8Array<ArrayBuffer>;
             };
             statusCode: number;
+            statusText: string;
             headers: import("undici/types/header").IncomingHttpHeaders;
             trailers: Record<string, string>;
             opaque: T;
@@ -55,6 +56,7 @@ export declare const services: {
                 bytes: () => Uint8Array<ArrayBuffer>;
             };
             statusCode: number;
+            statusText: string;
             headers: import("undici/types/header").IncomingHttpHeaders;
             trailers: Record<string, string>;
             opaque: T;
@@ -83,6 +85,7 @@ export declare const services: {
                 bytes: () => Uint8Array<ArrayBuffer>;
             };
             statusCode: number;
+            statusText: string;
             headers: import("undici/types/header").IncomingHttpHeaders;
             trailers: Record<string, string>;
             opaque: T;
@@ -111,6 +114,7 @@ export declare const services: {
                 bytes: () => Uint8Array<ArrayBuffer>;
             };
             statusCode: number;
+            statusText: string;
             headers: import("undici/types/header").IncomingHttpHeaders;
             trailers: Record<string, string>;
             opaque: T;

package/dist/services/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;kBAMoG,CAAC;uBAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA2hB,CAAC;uBAAe,CAAC;;;;;;;;;;;;;;;;sBAA0/F,CAAC;yBAAa,CAAC;;;;;;;;;;;CAD9rH,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAKA,eAAO,MAAM,QAAQ;;kBAMoG,CAAC;uBAAe,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAA2hB,CAAC;uBAAe,CAAC;;;;;;;;;;;;;;;;sBAA0/F,CAAC;yBAAa,CAAC;;;;;;;;;;;CAD9rH,CAAA"}

package/dist/services/mongodb-atlas/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/services/mongodb-atlas/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAElC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EACL,mBAAmB,EAEnB,MAAM,EAEN,UAAU,EACV,KAAK,EAGN,MAAM,gCAAgC,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAA;AAGlD,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE7D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,IAAI,GAAG,MAAM,EAAE,2BAInD,kBAAkB,CAAC,CAAC,CAAC,QA8BvB,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,UAAS,MAAM,EAAO,EACtB,QAAQ,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,EACtD,OAAO,IAAI,8BAcZ,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,UAAS,MAAM,EAAO,EACtB,OAAO,IAAI,KACV,UAAU,GAAG,IAaf,CAAA;AAED,eAAO,MAAM,4BAA4B,GACvC,UAAU,mBAAmB,EAC7B,OAAO,MAAM,CACX,MAAM,EACN;IACE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CACf,CACF,EACD,MAAM,IAAI,EACV,gBAAgB,MAAM,EACtB,UAAU;IACR,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,KACA,mBA6GF,CAAA;AAED,eAAO,MAAM,kBAAkB,GAC7B,OAAO,KAAK,EACZ,gBAAgB,MAAM,EACtB,WAAW,eAAe,SAM3B,CAAA;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,EAAE;;;;;;;;iBA2HuvrS,CAAC;sBAAgC,CAAC;2BAAsC,CAAC;;;;IAnH93rS;AAED,eAAO,MAAM,0BAA0B,GAAI,UAAU,QAAQ,EAAE,aAgC9D,CAAA;AAYD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,mBAAmB,QA+BvE;AAED,wBAAgB,8BAA8B,CAAC,WAAW,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CAAE,YAK9E;AAyBD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,EAAE,uBAKtF"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/services/mongodb-atlas/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAElC,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,IAAI,aAAa,EAAE,MAAM,SAAS,CAAA;AACvE,OAAO,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACtC,OAAO,EACL,mBAAmB,EAEnB,MAAM,EAEN,UAAU,EACV,KAAK,EAGN,MAAM,gCAAgC,CAAA;AACvC,OAAO,EAAE,IAAI,EAAE,MAAM,6BAA6B,CAAA;AAGlD,OAAO,EAAE,eAAe,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAE7D,eAAO,MAAM,YAAY,GAAI,CAAC,SAAS,IAAI,GAAG,MAAM,EAAE,2BAInD,kBAAkB,CAAC,CAAC,CAAC,QA8BvB,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,UAAS,MAAM,EAAO,EACtB,QAAQ,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,CAAC,EACtD,OAAO,IAAI,8BAcZ,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,UAAS,MAAM,EAAO,EACtB,OAAO,IAAI,KACV,UAAU,GAAG,IAaf,CAAA;AAED,eAAO,MAAM,4BAA4B,GACvC,UAAU,mBAAmB,EAC7B,OAAO,MAAM,CACX,MAAM,EACN;IACE,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CACf,CACF,EACD,MAAM,IAAI,EACV,gBAAgB,MAAM,EACtB,UAAU;IACR,gBAAgB,CAAC,EAAE,OAAO,CAAA;CAC3B,KACA,mBA6GF,CAAA;AAED,eAAO,MAAM,kBAAkB,GAC7B,OAAO,KAAK,EACZ,gBAAgB,MAAM,EACtB,WAAW,eAAe,SAM3B,CAAA;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,aAAa,CAAC,QAAQ,CAAC,EAAE;;;;;;;;iBA0I8iqS,CAAC;sBAAgC,CAAC;2BAAsC,CAAC;;;;IAlIrrqS;AAED,eAAO,MAAM,0BAA0B,GAAI,UAAU,QAAQ,EAAE,aAgC9D,CAAA;AAYD,wBAAgB,0BAA0B,CAAC,QAAQ,EAAE,mBAAmB,QA+BvE;AAED,wBAAgB,8BAA8B,CAAC,WAAW,CAAC,EAAE;IAAE,KAAK,CAAC,EAAE,IAAI,EAAE,CAAA;CAAE,YAK9E;AAwCD,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,mBAAmB,EAAE,YAAY,EAAE,MAAM,EAAE,uBAKtF"}

package/dist/services/mongodb-atlas/utils.js

@@ -217,6 +217,7 @@ function getHiddenFieldsFromRulesConfig(rulesConfig) {
 }
 function collectHiddenFieldsFromRoles(roles = []) {
     const hiddenFields = new Set();
+    const isFieldPermissionObject = (value) => !!value && typeof value === 'object' && ('read' in value || 'write' in value);
     const collectFromFields = (fields) => {
         if (!fields)
             return;
@@ -227,9 +228,24 @@ function collectHiddenFieldsFromRoles(roles = []) {
             }
         });
     };
+    const collectFromAdditionalFields = (fields) => {
+        if (!fields || typeof fields !== 'object')
+            return;
+        // Global additional_fields permissions (read/write) apply to unknown fields and cannot be mapped.
+        if (isFieldPermissionObject(fields))
+            return;
+        Object.entries(fields).forEach(([fieldName, permissions]) => {
+            if (!isFieldPermissionObject(permissions))
+                return;
+            const canRead = Boolean(permissions.read || permissions.write);
+            if (!canRead) {
+                hiddenFields.add(fieldName);
+            }
+        });
+    };
     roles.forEach((role) => {
         collectFromFields(role.fields);
-        collectFromFields(role.additional_fields);
+        collectFromAdditionalFields(role.additional_fields);
     });
     return Array.from(hiddenFields);
 }

package/dist/utils/context/helpers.d.ts

@@ -82,6 +82,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                         bytes: () => Uint8Array<ArrayBuffer>;
                     };
                     statusCode: number;
+                    statusText: string;
                     headers: import("undici/types/header").IncomingHttpHeaders;
                     trailers: Record<string, string>;
                     opaque: T;
@@ -110,6 +111,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                         bytes: () => Uint8Array<ArrayBuffer>;
                     };
                     statusCode: number;
+                    statusText: string;
                     headers: import("undici/types/header").IncomingHttpHeaders;
                     trailers: Record<string, string>;
                     opaque: T;
@@ -138,6 +140,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                         bytes: () => Uint8Array<ArrayBuffer>;
                     };
                     statusCode: number;
+                    statusText: string;
                     headers: import("undici/types/header").IncomingHttpHeaders;
                     trailers: Record<string, string>;
                     opaque: T;
@@ -166,6 +169,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                         bytes: () => Uint8Array<ArrayBuffer>;
                     };
                     statusCode: number;
+                    statusText: string;
                     headers: import("undici/types/header").IncomingHttpHeaders;
                     trailers: Record<string, string>;
                     opaque: T;
@@ -230,6 +234,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -258,6 +263,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -286,6 +292,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -314,6 +321,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -377,6 +385,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -405,6 +414,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -433,6 +443,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;
@@ -461,6 +472,7 @@ export declare const generateContextData: ({ user, services, app, rules, current
                     bytes: () => Uint8Array<ArrayBuffer>;
                 };
                 statusCode: number;
+                statusText: string;
                 headers: import("undici/types/header").IncomingHttpHeaders;
                 trailers: Record<string, string>;
                 opaque: T;

package/dist/utils/context/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,CACN,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACzC,MAAM,CAAA;IACX,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,CAAC,EAAE,OAAO,EACtB,sBAAsB,CAAC,EAAE,MAAM,EAAE,KAC9B,OAAO,CAAA;CACb,CAAA;AAgFD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,4GAUjC,yBAAyB;;;;;;;;;;;;;uBA4DP,SAAS;yBAGP,SAAS;;;;;;;;;;;;;;;;;;uBAcb,MAAM;;;;;;+BA5CU,MAAM,OAAO,QAAQ;;;;sCA1HrC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAsGT,CAAC;iCAAa,CAAC;;;;;;;;;;;;;;;;;;;kCAtGP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsGT,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;;;;kCAtGP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsGT,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;4BAyEF,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAiBrE,CAAA"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/context/helpers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG1C,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAE3C,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAA;AAEvD,KAAK,QAAQ,GAAG;IACd,MAAM,EAAE,CACN,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,OAAO,EAChB,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,kBAAkB,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KACzC,MAAM,CAAA;IACX,MAAM,EAAE,CACN,SAAS,EAAE,MAAM,EACjB,GAAG,EAAE,MAAM,GAAG,MAAM,EACpB,YAAY,CAAC,EAAE,OAAO,EACtB,sBAAsB,CAAC,EAAE,MAAM,EAAE,KAC9B,OAAO,CAAA;CACb,CAAA;AAgFD;;;;;;;;;GASG;AACH,eAAO,MAAM,mBAAmB,GAAI,4GAUjC,yBAAyB;;;;;;;;;;;;;uBA4DP,SAAS;yBAGP,SAAS;;;;;;;;;;;;;;;;;;uBAcb,MAAM;;;;;;+BA5CU,MAAM,OAAO,QAAQ;;;;sCA1HrC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8BAsGT,CAAC;iCAAa,CAAC;;;;;;;;;;;;;;;;;;;kCAtGP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsGT,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;;;;kCAtGP,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAsGT,CAAC;6BAAa,CAAC;;;;;;;;;;;;;;;4BAyEF,MAAM,OAAO,aAAa,WAAW,SAAS;;;CAiBrE,CAAA"}

package/dist/utils/roles/helpers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/roles/helpers.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAIrD,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,cAAc,CAAC,QAAQ,CAAC,EAChC,aAAa,oBAAoB,EACjC,OAAO,cAAc,CAAC,MAAM,CAAC,KAC5B,OAAO,CAAC,OAAO,CAgBjB,CAAA"}
+{"version":3,"file":"helpers.d.ts","sourceRoot":"","sources":["../../../src/utils/roles/helpers.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,oBAAoB,EAAE,MAAM,aAAa,CAAA;AAClD,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAgBrD,eAAO,MAAM,kBAAkB,GAC7B,QAAQ,cAAc,CAAC,QAAQ,CAAC,EAChC,aAAa,oBAAoB,EACjC,OAAO,cAAc,CAAC,MAAM,CAAC,KAC5B,OAAO,CAAC,OAAO,CAiBjB,CAAA"}