@flowerforce/flowerbase 1.7.6-beta.1 → 1.7.6-beta.2

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

@@ -1,6 +1,8 @@
+import type { Document } from 'mongodb';
 import { FunctionController } from './interface';
 export declare const mapWatchFilterToChangeStreamMatch: (value: unknown) => unknown;
 export declare const mapWatchFilterToDocumentQuery: (value: unknown) => unknown;
+export declare const shouldSkipReadabilityLookupForChange: (change: Document) => boolean;
 /**
  * > 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;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,kBAoRjC,CAAA"}
+{"version":3,"file":"controller.d.ts","sourceRoot":"","sources":["../../../src/features/functions/controller.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAIvC,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,eAAO,MAAM,oCAAoC,GAAI,QAAQ,QAAQ,YAClC,CAAA;AAEnC;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB,EAAE,kBAyRjC,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 = exports.mapWatchFilterToDocumentQuery = exports.mapWatchFilterToChangeStreamMatch = void 0;
+exports.functionsController = exports.shouldSkipReadabilityLookupForChange = exports.mapWatchFilterToDocumentQuery = exports.mapWatchFilterToChangeStreamMatch = void 0;
 const bson_1 = require("bson");
 const services_1 = require("../../services");
 const context_1 = require("../../utils/context");
@@ -262,6 +262,8 @@ const isReadableDocumentResult = (value) => !!value &&
     typeof value === 'object' &&
     !Array.isArray(value) &&
     Object.keys(value).length > 0;
+const shouldSkipReadabilityLookupForChange = (change) => change.operationType === 'delete';
+exports.shouldSkipReadabilityLookupForChange = shouldSkipReadabilityLookupForChange;
 /**
  * > Creates a pre handler for every query
  * @param app -> the fastify instance
@@ -431,6 +433,10 @@ const functionsController = (app_1, _a) => __awaiter(void 0, [app_1, _a], void 0
                     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;
+                    if ((0, exports.shouldSkipReadabilityLookupForChange)(change)) {
+                        subscriberRes.write(`data: ${serializeEjson(change)}\n\n`);
+                        return;
+                    }
                     const readQuery = subscriber.documentFilter
                         ? { $and: [subscriber.documentFilter, { _id: docId }] }
                         : { _id: docId };

package/dist/services/mongodb-atlas/index.d.ts

@@ -1,4 +1,7 @@
+import { Document } from 'mongodb';
 import { MongodbAtlasFunction } from './model';
+export declare const toWatchMatchFilter: (value: unknown) => unknown;
+export declare const watchPipelineRequestsDelete: (pipeline: Document[]) => boolean;
 declare const MongodbAtlas: MongodbAtlasFunction;
 export default MongodbAtlas;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/mongodb-atlas/index.ts"],"names":[],"mappings":"AAwBA,OAAO,EAGL,oBAAoB,EAErB,MAAM,SAAS,CAAA;AAq0ChB,QAAA,MAAM,YAAY,EAAE,oBAwBlB,CAAA;AAEF,eAAe,YAAY,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/services/mongodb-atlas/index.ts"],"names":[],"mappings":"AAKA,OAAO,EAIL,QAAQ,EAQT,MAAM,SAAS,CAAA;AAOhB,OAAO,EAGL,oBAAoB,EAErB,MAAM,SAAS,CAAA;AAgJhB,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,KAAG,OA0BnD,CAAA;AA4BD,eAAO,MAAM,2BAA2B,GAAI,UAAU,QAAQ,EAAE,YAK5D,CAAA;AAgtCJ,QAAA,MAAM,YAAY,EAAE,oBAwBlB,CAAA;AAEF,eAAe,YAAY,CAAA"}

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

@@ -23,6 +23,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.watchPipelineRequestsDelete = exports.toWatchMatchFilter = void 0;
 const cloneDeep_1 = __importDefault(require("lodash/cloneDeep"));
 const get_1 = __importDefault(require("lodash/get"));
 const isEqual_1 = __importDefault(require("lodash/isEqual"));
@@ -72,6 +73,12 @@ const findOptionKeys = new Set([
     'projection'
 ]);
 const isPlainObject = (value) => !!value && typeof value === 'object' && !Array.isArray(value);
+const isTraversablePlainObject = (value) => {
+    if (!isPlainObject(value))
+        return false;
+    const prototype = Object.getPrototypeOf(value);
+    return prototype === Object.prototype || prototype === null;
+};
 const looksLikeFindOptions = (value) => {
     if (!isPlainObject(value))
         return false;
@@ -114,21 +121,81 @@ const normalizeFindOneAndUpdateOptions = (options) => {
     return Object.assign(Object.assign({}, rest), { returnDocument: returnNewDocument ? 'after' : 'before' });
 };
 const buildAndQuery = (clauses) => clauses.length ? { $and: clauses } : {};
+const watchChangeEventRootKeys = new Set([
+    '_id',
+    'operationType',
+    'clusterTime',
+    'txnNumber',
+    'lsid',
+    'ns',
+    'documentKey',
+    'fullDocument',
+    'updateDescription'
+]);
+const isWatchChangeEventPath = (key) => {
+    if (watchChangeEventRootKeys.has(key))
+        return true;
+    return (key.startsWith('ns.') ||
+        key.startsWith('documentKey.') ||
+        key.startsWith('fullDocument.') ||
+        key.startsWith('updateDescription.'));
+};
+const isWatchOpaqueChangeEventObjectKey = (key) => key === 'ns' || key === 'documentKey' || key === 'fullDocument' || key === 'updateDescription';
 const toWatchMatchFilter = (value) => {
     if (Array.isArray(value)) {
-        return value.map((item) => toWatchMatchFilter(item));
+        return value.map((item) => (0, exports.toWatchMatchFilter)(item));
     }
-    if (!isPlainObject(value))
+    if (!isTraversablePlainObject(value))
         return value;
     return Object.entries(value).reduce((acc, [key, current]) => {
         if (key.startsWith('$')) {
-            acc[key] = toWatchMatchFilter(current);
+            acc[key] = (0, exports.toWatchMatchFilter)(current);
             return acc;
         }
-        acc[`fullDocument.${key}`] = toWatchMatchFilter(current);
+        if (isWatchOpaqueChangeEventObjectKey(key)) {
+            acc[key] = current;
+            return acc;
+        }
+        if (isWatchChangeEventPath(key)) {
+            acc[key] = (0, exports.toWatchMatchFilter)(current);
+            return acc;
+        }
+        acc[`fullDocument.${key}`] = (0, exports.toWatchMatchFilter)(current);
         return acc;
     }, {});
 };
+exports.toWatchMatchFilter = toWatchMatchFilter;
+const isDeleteOperationValue = (value) => {
+    if (typeof value === 'string')
+        return value.toLowerCase() === 'delete';
+    if (isPlainObject(value) && Array.isArray(value.$in)) {
+        return value.$in.some((entry) => isDeleteOperationValue(entry));
+    }
+    if (Array.isArray(value)) {
+        return value.some((entry) => isDeleteOperationValue(entry));
+    }
+    return false;
+};
+const hasDeleteOperationType = (value) => {
+    if (Array.isArray(value)) {
+        return value.some((entry) => hasDeleteOperationType(entry));
+    }
+    if (!isTraversablePlainObject(value))
+        return false;
+    return Object.entries(value).some(([key, current]) => {
+        if (key === 'operationType') {
+            return isDeleteOperationValue(current);
+        }
+        return hasDeleteOperationType(current);
+    });
+};
+const watchPipelineRequestsDelete = (pipeline) => pipeline.some((stage) => {
+    if (!isTraversablePlainObject(stage))
+        return false;
+    const match = stage.$match;
+    return hasDeleteOperationType(match);
+});
+exports.watchPipelineRequestsDelete = watchPipelineRequestsDelete;
 const resolveWatchArgs = (pipelineOrOptions, options) => {
     var _a;
     const inputPipeline = Array.isArray(pipelineOrOptions) ? pipelineOrOptions : [];
@@ -143,7 +210,7 @@ const resolveWatchArgs = (pipelineOrOptions, options) => {
     const _b = rawOptions, { filter: watchFilter, ids } = _b, watchOptions = __rest(_b, ["filter", "ids"]);
     const extraMatches = [];
     if (typeof watchFilter !== 'undefined') {
-        extraMatches.push({ $match: toWatchMatchFilter(watchFilter) });
+        extraMatches.push({ $match: (0, exports.toWatchMatchFilter)(watchFilter) });
     }
     if (Array.isArray(ids)) {
         extraMatches.push({
@@ -861,15 +928,26 @@ const getOperators = (mongo, { rules, dbName, collName, user, run_as_system, mon
                     (0, utils_3.checkDenyOperation)(normalizedRules, collection.collectionName, model_1.CRUD_OPERATIONS.READ);
                     // Apply access filters to initial change stream pipeline
                     const formattedQuery = (0, utils_3.getFormattedQuery)(filters, {}, user);
-                    const watchFormattedQuery = formattedQuery.map((condition) => toWatchMatchFilter(condition));
+                    const watchFormattedQuery = formattedQuery.map((condition) => (0, exports.toWatchMatchFilter)(condition));
+                    const requestedPipeline = [...extraMatches, ...pipeline];
+                    const allowDeleteBypass = (0, exports.watchPipelineRequestsDelete)(requestedPipeline);
                     const firstStep = watchFormattedQuery.length
                         ? {
-                            $match: {
-                                $and: watchFormattedQuery
-                            }
+                            $match: allowDeleteBypass
+                                ? {
+                                    $or: [
+                                        {
+                                            $and: watchFormattedQuery
+                                        },
+                                        { operationType: 'delete' }
+                                    ]
+                                }
+                                : {
+                                    $and: watchFormattedQuery
+                                }
                         }
                         : undefined;
-                    const formattedPipeline = [firstStep, ...extraMatches, ...pipeline].filter(Boolean);
+                    const formattedPipeline = [firstStep, ...requestedPipeline].filter(Boolean);
                     const result = changestreamCollection.watch(formattedPipeline, watchOptions);
                     const originalOn = result.on.bind(result);
                     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flowerforce/flowerbase",
-  "version": "1.7.6-beta.1",
+  "version": "1.7.6-beta.2",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/features/functions/__tests__/watch-filter.test.ts

@@ -1,5 +1,9 @@
 import { ObjectId } from 'mongodb'
-import { mapWatchFilterToChangeStreamMatch, mapWatchFilterToDocumentQuery } from '../controller'
+import {
+  mapWatchFilterToChangeStreamMatch,
+  mapWatchFilterToDocumentQuery,
+  shouldSkipReadabilityLookupForChange
+} from '../controller'
 
 describe('watch filter mapping', () => {
   it('keeps change-event fields untouched and prefixes only document fields', () => {
@@ -113,4 +117,10 @@ describe('watch filter mapping', () => {
     expect(documentQuery._id).toEqual(id)
     expect(documentQuery.operationType).toBeUndefined()
   })
+
+  it('skips readability lookup only for delete change events', () => {
+    expect(shouldSkipReadabilityLookupForChange({ operationType: 'delete' } as any)).toBe(true)
+    expect(shouldSkipReadabilityLookupForChange({ operationType: 'update' } as any)).toBe(false)
+    expect(shouldSkipReadabilityLookupForChange({ operationType: 'insert' } as any)).toBe(false)
+  })
 })

package/src/features/functions/controller.ts

@@ -315,6 +315,9 @@ const isReadableDocumentResult = (value: unknown) =>
   !Array.isArray(value) &&
   Object.keys(value as Record<string, unknown>).length > 0
 
+export const shouldSkipReadabilityLookupForChange = (change: Document) =>
+  change.operationType === 'delete'
+
 /**
  * > Creates a pre handler for every query
  * @param app -> the fastify instance
@@ -524,6 +527,11 @@ export const functionsController: FunctionController = async (
             (change as { fullDocument?: { _id?: unknown } })?.fullDocument?._id
           if (typeof docId === 'undefined') return
 
+          if (shouldSkipReadabilityLookupForChange(change)) {
+            subscriberRes.write(`data: ${serializeEjson(change)}\n\n`)
+            return
+          }
+
           const readQuery = subscriber.documentFilter
             ? ({ $and: [subscriber.documentFilter, { _id: docId }] } as Document)
             : ({ _id: docId } as Document)

package/src/services/mongodb-atlas/__tests__/watch-filter.test.ts

@@ -0,0 +1,78 @@
+import { ObjectId } from 'mongodb'
+import { toWatchMatchFilter, watchPipelineRequestsDelete } from '../index'
+
+describe('mongodb-atlas watch filter mapping', () => {
+  it('keeps change-event keys untouched and prefixes only document keys', () => {
+    const input = {
+      accountId: '699efbc09729e3b79f79e9b4',
+      operationType: 'delete',
+      $or: [
+        { requestId: '69a282a75cd849c244e001ca' },
+        { 'documentKey._id': '69a282a75cd849c244e001ca' }
+      ]
+    }
+
+    const output = toWatchMatchFilter(input)
+    expect(output).toEqual({
+      'fullDocument.accountId': '699efbc09729e3b79f79e9b4',
+      operationType: 'delete',
+      $or: [
+        { 'fullDocument.requestId': '69a282a75cd849c244e001ca' },
+        { 'documentKey._id': '69a282a75cd849c244e001ca' }
+      ]
+    })
+
+    const outputJson = JSON.stringify(output)
+    expect(outputJson).not.toContain('fullDocument.operationType')
+    expect(outputJson).not.toContain('fullDocument.documentKey.')
+  })
+
+  it('preserves ObjectId values in watch filter mapping', () => {
+    const id = new ObjectId('69a282a75cd849c244e001ca')
+    const input = {
+      operationType: 'update',
+      'documentKey._id': id,
+      requestId: id
+    }
+
+    const output = toWatchMatchFilter(input) as Record<string, unknown>
+    expect(output.operationType).toBe('update')
+    expect(output['documentKey._id']).toEqual(id)
+    expect(output['fullDocument.requestId']).toEqual(id)
+  })
+
+  it('detects delete operation requests in watch pipeline matches', () => {
+    expect(
+      watchPipelineRequestsDelete([
+        {
+          $match: {
+            $or: [
+              { operationType: 'insert' },
+              { operationType: 'delete' }
+            ]
+          }
+        }
+      ] as any)
+    ).toBe(true)
+
+    expect(
+      watchPipelineRequestsDelete([
+        {
+          $match: {
+            operationType: { $in: ['insert', 'replace'] }
+          }
+        }
+      ] as any)
+    ).toBe(false)
+
+    expect(
+      watchPipelineRequestsDelete([
+        {
+          $project: {
+            operationType: 1
+          }
+        }
+      ] as any)
+    ).toBe(false)
+  })
+})

package/src/services/mongodb-atlas/index.ts

@@ -79,6 +79,12 @@ const findOptionKeys = new Set([
 const isPlainObject = (value: unknown): value is Record<string, unknown> =>
   !!value && typeof value === 'object' && !Array.isArray(value)
 
+const isTraversablePlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (!isPlainObject(value)) return false
+  const prototype = Object.getPrototypeOf(value)
+  return prototype === Object.prototype || prototype === null
+}
+
 const looksLikeFindOptions = (value: unknown) => {
   if (!isPlainObject(value)) return false
   return Object.keys(value).some((key) => findOptionKeys.has(key))
@@ -140,23 +146,92 @@ const normalizeFindOneAndUpdateOptions = (
 const buildAndQuery = (clauses: MongoFilter<Document>[]): MongoFilter<Document> =>
   clauses.length ? { $and: clauses } : {}
 
-const toWatchMatchFilter = (value: unknown): unknown => {
+const watchChangeEventRootKeys = new Set([
+  '_id',
+  'operationType',
+  'clusterTime',
+  'txnNumber',
+  'lsid',
+  'ns',
+  'documentKey',
+  'fullDocument',
+  'updateDescription'
+])
+
+const isWatchChangeEventPath = (key: string) => {
+  if (watchChangeEventRootKeys.has(key)) return true
+  return (
+    key.startsWith('ns.') ||
+    key.startsWith('documentKey.') ||
+    key.startsWith('fullDocument.') ||
+    key.startsWith('updateDescription.')
+  )
+}
+
+const isWatchOpaqueChangeEventObjectKey = (key: string) =>
+  key === 'ns' || key === 'documentKey' || key === 'fullDocument' || key === 'updateDescription'
+
+export const toWatchMatchFilter = (value: unknown): unknown => {
   if (Array.isArray(value)) {
     return value.map((item) => toWatchMatchFilter(item))
   }
 
-  if (!isPlainObject(value)) return value
+  if (!isTraversablePlainObject(value)) return value
 
   return Object.entries(value).reduce<Record<string, unknown>>((acc, [key, current]) => {
     if (key.startsWith('$')) {
       acc[key] = toWatchMatchFilter(current)
       return acc
     }
+
+    if (isWatchOpaqueChangeEventObjectKey(key)) {
+      acc[key] = current
+      return acc
+    }
+
+    if (isWatchChangeEventPath(key)) {
+      acc[key] = toWatchMatchFilter(current)
+      return acc
+    }
+
     acc[`fullDocument.${key}`] = toWatchMatchFilter(current)
     return acc
   }, {})
 }
 
+const isDeleteOperationValue = (value: unknown): boolean => {
+  if (typeof value === 'string') return value.toLowerCase() === 'delete'
+  if (isPlainObject(value) && Array.isArray((value as { $in?: unknown[] }).$in)) {
+    return (value as { $in: unknown[] }).$in.some((entry) => isDeleteOperationValue(entry))
+  }
+  if (Array.isArray(value)) {
+    return value.some((entry) => isDeleteOperationValue(entry))
+  }
+  return false
+}
+
+const hasDeleteOperationType = (value: unknown): boolean => {
+  if (Array.isArray(value)) {
+    return value.some((entry) => hasDeleteOperationType(entry))
+  }
+
+  if (!isTraversablePlainObject(value)) return false
+
+  return Object.entries(value).some(([key, current]) => {
+    if (key === 'operationType') {
+      return isDeleteOperationValue(current)
+    }
+    return hasDeleteOperationType(current)
+  })
+}
+
+export const watchPipelineRequestsDelete = (pipeline: Document[]) =>
+  pipeline.some((stage) => {
+    if (!isTraversablePlainObject(stage)) return false
+    const match = (stage as { $match?: unknown }).$match
+    return hasDeleteOperationType(match)
+  })
+
 type RealmCompatibleWatchOptions = Document & {
   filter?: MongoFilter<Document>
   ids?: unknown[]
@@ -1017,15 +1092,26 @@ const getOperators: GetOperatorsFunction = (
             (condition) => toWatchMatchFilter(condition) as MongoFilter<Document>
           )
 
+          const requestedPipeline = [...extraMatches, ...pipeline]
+          const allowDeleteBypass = watchPipelineRequestsDelete(requestedPipeline)
           const firstStep = watchFormattedQuery.length
             ? {
-              $match: {
-                $and: watchFormattedQuery
-              }
+              $match: allowDeleteBypass
+                ? {
+                  $or: [
+                    {
+                      $and: watchFormattedQuery
+                    },
+                    { operationType: 'delete' }
+                  ]
+                }
+                : {
+                  $and: watchFormattedQuery
+                }
             }
             : undefined
 
-          const formattedPipeline = [firstStep, ...extraMatches, ...pipeline].filter(Boolean) as Document[]
+          const formattedPipeline = [firstStep, ...requestedPipeline].filter(Boolean) as Document[]
 
           const result = changestreamCollection.watch(formattedPipeline, watchOptions)
           const originalOn = result.on.bind(result)