@flowerforce/flowerbase 1.7.5 → 1.7.6-beta.0

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)
+  })
 })

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

@@ -1,3 +1,4 @@
+import { ObjectId } from 'mongodb'
 import rulesMatcherUtils from '../rules-matcher/utils'
 
 describe('rule function', () => {
@@ -46,4 +47,42 @@ describe('rule function', () => {
       rulesMatcherUtils.rule(missingOperatorBlock, mockData, mockOptions)
     }).toThrow('Error missing operator:$notFoundOperator')
   })
+
+  it('should support %stringToOid with $ref values', () => {
+    const companyId = new ObjectId()
+    const data = {
+      user: {
+        _id: companyId
+      },
+      auth: {
+        company: companyId.toHexString()
+      }
+    }
+
+    const result = rulesMatcherUtils.rule({ _id: { '%stringToOid': '$ref:auth.company' } }, data, {
+      prefix: 'user'
+    })
+
+    expect(result.valid).toBe(true)
+    expect(result.name).toBe('user._id___%stringToOid')
+  })
+
+  it('should support %oidToString with $ref values', () => {
+    const authId = new ObjectId()
+    const data = {
+      user: {
+        authId: authId.toHexString()
+      },
+      auth: {
+        id: authId
+      }
+    }
+
+    const result = rulesMatcherUtils.rule({ authId: { '%oidToString': '$ref:auth.id' } }, data, {
+      prefix: 'user'
+    })
+
+    expect(result.valid).toBe(true)
+    expect(result.name).toBe('user.authId___%oidToString')
+  })
 })

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

@@ -22,6 +22,8 @@ describe('Enums and Types', () => {
     expect(RulesOperators.$nin).toBe('$nin')
     expect(RulesOperators.$all).toBe('$all')
     expect(RulesOperators.$regex).toBe('$regex')
+    expect(RulesOperators['%stringToOid']).toBe('%stringToOid')
+    expect(RulesOperators['%oidToString']).toBe('%oidToString')
   })
 
   it('should validate RulesOperatorsInArray type', () => {

package/src/utils/initializer/exposeRoutes.ts

@@ -2,7 +2,7 @@ import { uptime } from 'node:process'
 import { FastifyInstance } from 'fastify'
 import { RegistrationDto } from '../../auth/providers/local-userpass/dtos'
 import { AUTH_ENDPOINTS, REGISTRATION_SCHEMA } from '../../auth/utils'
-import { API_VERSION, AUTH_CONFIG, DB_NAME, DEFAULT_CONFIG } from '../../constants'
+import { API_VERSION, AUTH_CONFIG, AUTH_DB_NAME, DEFAULT_CONFIG } from '../../constants'
 import { PROVIDER } from '../../shared/models/handleUserRegistration.model'
 import { hashPassword } from '../crypto'
 
@@ -46,7 +46,7 @@ export const exposeRoutes = async (fastify: FastifyInstance) => {
       schema: REGISTRATION_SCHEMA
     }, async function (req, res) {
       const { authCollection } = AUTH_CONFIG
-      const db = fastify.mongo.client.db(DB_NAME)
+      const db = fastify.mongo.client.db(AUTH_DB_NAME)
       const { email, password } = req.body
       const hashedPassword = await hashPassword(password)
       const now = new Date()

package/src/utils/rules-matcher/interface.ts

@@ -331,6 +331,8 @@ export type Operators = {
    * @returns
    */
   $regex: OperatorsFunction
+  '%stringToOid': OperatorsFunction
+  '%oidToString': OperatorsFunction
 }
 
 export enum RulesOperators {
@@ -349,7 +351,9 @@ export enum RulesOperators {
   $nin = '$nin',
   $all = '$all',
   $size = '$size',
-  $regex = '$regex'
+  $regex = '$regex',
+  '%stringToOid' = '%stringToOid',
+  '%oidToString' = '%oidToString'
 }
 
 export type RulesOperatorsInArray<T> = Partial<{

package/src/utils/rules-matcher/utils.ts

@@ -1,9 +1,59 @@
+import { ObjectId } from 'bson'
 import _get from 'lodash/get'
-import _intersection from 'lodash/intersection'
 import _trimStart from 'lodash/trimStart'
 import { Operators, RulesMatcherUtils, RulesObject } from './interface'
 
 const EMPTY_STRING_REGEXP = /^\s*$/
+const HEX_24_REGEXP = /^[a-fA-F0-9]{24}$/
+
+const toObjectIdHex = (value: unknown): string | null => {
+  if (value instanceof ObjectId) {
+    return value.toHexString()
+  }
+
+  if (typeof value === 'string') {
+    if (!HEX_24_REGEXP.test(value) || !ObjectId.isValid(value)) {
+      return null
+    }
+    return new ObjectId(value).toHexString()
+  }
+
+  if (!value || typeof value !== 'object') {
+    return null
+  }
+
+  const maybeObjectId = value as { _bsontype?: string; toHexString?: () => string }
+  if (maybeObjectId._bsontype === 'ObjectId' && typeof maybeObjectId.toHexString === 'function') {
+    const hex = maybeObjectId.toHexString()
+    return HEX_24_REGEXP.test(hex) ? hex.toLowerCase() : null
+  }
+
+  return null
+}
+
+const areSemanticallyEqual = (left: unknown, right: unknown): boolean => {
+  const leftOid = toObjectIdHex(left)
+  const rightOid = toObjectIdHex(right)
+
+  if (leftOid || rightOid) {
+    return leftOid !== null && rightOid !== null && leftOid === rightOid
+  }
+
+  return left === right
+}
+
+const includesWithSemanticEquality = (value: unknown, candidate: unknown): boolean =>
+  rulesMatcherUtils
+    .forceArray(candidate)
+    .some((item) =>
+      rulesMatcherUtils
+        .forceArray(value)
+        .some((sourceItem) =>
+          rulesMatcherUtils.forceArray(item).some((candidateItem) =>
+            areSemanticallyEqual(sourceItem, candidateItem)
+          )
+        )
+    )
 
 /**
  * Defines a utility object named rulesMatcherUtils, which contains various helper functions used for processing rules and data in a rule-matching context.
@@ -24,10 +74,10 @@ const rulesMatcherUtils: RulesMatcherUtils = {
     const valueRef =
       value && String(value).indexOf('$ref:') === 0
         ? _get(
-            data,
-            rulesMatcherUtils.getPath(value.replace('$ref:', ''), prefix),
-            undefined
-          )
+          data,
+          rulesMatcherUtils.getPath(value.replace('$ref:', ''), prefix),
+          undefined
+        )
         : value
 
     if (!operators[op]) {
@@ -230,9 +280,9 @@ const rulesMatcherUtils: RulesMatcherUtils = {
 export const operators: Operators = {
   $exists: (a, b) => !rulesMatcherUtils.isEmpty(a) === b,
 
-  $eq: (a, b) => a === b,
+  $eq: (a, b) => areSemanticallyEqual(a, b),
 
-  $ne: (a, b) => a !== b,
+  $ne: (a, b) => !areSemanticallyEqual(a, b),
 
   $gt: (a, b) => rulesMatcherUtils.forceNumber(a) > parseFloat(b),
 
@@ -250,39 +300,35 @@ export const operators: Operators = {
 
   $strLte: (a, b) => String(a || '').length <= parseFloat(b),
 
-  $in: (a, b) =>
-    rulesMatcherUtils
-      .forceArray(b)
-      .some(
-        (c) =>
-          _intersection(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c))
-            .length
-      ),
-
-  $nin: (a, b) =>
-    !rulesMatcherUtils
-      .forceArray(b)
-      .some(
-        (c) =>
-          _intersection(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c))
-            .length
-      ),
+  $in: (a, b) => includesWithSemanticEquality(a, b),
+
+  $nin: (a, b) => !includesWithSemanticEquality(a, b),
 
   $all: (a, b) =>
-    rulesMatcherUtils
-      .forceArray(b)
-      .every(
-        (c) =>
-          _intersection(rulesMatcherUtils.forceArray(a), rulesMatcherUtils.forceArray(c))
-            .length
-      ),
+    rulesMatcherUtils.forceArray(b).every((candidate) =>
+      rulesMatcherUtils
+        .forceArray(a)
+        .some((value) =>
+          rulesMatcherUtils.forceArray(candidate).some((item) => areSemanticallyEqual(value, item))
+        )
+    ),
 
   $size: (a, b) => Array.isArray(a) && a.length === parseFloat(b),
 
   $regex: (a, b, opt) =>
     rulesMatcherUtils
       .forceArray(b)
-      .some((c) => (c instanceof RegExp ? c.test(a) : new RegExp(c, opt).test(a)))
+      .some((c) => (c instanceof RegExp ? c.test(a) : new RegExp(c, opt).test(a))),
+
+  '%stringToOid': (a, b) => {
+    const converted = toObjectIdHex(b)
+    return converted !== null && areSemanticallyEqual(a, converted)
+  },
+
+  '%oidToString': (a, b) => {
+    const converted = toObjectIdHex(b)
+    return converted !== null && areSemanticallyEqual(a, converted)
+  }
 }
 
 // export default operators