@flowerforce/flowerbase 1.7.2 → 1.7.3-beta.1

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

@@ -1,9 +1,16 @@
 import get from 'lodash/get'
 import isEqual from 'lodash/isEqual'
+import set from 'lodash/set'
+import unset from 'lodash/unset'
+import cloneDeep from 'lodash/cloneDeep'
 import {
+  ClientSession,
+  ClientSessionOptions,
   Collection,
   Document,
   EventsDescription,
+  FindOneOptions,
+  FindOptions,
   FindOneAndUpdateOptions,
   Filter as MongoFilter,
   UpdateFilter,
@@ -45,6 +52,222 @@ const logService = (message: string, payload?: unknown) => {
   console.log('[service-debug]', message, payload ?? '')
 }
 
+const findOptionKeys = new Set([
+  'sort',
+  'skip',
+  'limit',
+  'session',
+  'hint',
+  'maxTimeMS',
+  'collation',
+  'allowPartialResults',
+  'noCursorTimeout',
+  'batchSize',
+  'returnKey',
+  'showRecordId',
+  'comment',
+  'let',
+  'projection'
+])
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+  !!value && typeof value === 'object' && !Array.isArray(value)
+
+const looksLikeFindOptions = (value: unknown) => {
+  if (!isPlainObject(value)) return false
+  return Object.keys(value).some((key) => findOptionKeys.has(key))
+}
+
+const resolveFindArgs = (
+  projectionOrOptions?: Document | FindOptions | FindOneOptions,
+  options?: FindOptions | FindOneOptions
+) => {
+  if (typeof options !== 'undefined') {
+    return {
+      projection: projectionOrOptions as Document | undefined,
+      options
+    }
+  }
+
+  if (looksLikeFindOptions(projectionOrOptions)) {
+    const resolvedOptions = projectionOrOptions as FindOptions | FindOneOptions
+    const projection =
+      isPlainObject(resolvedOptions) && isPlainObject(resolvedOptions.projection)
+        ? (resolvedOptions.projection as Document)
+        : undefined
+    return {
+      projection,
+      options: resolvedOptions
+    }
+  }
+
+  return {
+    projection: projectionOrOptions as Document | undefined,
+    options: undefined
+  }
+}
+
+const normalizeInsertManyResult = <T extends { insertedIds?: Record<string, unknown> }>(result: T) => {
+  if (!result?.insertedIds || Array.isArray(result.insertedIds)) return result
+  return {
+    ...result,
+    insertedIds: Object.values(result.insertedIds)
+  }
+}
+
+const hasAtomicOperators = (data: Document) => Object.keys(data).some((key) => key.startsWith('$'))
+
+const normalizeUpdatePayload = (data: Document) =>
+  hasAtomicOperators(data) ? data : { $set: data }
+
+const hasOperatorExpressions = (value: unknown) =>
+  isPlainObject(value) && Object.keys(value).some((key) => key.startsWith('$'))
+
+const matchesPullCondition = (item: unknown, operand: unknown) => {
+  if (!isPlainObject(operand)) return isEqual(item, operand)
+  if (hasOperatorExpressions(operand)) {
+    if (Array.isArray((operand as { $in?: unknown }).$in)) {
+      return ((operand as { $in: unknown[] }).$in).some((candidate) => isEqual(candidate, item))
+    }
+    return false
+  }
+  return Object.entries(operand).every(([key, value]) => isEqual(get(item, key), value))
+}
+
+const applyDocumentUpdateOperators = (baseDocument: Document, update: Document): Document => {
+  const updated = cloneDeep(baseDocument)
+
+  for (const [operator, payload] of Object.entries(update)) {
+    if (!isPlainObject(payload)) continue
+
+    switch (operator) {
+      case '$set':
+        Object.entries(payload).forEach(([path, value]) => set(updated, path, value))
+        break
+      case '$unset':
+        Object.keys(payload).forEach((path) => {
+          unset(updated, path)
+        })
+        break
+      case '$inc':
+        Object.entries(payload).forEach(([path, value]) => {
+          const currentValue = get(updated, path)
+          const increment = typeof value === 'number' ? value : 0
+          if (typeof currentValue === 'undefined') {
+            set(updated, path, increment)
+            return
+          }
+          if (typeof currentValue !== 'number') {
+            throw new Error(`Cannot apply $inc to a non-numeric value at path "${path}"`)
+          }
+          set(updated, path, currentValue + increment)
+        })
+        break
+      case '$push':
+        Object.entries(payload).forEach(([path, value]) => {
+          const currentValue = get(updated, path)
+          const targetArray = Array.isArray(currentValue) ? [...currentValue] : []
+          if (isPlainObject(value) && Array.isArray((value as { $each?: unknown[] }).$each)) {
+            targetArray.push(...((value as { $each: unknown[] }).$each))
+          } else {
+            targetArray.push(value)
+          }
+          set(updated, path, targetArray)
+        })
+        break
+      case '$addToSet':
+        Object.entries(payload).forEach(([path, value]) => {
+          const currentValue = get(updated, path)
+          const targetArray = Array.isArray(currentValue) ? [...currentValue] : []
+          const valuesToAdd =
+            isPlainObject(value) && Array.isArray((value as { $each?: unknown[] }).$each)
+              ? (value as { $each: unknown[] }).$each
+              : [value]
+          valuesToAdd.forEach((entry) => {
+            if (!targetArray.some((existing) => isEqual(existing, entry))) {
+              targetArray.push(entry)
+            }
+          })
+          set(updated, path, targetArray)
+        })
+        break
+      case '$pull':
+        Object.entries(payload).forEach(([path, value]) => {
+          const currentValue = get(updated, path)
+          if (!Array.isArray(currentValue)) return
+          const filtered = currentValue.filter((entry) => !matchesPullCondition(entry, value))
+          set(updated, path, filtered)
+        })
+        break
+      case '$pop':
+        Object.entries(payload).forEach(([path, value]) => {
+          const currentValue = get(updated, path)
+          if (!Array.isArray(currentValue) || !currentValue.length) return
+          const next = [...currentValue]
+          if (value === -1) {
+            next.shift()
+          } else {
+            next.pop()
+          }
+          set(updated, path, next)
+        })
+        break
+      case '$mul':
+        Object.entries(payload).forEach(([path, value]) => {
+          const currentValue = get(updated, path)
+          const factor = typeof value === 'number' ? value : 1
+          if (typeof currentValue === 'undefined') {
+            set(updated, path, 0)
+            return
+          }
+          if (typeof currentValue !== 'number') {
+            throw new Error(`Cannot apply $mul to a non-numeric value at path "${path}"`)
+          }
+          set(updated, path, currentValue * factor)
+        })
+        break
+      case '$min':
+        Object.entries(payload).forEach(([path, value]) => {
+          const currentValue = get(updated, path)
+          const comparableCurrent = currentValue as any
+          const comparableValue = value as any
+          if (typeof currentValue === 'undefined' || comparableCurrent > comparableValue) {
+            set(updated, path, value)
+          }
+        })
+        break
+      case '$max':
+        Object.entries(payload).forEach(([path, value]) => {
+          const currentValue = get(updated, path)
+          const comparableCurrent = currentValue as any
+          const comparableValue = value as any
+          if (typeof currentValue === 'undefined' || comparableCurrent < comparableValue) {
+            set(updated, path, value)
+          }
+        })
+        break
+      case '$rename':
+        Object.entries(payload).forEach(([fromPath, toPath]) => {
+          if (typeof toPath !== 'string') return
+          const currentValue = get(updated, fromPath)
+          if (typeof currentValue === 'undefined') return
+          set(updated, toPath, currentValue)
+          unset(updated, fromPath)
+        })
+        break
+      case '$currentDate':
+        Object.keys(payload).forEach((path) => set(updated, path, new Date()))
+        break
+      case '$setOnInsert':
+        break
+      default:
+        break
+    }
+  }
+
+  return updated
+}
+
 const getUpdatedPaths = (update: Document) => {
   const entries = Object.entries(update ?? {})
   const hasOperators = entries.some(([key]) => key.startsWith('$'))
@@ -133,12 +356,16 @@ const getOperators: GetOperatorsFunction = (
    *  - Validates the result using `checkValidation` to ensure read permission.
    *  - If validation fails, returns an empty object; otherwise returns the validated document.
    */
-    findOne: async (query = {}, projection, options) => {
+    findOne: async (query = {}, projectionOrOptions, options) => {
       try {
+        const { projection, options: normalizedOptions } = resolveFindArgs(
+          projectionOrOptions,
+          options
+        )
         const resolvedOptions =
-          projection || options
+          projection || normalizedOptions
             ? {
-              ...(options ?? {}),
+              ...(normalizedOptions ?? {}),
               ...(projection ? { projection } : {})
             }
             : undefined
@@ -350,6 +577,7 @@ const getOperators: GetOperatorsFunction = (
      */
     updateOne: async (query, data, options) => {
       try {
+        const normalizedData = normalizeUpdatePayload(data as Document)
         if (!run_as_system) {
 
           checkDenyOperation(normalizedRules, collection.collectionName, CRUD_OPERATIONS.UPDATE)
@@ -364,31 +592,23 @@ const getOperators: GetOperatorsFunction = (
           const result = await collection.findOne({ $and: safeQuery })
 
           if (!result) {
+            if (options?.upsert) {
+              const upsertResult = await collection.updateOne(
+                { $and: safeQuery },
+                normalizedData,
+                options
+              )
+              emitMongoEvent('updateOne')
+              return upsertResult
+            }
             throw new Error('Update not permitted')
           }
 
           const winningRole = getWinningRole(result, user, roles)
 
           // Check if the update data contains MongoDB update operators (e.g., $set, $inc)
-          const hasOperators = Object.keys(data).some((key) => key.startsWith('$'))
-          const updatedPaths = getUpdatedPaths(data as Document)
-
-          // Flatten the update object to extract the actual fields being modified
-          // const docToCheck = hasOperators
-          //   ? Object.values(data).reduce((acc, operation) => ({ ...acc, ...operation }), {})
-          //   : data
-          const pipeline = [
-            {
-              $match: { $and: safeQuery }
-            },
-            {
-              $limit: 1
-            },
-            ...Object.entries(data).map(([key, value]) => ({ [key]: value }))
-          ]
-          const [docToCheck] = hasOperators
-            ? await collection.aggregate(pipeline).toArray()
-            : ([data] as [Document])
+          const updatedPaths = getUpdatedPaths(normalizedData)
+          const docToCheck = applyDocumentUpdateOperators(result, normalizedData)
           // Validate update permissions
           const { status, document } = winningRole
             ? await checkValidation(
@@ -408,11 +628,11 @@ const getOperators: GetOperatorsFunction = (
           if (!status || !areDocumentsEqual) {
             throw new Error('Update not permitted')
           }
-          const res = await collection.updateOne({ $and: safeQuery }, data, options)
+          const res = await collection.updateOne({ $and: safeQuery }, normalizedData, options)
           emitMongoEvent('updateOne')
           return res
         }
-        const result = await collection.updateOne(query, data, options)
+        const result = await collection.updateOne(query, normalizedData, options)
         emitMongoEvent('updateOne')
         return result
       } catch (error) {
@@ -450,20 +670,19 @@ const getOperators: GetOperatorsFunction = (
           }
 
           const winningRole = getWinningRole(result, user, roles)
-          const hasOperators = Object.keys(data).some((key) => key.startsWith('$'))
-          const updatedPaths = Array.isArray(data) ? [] : getUpdatedPaths(data as Document)
-          const pipeline = [
-            {
-              $match: { $and: safeQuery }
-            },
-            {
-              $limit: 1
-            },
-            ...Object.entries(data).map(([key, value]) => ({ [key]: value }))
-          ]
-          const [docToCheck] = hasOperators
-            ? await collection.aggregate(pipeline).toArray()
-            : ([data] as [Document])
+          const normalizedData = Array.isArray(data)
+            ? data
+            : normalizeUpdatePayload(data as Document)
+          const updatedPaths = Array.isArray(normalizedData)
+            ? []
+            : getUpdatedPaths(normalizedData as Document)
+          const [docToCheck] = Array.isArray(normalizedData)
+            ? await collection.aggregate([
+              { $match: { $and: safeQuery } },
+              { $limit: 1 },
+              ...normalizedData
+            ]).toArray()
+            : [applyDocumentUpdateOperators(result, normalizedData as Document)]
 
           const { status, document } = winningRole
             ? await checkValidation(
@@ -484,8 +703,8 @@ const getOperators: GetOperatorsFunction = (
           }
 
           const updateResult = options
-            ? await collection.findOneAndUpdate({ $and: safeQuery }, data, options)
-            : await collection.findOneAndUpdate({ $and: safeQuery }, data)
+            ? await collection.findOneAndUpdate({ $and: safeQuery }, normalizedData, options)
+            : await collection.findOneAndUpdate({ $and: safeQuery }, normalizedData)
           if (!updateResult) {
             emitMongoEvent('findOneAndUpdate')
             return updateResult
@@ -540,12 +759,16 @@ const getOperators: GetOperatorsFunction = (
      *
      * This ensures that both pre-query filtering and post-query validation are applied consistently.
      */
-    find: (query = {}, projection, options) => {
+    find: (query = {}, projectionOrOptions, options) => {
       try {
+        const { projection, options: normalizedOptions } = resolveFindArgs(
+          projectionOrOptions,
+          options
+        )
         const resolvedOptions =
-          projection || options
+          projection || normalizedOptions
             ? {
-              ...(options ?? {}),
+              ...(normalizedOptions ?? {}),
               ...(projection ? { projection } : {})
             }
             : undefined
@@ -867,12 +1090,12 @@ const getOperators: GetOperatorsFunction = (
 
           const result = await collection.insertMany(documents, options)
           emitMongoEvent('insertMany')
-          return result
+          return normalizeInsertManyResult(result)
         }
         // If system mode is active, insert all documents without validation
         const result = await collection.insertMany(documents, options)
         emitMongoEvent('insertMany')
-        return result
+        return normalizeInsertManyResult(result)
       } catch (error) {
         emitMongoEvent('insertMany', undefined, error)
         throw error
@@ -880,6 +1103,7 @@ const getOperators: GetOperatorsFunction = (
     },
     updateMany: async (query, data, options) => {
       try {
+        const normalizedData = normalizeUpdatePayload(data as Document)
         if (!run_as_system) {
           checkDenyOperation(normalizedRules, collection.collectionName, CRUD_OPERATIONS.UPDATE)
           // Apply access control filters
@@ -893,24 +1117,10 @@ const getOperators: GetOperatorsFunction = (
           }
 
           // Check if the update data contains MongoDB update operators (e.g., $set, $inc)
-          const hasOperators = Object.keys(data).some((key) => key.startsWith('$'))
-          const updatedPaths = getUpdatedPaths(data as Document)
-
-          // Flatten the update object to extract the actual fields being modified
-          // const docToCheck = hasOperators
-          //   ? Object.values(data).reduce((acc, operation) => ({ ...acc, ...operation }), {})
-          //   : data
-
-          const pipeline = [
-            {
-              $match: { $and: formattedQuery }
-            },
-            ...Object.entries(data).map(([key, value]) => ({ [key]: value }))
-          ]
-
-          const docsToCheck = hasOperators
-            ? await collection.aggregate(pipeline).toArray()
-            : result
+          const updatedPaths = getUpdatedPaths(normalizedData)
+          const docsToCheck = result.map((currentDoc) =>
+            applyDocumentUpdateOperators(currentDoc, normalizedData)
+          )
 
           const filteredItems = await Promise.all(
             docsToCheck.map(async (currentDoc) => {
@@ -944,11 +1154,11 @@ const getOperators: GetOperatorsFunction = (
             throw new Error('Update not permitted')
           }
 
-          const res = await collection.updateMany({ $and: formattedQuery }, data, options)
+          const res = await collection.updateMany({ $and: formattedQuery }, normalizedData, options)
           emitMongoEvent('updateMany')
           return res
         }
-        const result = await collection.updateMany(query, data, options)
+        const result = await collection.updateMany(query, normalizedData, options)
         emitMongoEvent('updateMany')
         return result
       } catch (error) {
@@ -1040,6 +1250,12 @@ const MongodbAtlas: MongodbAtlasFunction = (
   app,
   { rules, user, run_as_system, monitoring } = {}
 ) => ({
+  startSession: (options?: ClientSessionOptions) => {
+    const mongoClient = app.mongo.client as unknown as {
+      startSession: (sessionOptions?: ClientSessionOptions) => ClientSession
+    }
+    return mongoClient.startSession(options)
+  },
   db: (dbName: string) => {
     return {
       collection: (collName: string) => {

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

@@ -1,5 +1,7 @@
 import { FastifyInstance } from 'fastify'
 import {
+  ClientSession,
+  ClientSessionOptions,
   Collection,
   Document,
   FindCursor,
@@ -31,6 +33,7 @@ export type MongodbAtlasFunction = (
   db: (dbName: string) => {
     collection: (collName: string) => ReturnType<GetOperatorsFunction>
   }
+  startSession: (options?: ClientSessionOptions) => ClientSession
 }
 
 export type GetValidRuleParams<T extends Role | Filter> = {

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

@@ -0,0 +1,60 @@
+import { GenerateContextSync } from '../context'
+import { Functions } from '../../features/functions/interface'
+
+const mockServices = {
+  api: jest.fn().mockReturnValue({}),
+  aws: jest.fn().mockReturnValue({}),
+  'mongodb-atlas': jest.fn().mockReturnValue({})
+} as any
+
+describe('context.functions.execute compatibility', () => {
+  it('returns direct value when target function is synchronous', () => {
+    const functionsList = {
+      caller: {
+        code: 'module.exports = function() { return context.functions.execute("syncTarget") }'
+      },
+      syncTarget: {
+        code: 'module.exports = function() { return { ok: true } }'
+      }
+    } as Functions
+
+    const result = GenerateContextSync({
+      args: [],
+      app: {} as any,
+      rules: {} as any,
+      user: {} as any,
+      currentFunction: functionsList.caller,
+      functionsList,
+      services: mockServices,
+      functionName: 'caller'
+    })
+
+    expect(result).toEqual({ ok: true })
+    expect(result).not.toBeInstanceOf(Promise)
+  })
+
+  it('returns Promise when target function is asynchronous', async () => {
+    const functionsList = {
+      caller: {
+        code: 'module.exports = function() { return context.functions.execute("asyncTarget") }'
+      },
+      asyncTarget: {
+        code: 'module.exports = async function() { return { ok: true } }'
+      }
+    } as Functions
+
+    const result = GenerateContextSync({
+      args: [],
+      app: {} as any,
+      rules: {} as any,
+      user: {} as any,
+      currentFunction: functionsList.caller,
+      functionsList,
+      services: mockServices,
+      functionName: 'caller'
+    })
+
+    expect(result && typeof (result as Promise<unknown>).then).toBe('function')
+    await expect(result).resolves.toEqual({ ok: true })
+  })
+})

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

@@ -25,6 +25,7 @@ const mockFunctions = {
 
 const currentFunction = mockFunctions.test
 const GenerateContextMock = jest.fn()
+const GenerateContextSyncMock = jest.fn()
 const mockUser = {} as User
 const mockRules = {} as Rules
 const mockEnv = {
@@ -52,6 +53,7 @@ describe('generateContextData', () => {
       functionsList: mockFunctions,
       currentFunction,
       GenerateContext: GenerateContextMock,
+      GenerateContextSync: GenerateContextSyncMock,
       user: mockUser,
       rules: mockRules
     })
@@ -77,7 +79,7 @@ describe('generateContextData', () => {
     mockErrorLog.mockRestore()
 
     context.functions.execute('test')
-    expect(GenerateContextMock).toHaveBeenCalled()
+    expect(GenerateContextSyncMock).toHaveBeenCalled()
 
     const token = jwt.sign(
       { sub: 'user', role: 'admin' },

package/src/utils/context/helpers.ts

@@ -117,6 +117,7 @@ export const generateContextData = ({
   functionName,
   functionsList,
   GenerateContext,
+  GenerateContextSync,
   request
 }: GenerateContextDataParams) => {
   const BSON = mongodb.BSON
@@ -206,7 +207,7 @@ export const generateContextData = ({
       functions: {
         execute: (name: keyof typeof functionsList, ...args: Arguments) => {
           const currentFunction = functionsList[name] as Function
-          return GenerateContext({
+          return GenerateContextSync({
             args,
             app,
             rules,