@flowerforce/flowerbase 1.7.5 → 1.7.6-beta.1

package/src/monitoring/ui.shared.js

@@ -52,7 +52,8 @@
       month: '2-digit',
       day: '2-digit',
       hour: '2-digit',
-      minute: '2-digit'
+      minute: '2-digit',
+      second: '2-digit'
     });
   };
 
@@ -124,7 +125,7 @@
     return output || ' ';
   };
 
-  const highlightJson = (text) => {
+  const highlightJsonText = (text) => {
     if (!text) return ' ';
     const regex = /"(?:\\.|[^"\\])*"(?=\s*:)|"(?:\\.|[^"\\])*"|(-?\d+(?:\.\d+)?(?:[eE][+\-]?\d+)?)|\btrue\b|\bfalse\b|\bnull\b/g;
     let output = '';
@@ -149,6 +150,239 @@
     return output || ' ';
   };
 
+  const renderJsonPrimitive = (value) => {
+    if (typeof value === 'string') {
+      return '<span class="token string">' + escapeHtml(JSON.stringify(value)) + '</span>';
+    }
+    if (typeof value === 'number') {
+      return '<span class="token number">' + escapeHtml(String(value)) + '</span>';
+    }
+    if (typeof value === 'boolean' || value === null) {
+      return '<span class="token literal">' + escapeHtml(String(value)) + '</span>';
+    }
+    return '<span class="token literal">' + escapeHtml(safeStringify(value)) + '</span>';
+  };
+
+  const renderJsonKey = (key) => {
+    return '<span class="token key">' + escapeHtml(JSON.stringify(key)) + '</span><span class="json-punct">: </span>';
+  };
+
+  const renderJsonLine = (depth, content, className) => {
+    return '<span class="json-line ' + (className || '') + '" style="--json-depth:' + depth + ';">' + content + '</span>';
+  };
+
+  const getJsonSummaryLabel = (value) => {
+    if (Array.isArray(value)) {
+      const size = value.length;
+      return size + ' item' + (size === 1 ? '' : 's');
+    }
+    const size = Object.keys(value || {}).length;
+    return size + ' key' + (size === 1 ? '' : 's');
+  };
+
+  const renderJsonNode = (value, depth, keyHtml, withComma) => {
+    if (Array.isArray(value) || (value && typeof value === 'object')) {
+      const isArray = Array.isArray(value);
+      const items = isArray
+        ? value.map((item, index) => ({ key: String(index), value: item }))
+        : Object.keys(value).map((key) => ({ key, value: value[key] }));
+      const openChar = isArray ? '[' : '{';
+      const closeChar = isArray ? ']' : '}';
+      if (!items.length) {
+        return renderJsonLine(
+          depth,
+          '<span class="json-toggle-spacer"></span>' +
+            (keyHtml || '') +
+            '<span class="json-brace">' + openChar + closeChar + '</span>' +
+            (withComma ? '<span class="json-punct">,</span>' : ''),
+          'json-single'
+        );
+      }
+      const children = items
+        .map((entry, index) =>
+          renderJsonNode(
+            entry.value,
+            depth + 1,
+            isArray ? '' : renderJsonKey(entry.key),
+            index < items.length - 1
+          )
+        )
+        .join('');
+      const summary = escapeHtml(getJsonSummaryLabel(value));
+      return (
+        '<span class="json-node">' +
+          renderJsonLine(
+            depth,
+            '<button type="button" class="json-toggle" data-json-toggle aria-expanded="true" title="Collapse">▾</button>' +
+              (keyHtml || '') +
+              '<span class="json-brace">' + openChar + '</span>' +
+              '<span class="json-summary">' +
+                '<span class="json-ellipsis"> … </span>' +
+                '<span class="token literal">' + summary + '</span> ' +
+                '<span class="json-brace">' + closeChar + '</span>' +
+                (withComma ? '<span class="json-punct">,</span>' : '') +
+              '</span>',
+            'json-open'
+          ) +
+          '<span class="json-children">' + children + '</span>' +
+          renderJsonLine(
+            depth,
+            '<span class="json-toggle-spacer"></span><span class="json-brace">' + closeChar + '</span>' +
+              (withComma ? '<span class="json-punct">,</span>' : ''),
+            'json-close'
+          ) +
+        '</span>'
+      );
+    }
+    return renderJsonLine(
+      depth,
+      '<span class="json-toggle-spacer"></span>' +
+        (keyHtml || '') +
+        renderJsonPrimitive(value) +
+        (withComma ? '<span class="json-punct">,</span>' : ''),
+      'json-single'
+    );
+  };
+
+  const renderCollapsibleJson = (text) => {
+    if (!text) return ' ';
+    const parsed = JSON.parse(text);
+    return '<span class="json-tree">' + renderJsonNode(parsed, 0, '', false) + '</span>';
+  };
+
+  const highlightJson = (text, options) => {
+    if (!text) return ' ';
+    const collapsible = !!(options && options.collapsible);
+    if (!collapsible) return highlightJsonText(text);
+    try {
+      return renderCollapsibleJson(text);
+    } catch (err) {
+      return highlightJsonText(text);
+    }
+  };
+
+  const bindJsonToggleHandlers = () => {
+    if (state.__jsonToggleBound) return;
+    state.__jsonToggleBound = true;
+    document.addEventListener('click', (event) => {
+      const toggle = event.target && event.target.closest
+        ? event.target.closest('[data-json-toggle]')
+        : null;
+      if (!toggle) return;
+      const node = toggle.closest('.json-node');
+      if (!node) return;
+      event.preventDefault();
+      const collapsed = node.classList.toggle('is-collapsed');
+      toggle.setAttribute('aria-expanded', collapsed ? 'false' : 'true');
+      toggle.setAttribute('title', collapsed ? 'Expand' : 'Collapse');
+    });
+  };
+
+  bindJsonToggleHandlers();
+
+  const getJsonViewerStore = () => {
+    if (!state.__jsonViewerStore || typeof state.__jsonViewerStore.get !== 'function') {
+      state.__jsonViewerStore = new WeakMap();
+    }
+    return state.__jsonViewerStore;
+  };
+
+  const getCodeMirrorLib = () => {
+    if (typeof window === 'undefined') return null;
+    const codeMirror = window.CodeMirror;
+    if (!codeMirror || typeof codeMirror !== 'function') return null;
+    return codeMirror;
+  };
+
+  const clearJsonViewer = (element, placeholder) => {
+    if (!element) return;
+    const store = getJsonViewerStore();
+    const editor = store.get(element);
+    if (editor && typeof editor.getWrapperElement === 'function') {
+      const wrapper = editor.getWrapperElement();
+      if (wrapper && wrapper.parentNode === element) {
+        wrapper.parentNode.removeChild(wrapper);
+      }
+      store.delete(element);
+    }
+    element.classList.remove('cm-json-host');
+    element.classList.remove('json-highlight');
+    element.textContent = placeholder || '';
+  };
+
+  const renderJsonViewer = (element, value, options) => {
+    if (!element) return;
+    const opts = options || {};
+    let text = '';
+    let mode = { name: 'javascript', json: true };
+
+    if (typeof value === 'string') {
+      text = value;
+      const trimmed = text.trim();
+      if (trimmed) {
+        try {
+          const parsed = JSON.parse(trimmed);
+          if (opts.pretty !== false) {
+            text = JSON.stringify(parsed, null, 2);
+          }
+        } catch (err) {
+          mode = 'text/plain';
+        }
+      } else {
+        mode = 'text/plain';
+      }
+    } else if (value === undefined || value === null) {
+      text = '';
+      mode = 'text/plain';
+    } else {
+      try {
+        text = JSON.stringify(value, null, 2);
+      } catch (err) {
+        text = safeStringify(value);
+        mode = 'text/plain';
+      }
+    }
+
+    const CodeMirrorLib = getCodeMirrorLib();
+    if (!CodeMirrorLib) {
+      element.classList.add('json-highlight');
+      element.innerHTML = highlightJson(text || '', { collapsible: opts.collapsible !== false });
+      return;
+    }
+
+    const store = getJsonViewerStore();
+    let editor = store.get(element);
+    if (!editor) {
+      editor = CodeMirrorLib((node) => {
+        element.innerHTML = '';
+        element.appendChild(node);
+      }, {
+        lineNumbers: true,
+        lineWrapping: false,
+        readOnly: 'nocursor',
+        foldGutter: true,
+        gutters: ['CodeMirror-linenumbers', 'CodeMirror-foldgutter'],
+        mode
+      });
+      store.set(element, editor);
+    }
+
+    const collapsible = opts.collapsible !== false;
+    editor.setOption('lineNumbers', opts.lineNumbers !== false);
+    editor.setOption('readOnly', opts.readOnly === false ? false : 'nocursor');
+    editor.setOption('foldGutter', collapsible);
+    editor.setOption('gutters', collapsible
+      ? ['CodeMirror-linenumbers', 'CodeMirror-foldgutter']
+      : ['CodeMirror-linenumbers']);
+    editor.setOption('mode', mode);
+    editor.setValue(text || '');
+    if (typeof editor.clearHistory === 'function') editor.clearHistory();
+    if (typeof editor.refresh === 'function') editor.refresh();
+
+    element.classList.remove('json-highlight');
+    element.classList.add('cm-json-host');
+  };
+
   const setActiveTab = (tab) => {
     if (!dom.tabButtons || !dom.tabPanels) return;
     dom.tabButtons.forEach((item) => {
@@ -172,7 +406,9 @@
       escapeHtml,
       safeStringify,
       highlightCode,
-      highlightJson
+      highlightJson,
+      renderJsonViewer,
+      clearJsonViewer
     },
     helpers: {
       setActiveTab

package/src/monitoring/ui.triggers.js

@@ -15,7 +15,7 @@
   dom.refreshTriggers = document.getElementById('refreshTriggers');
 
   const { triggerList, triggerDetail, triggerFunctionButton, refreshTriggers } = dom;
-  const { api, highlightJson } = utils;
+  const { api, renderJsonViewer } = utils;
   const { setActiveTab } = helpers;
 
   const buildTriggerFunctionMap = (items) => {
@@ -71,8 +71,7 @@
       });
     }
     if (triggerDetail) {
-      triggerDetail.classList.add('json-highlight');
-      triggerDetail.innerHTML = highlightJson(JSON.stringify(entry, null, 2) || '');
+      renderJsonViewer(triggerDetail, entry, { collapsible: true });
     }
     if (triggerFunctionButton) {
       if (fnName) {

package/src/monitoring/ui.users.js

@@ -66,7 +66,7 @@
     openCreateUser,
     closeCreateUser
   } = dom;
-  const { api, formatDateTime, highlightJson } = utils;
+  const { api, formatDateTime, renderJsonViewer, clearJsonViewer } = utils;
   const { setActiveTab } = helpers;
 
   const USER_DETAIL_PLACEHOLDER = 'select a user to inspect';
@@ -92,23 +92,19 @@
   const setUserDetailContent = (entry) => {
     if (!userDetail) return;
     if (!entry) {
-      userDetail.classList.remove('json-highlight');
-      userDetail.textContent = USER_DETAIL_PLACEHOLDER;
+      clearJsonViewer(userDetail, USER_DETAIL_PLACEHOLDER);
       return;
     }
-    userDetail.classList.add('json-highlight');
-    userDetail.innerHTML = highlightJson(JSON.stringify(entry, null, 2) || '');
+    renderJsonViewer(userDetail, entry, { collapsible: true });
   };
 
   const setUserConfigContent = (element, value, placeholder) => {
     if (!element) return;
     if (!value) {
-      element.classList.remove('json-highlight');
-      element.textContent = placeholder;
+      clearJsonViewer(element, placeholder);
       return;
     }
-    element.classList.add('json-highlight');
-    element.innerHTML = highlightJson(JSON.stringify(value, null, 2) || '');
+    renderJsonViewer(element, value, { collapsible: true });
   };
 
   const renderUserConfig = () => {

package/src/monitoring/utils.ts

@@ -2,7 +2,7 @@ import fs from 'node:fs'
 import path from 'node:path'
 import type { FastifyInstance, FastifyRequest } from 'fastify'
 import { ObjectId } from 'mongodb'
-import { AUTH_CONFIG, DB_NAME, DEFAULT_CONFIG } from '../constants'
+import { AUTH_CONFIG, AUTH_DB_NAME, DB_NAME, DEFAULT_CONFIG } from '../constants'
 import type { Rules } from '../features/rules/interface'
 import { getValidRule } from '../services/mongodb-atlas/utils'
 import { checkApplyWhen } from '../utils/roles/machines/utils'
@@ -380,7 +380,8 @@ export const resolveUserContext = async (
   if (!userId) return undefined
   const normalizedUserId = userId.trim()
 
-  const db = app.mongo.client.db(DB_NAME)
+  const authDb = app.mongo.client.db(AUTH_DB_NAME)
+  const customDb = app.mongo.client.db(DB_NAME)
   const authCollection = AUTH_CONFIG.authCollection ?? 'auth_users'
   const userCollection = AUTH_CONFIG.userCollection
   const userIdField = AUTH_CONFIG.user_id_field ?? 'id'
@@ -388,14 +389,14 @@ export const resolveUserContext = async (
   const authSelector = isObjectId
     ? { _id: new ObjectId(normalizedUserId) }
     : { id: normalizedUserId }
-  const authUser = await db.collection(authCollection).findOne(authSelector)
+  const authUser = await authDb.collection(authCollection).findOne(authSelector)
 
   let customUser: Record<string, unknown> | null = null
   if (userCollection) {
     const customSelector = { [userIdField]: normalizedUserId }
-    customUser = await db.collection(userCollection).findOne(customSelector)
+    customUser = await customDb.collection(userCollection).findOne(customSelector)
     if (!customUser && isObjectId) {
-      customUser = await db.collection(userCollection).findOne({ _id: new ObjectId(normalizedUserId) })
+      customUser = await customDb.collection(userCollection).findOne({ _id: new ObjectId(normalizedUserId) })
     }
   }
 

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

@@ -7,7 +7,6 @@ import {
   ChangeStreamOptions,
   ClientSession,
   ClientSessionOptions,
-  Collection,
   Document,
   EventsDescription,
   FindOneAndUpdateOptions,
@@ -22,6 +21,7 @@ import { buildRulesMeta } from '../../monitoring/utils'
 import { checkValidation } from '../../utils/roles/machines'
 import { getWinningRole } from '../../utils/roles/machines/utils'
 import { emitServiceEvent } from '../monitoring'
+import { CHANGESTREAM } from '../../constants'
 import {
   CRUD_OPERATIONS,
   GetOperatorsFunction,
@@ -388,9 +388,10 @@ const areUpdatedFieldsAllowed = (
 }
 
 const getOperators: GetOperatorsFunction = (
-  collection,
-  { rules, collName, user, run_as_system, monitoringOrigin }
+  mongo,
+  { rules, dbName, collName, user, run_as_system, monitoringOrigin }
 ) => {
+  const collection = mongo.client.db(dbName).collection(collName)
   const normalizedRules: Rules = rules ?? ({} as Rules)
   const collectionRules = normalizedRules[collName]
   const filters = collectionRules?.filters ?? []
@@ -996,6 +997,7 @@ const getOperators: GetOperatorsFunction = (
      * This allows fine-grained control over what change events a user can observe, based on roles and filters.
      */
     watch: (pipelineOrOptions = [], options) => {
+      const changestreamCollection = mongo[CHANGESTREAM].client.db(dbName).collection(collName)
       try {
         const {
           pipeline,
@@ -1025,7 +1027,7 @@ const getOperators: GetOperatorsFunction = (
 
           const formattedPipeline = [firstStep, ...extraMatches, ...pipeline].filter(Boolean) as Document[]
 
-          const result = collection.watch(formattedPipeline, watchOptions)
+          const result = changestreamCollection.watch(formattedPipeline, watchOptions)
           const originalOn = result.on.bind(result)
 
           /**
@@ -1107,7 +1109,7 @@ const getOperators: GetOperatorsFunction = (
         }
 
         // System mode: no filtering applied
-        const result = collection.watch([...extraMatches, ...pipeline], watchOptions)
+        const result = changestreamCollection.watch([...extraMatches, ...pipeline], watchOptions)
         emitMongoEvent('watch')
         return result
       } catch (error) {
@@ -1387,15 +1389,10 @@ const MongodbAtlas: MongodbAtlasFunction = (
   db: (dbName: string) => {
     return {
       collection: (collName: string) => {
-        const mongoClient = app.mongo.client as unknown as {
-          db: (database: string) => {
-            collection: (name: string) => Collection<Document>
-          }
-        }
-        const collection: Collection<Document> = mongoClient.db(dbName).collection(collName)
-        return getOperators(collection, {
-          rules,
+        return getOperators(app.mongo, {
+          dbName,
           collName,
+          rules,
           user,
           run_as_system,
           monitoringOrigin: monitoring?.invokedFrom

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

@@ -44,9 +44,10 @@ export type GetValidRuleParams<T extends Role | Filter> = {
 type Method<T extends keyof Collection<Document>> = Collection<Document>[T]
 
 export type GetOperatorsFunction = (
-  collection: Collection<Document>,
+  mongoInstance: FastifyInstance["mongo"],
   {
     rules,
+    dbName,
     collName,
     user,
     run_as_system,
@@ -55,6 +56,7 @@ export type GetOperatorsFunction = (
     user?: User
     rules?: Rules
     run_as_system?: boolean
+    dbName: string
     collName: string
     monitoringOrigin?: string
   }

package/src/shared/handleUserDeletion.ts

@@ -1,5 +1,5 @@
 import { ObjectId } from "bson"
-import { AUTH_CONFIG, DB_NAME } from "../constants"
+import { AUTH_CONFIG, AUTH_DB_NAME } from "../constants"
 import { emitServiceEvent } from "../services/monitoring"
 import { HandleUserDeletion } from "./models/handleUserDeletion.model"
 
@@ -33,7 +33,7 @@ const handleUserDeletion: HandleUserDeletion = (app, opt) => async ({ id, email
 
         const { authCollection } = AUTH_CONFIG
         const mongo = app?.mongo
-        const db = mongo.client.db(DB_NAME)
+        const db = mongo.client.db(AUTH_DB_NAME)
         const collection = db.collection<Record<string, unknown>>(authCollection!)
         let query: Record<string, unknown>
 

package/src/shared/handleUserRegistration.ts

@@ -1,8 +1,8 @@
-import { AUTH_CONFIG, DB_NAME } from "../constants"
+import { AUTH_CONFIG, AUTH_DB_NAME } from "../constants"
+import { emitServiceEvent } from "../services/monitoring"
 import { StateManager } from "../state"
 import { GenerateContext } from "../utils/context"
 import { generateToken, hashPassword } from "../utils/crypto"
-import { emitServiceEvent } from "../services/monitoring"
 import { HandleUserRegistration } from "./models/handleUserRegistration.model"
 
 /**
@@ -35,7 +35,7 @@ const handleUserRegistration: HandleUserRegistration = (app, opt) => async ({ em
         const runConfirmationFunction = localUserpassConfig?.runConfirmationFunction === true
         const confirmationFunctionName = localUserpassConfig?.confirmationFunctionName
         const mongo = app?.mongo
-        const db = mongo.client.db(DB_NAME)
+        const db = mongo.client.db(AUTH_DB_NAME)
         const hashedPassword = await hashPassword(password)
 
         const existingUser = await db?.collection(authCollection!).findOne({ email })

package/src/types/fastify-raw-body.d.ts

@@ -1,6 +1,5 @@
 import 'fastify'
 import type { FastifyJWT } from '@fastify/jwt'
-import { Db, MongoClient } from 'mongodb'
 
 declare module 'fastify' {
   interface FastifyRequest {
@@ -11,12 +10,4 @@ declare module 'fastify' {
   interface FastifyContextConfig {
     rawBody?: boolean
   }
-
-  interface FastifyInstance {
-    mongo?: {
-      client: MongoClient
-      db?: Db
-      ObjectId: typeof import('mongodb').ObjectId
-    }
-  }
 }

package/src/utils/__tests__/mongodbCSFLE.test.ts

@@ -0,0 +1,105 @@
+import { UUID } from 'mongodb'
+import type { EncryptionSchemas } from '../../features/encryption/interface'
+import { buildSchemaMap } from '../initializer/mongodbCSFLE'
+
+describe('buildSchemaMap', () => {
+  const genericSchemas: EncryptionSchemas = {
+    'appDb.records': {
+      bsonType: 'object',
+      encryptMetadata: {
+        keyAlias: 'root-key'
+      },
+      properties: {
+        publicText: {
+          encrypt: {
+            bsonType: 'string',
+            algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Random'
+          }
+        },
+        protectedText: {
+          encrypt: {
+            bsonType: 'string',
+            algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+            keyAlias: 'root-key'
+          }
+        },
+        nestedObject: {
+          bsonType: 'object',
+          encryptMetadata: { keyAlias: 'nested-key' },
+          properties: {
+            deepObject: {
+              bsonType: 'object',
+              properties: {
+                deepSecret: {
+                  encrypt: {
+                    bsonType: 'string',
+                    algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Random',
+                    keyAlias: 'deep-key'
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+
+  it('resolves keyAlias to keyId for root and nested schemas', () => {
+    const rootKeyId = new UUID()
+    const nestedKeyId = new UUID()
+    const deepKeyId = new UUID()
+
+    const schemaMap = buildSchemaMap(genericSchemas, [
+      { dataKeyAlias: 'root-key', dataKeyId: rootKeyId },
+      { dataKeyAlias: 'nested-key', dataKeyId: nestedKeyId },
+      { dataKeyAlias: 'deep-key', dataKeyId: deepKeyId }
+    ])
+
+    expect(schemaMap['appDb.records']).toEqual({
+      bsonType: 'object',
+      encryptMetadata: { keyId: [rootKeyId] },
+      properties: {
+        publicText: {
+          encrypt: {
+            bsonType: 'string',
+            algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Random'
+          }
+        },
+        protectedText: {
+          encrypt: {
+            bsonType: 'string',
+            algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Deterministic',
+            keyId: [rootKeyId]
+          }
+        },
+        nestedObject: {
+          bsonType: 'object',
+          encryptMetadata: { keyId: [nestedKeyId] },
+          properties: {
+            deepObject: {
+              bsonType: 'object',
+              properties: {
+                deepSecret: {
+                  encrypt: {
+                    bsonType: 'string',
+                    algorithm: 'AEAD_AES_256_CBC_HMAC_SHA_512-Random',
+                    keyId: [deepKeyId]
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    })
+  })
+
+  it('throws when nested keyAlias cannot be resolved', () => {
+    const rootKeyId = new UUID()
+
+    expect(() =>
+      buildSchemaMap(genericSchemas, [{ dataKeyAlias: 'root-key', dataKeyId: rootKeyId }])
+    ).toThrow('Key with alias deep-key could not be found in the Key Vault.')
+  })
+})

package/src/utils/__tests__/operators.test.ts

@@ -1,3 +1,4 @@
+import { ObjectId } from 'mongodb'
 import { operators } from '../rules-matcher/utils'
 
 describe('operators', () => {
@@ -8,10 +9,15 @@ describe('operators', () => {
   it('should check equals values', () => {
     expect(operators.$eq('a', 'a')).toBe(true)
     expect(!operators.$eq('a', 'b')).toBe(true)
+    const id = new ObjectId()
+    expect(operators.$eq(id, id.toHexString())).toBe(true)
+    expect(operators.$eq(id, new ObjectId(id.toHexString()))).toBe(true)
   })
   it('should check different values', () => {
     expect(operators.$ne('a', 'a')).toBe(false)
     expect(operators.$ne('a', 'b')).toBe(true)
+    const id = new ObjectId()
+    expect(operators.$ne(id, id.toHexString())).toBe(false)
   })
   it('should check string length values', () => {
     // test $strGt
@@ -69,6 +75,8 @@ describe('operators', () => {
     expect(operators.$in([3, 4], [3, 4, 5])).toBe(true)
     expect(operators.$in([3, 6], [3, 4, 5])).toBe(true)
     expect(operators.$in({ name: 'ciao' }, [{ name: 'ciao' }, 4, 5])).toBe(false)
+    const id = new ObjectId()
+    expect(operators.$in(id, [id.toHexString()])).toBe(true)
   })
   it("should check if a value isn't in an array", () => {
     expect(operators.$nin(2, [3])).toBe(true)
@@ -76,6 +84,8 @@ describe('operators', () => {
     expect(operators.$nin([3, 4], [3, 4, 5])).toBe(false)
     expect(operators.$nin([3, 6], [3, 4, 5])).toBe(false)
     expect(operators.$nin({ name: 'ciao' }, [{ name: 'ciao' }, 4, 5])).toBe(true)
+    const id = new ObjectId()
+    expect(operators.$nin(id, [id.toHexString()])).toBe(false)
   })
   it('should find all values in an array', () => {
     expect(operators.$all(2, [3])).toBe(false)
@@ -85,6 +95,8 @@ describe('operators', () => {
     expect(operators.$all([3, 6], [3, 4, 5])).toBe(false)
     expect(operators.$all({ name: 'ciao' }, [{ name: 'ciao' }, 4, 5])).toBe(false)
     expect(operators.$all([{ name: 'ciao' }, 4, 5], [{ name: 'ciao' }, 4, 5])).toBe(false)
+    const id = new ObjectId()
+    expect(operators.$all([id], [id.toHexString()])).toBe(true)
   })
   it('should check array size', () => {
     expect(operators.$size([1, 2, 3], 3)).toBe(true)
@@ -100,4 +112,16 @@ describe('operators', () => {
     expect(operators.$regex('1234567890', numberRegex)).toBe(true)
     expect(operators.$regex('12345r', numberRegex)).toBe(false)
   })
+
+  it('should support %stringToOid conversion operator', () => {
+    const id = new ObjectId()
+    expect(operators['%stringToOid'](id, id.toHexString())).toBe(true)
+    expect(operators['%stringToOid'](id, 'not-an-object-id')).toBe(false)
+  })
+
+  it('should support %oidToString conversion operator', () => {
+    const id = new ObjectId()
+    expect(operators['%oidToString'](id.toHexString(), id)).toBe(true)
+    expect(operators['%oidToString']('not-matching', id)).toBe(false)
+  })
 })