@flowerforce/flowerbase 1.8.4-beta.4 → 1.8.4-beta.6

package/dist/utils/context/helpers.js

@@ -109,7 +109,7 @@ const createJwtUtils = () => {
  * @param functionsList -> the list of all functions
  */
 const generateContextData = ({ user, services, app, rules, currentFunction, functionName, functionsList, GenerateContextSync, request }) => {
-    var _a;
+    var _a, _b, _c, _d, _e, _f;
     const BSON = mongodb_1.mongodb.BSON;
     const Binary = BSON === null || BSON === void 0 ? void 0 : BSON.Binary;
     if (Binary && typeof Binary.fromBase64 !== 'function') {
@@ -160,7 +160,24 @@ const generateContextData = ({ user, services, app, rules, currentFunction, func
             }
         },
         context: {
-            request: Object.assign(Object.assign({}, request), { remoteIPAddress: request === null || request === void 0 ? void 0 : request.ip }),
+            request: {
+                remoteIPAddress: (_b = request === null || request === void 0 ? void 0 : request.ip) !== null && _b !== void 0 ? _b : '',
+                requestHeaders: (request === null || request === void 0 ? void 0 : request.headers)
+                    ? Object.fromEntries(Object.entries(request.headers).map(([key, value]) => [
+                        key,
+                        Array.isArray(value) ? value : value !== undefined ? [value] : []
+                    ]))
+                    : {},
+                webhookUrl: (_c = request === null || request === void 0 ? void 0 : request.url) === null || _c === void 0 ? void 0 : _c.split('?')[0],
+                httpMethod: request === null || request === void 0 ? void 0 : request.method,
+                rawQueryString: ((_d = request === null || request === void 0 ? void 0 : request.url) === null || _d === void 0 ? void 0 : _d.includes('?'))
+                    ? request.url.substring(request.url.indexOf('?'))
+                    : '',
+                httpReferrer: (_e = request === null || request === void 0 ? void 0 : request.headers) === null || _e === void 0 ? void 0 : _e.referer,
+                httpUserAgent: (_f = request === null || request === void 0 ? void 0 : request.headers) === null || _f === void 0 ? void 0 : _f['user-agent'],
+                service: '',
+                action: ''
+            },
             user,
             environment: {
                 tag: process.env.NODE_ENV

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

@@ -17,7 +17,7 @@ export interface GenerateContextParams {
     enqueue?: boolean;
     request?: ContextRequest;
 }
-type ContextRequest = Pick<FastifyRequest, "ips" | "host" | "hostname" | "url" | "method" | "ip" | "id">;
+type ContextRequest = Pick<FastifyRequest, "ips" | "host" | "hostname" | "url" | "method" | "ip" | "id" | "headers">;
 export interface GenerateContextDataParams extends Omit<GenerateContextParams, 'args'> {
     GenerateContext: (params: GenerateContextParams) => Promise<unknown>;
     GenerateContextSync: (params: GenerateContextParams) => unknown;

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

@@ -1 +1 @@
-{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/utils/context/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACzD,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAA;AACxE,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAA;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAEnD,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,eAAe,CAAA;IACpB,eAAe,EAAE,QAAQ,CAAA;IACzB,aAAa,EAAE,SAAS,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,QAAQ,EAAE,QAAQ,CAAA;IAClB,IAAI,EAAE,SAAS,CAAA;IACf,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,cAAc,CAAA;CACzB;AAED,KAAK,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,KAAK,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,IAAI,GAAG,IAAI,CAAC,CAAA;AACxG,MAAM,WAAW,yBAA0B,SAAQ,IAAI,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACpF,eAAe,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACpE,mBAAmB,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,OAAO,CAAA;CAChE"}
+{"version":3,"file":"interface.d.ts","sourceRoot":"","sources":["../../../src/utils/context/interface.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,SAAS,CAAA;AACzD,OAAO,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,oCAAoC,CAAA;AACxE,OAAO,EAAE,KAAK,EAAE,MAAM,gCAAgC,CAAA;AACtD,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAA;AAEnD,MAAM,WAAW,qBAAqB;IACpC,GAAG,EAAE,eAAe,CAAA;IACpB,eAAe,EAAE,QAAQ,CAAA;IACzB,aAAa,EAAE,SAAS,CAAA;IACxB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,KAAK,CAAA;IACZ,IAAI,EAAE,IAAI,CAAA;IACV,QAAQ,EAAE,QAAQ,CAAA;IAClB,IAAI,EAAE,SAAS,CAAA;IACf,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,cAAc,CAAA;CACzB;AAED,KAAK,cAAc,GAAG,IAAI,CAAC,cAAc,EAAE,KAAK,GAAG,MAAM,GAAG,UAAU,GAAG,KAAK,GAAG,QAAQ,GAAG,IAAI,GAAG,IAAI,GAAG,SAAS,CAAC,CAAA;AACpH,MAAM,WAAW,yBAA0B,SAAQ,IAAI,CAAC,qBAAqB,EAAE,MAAM,CAAC;IACpF,eAAe,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IACpE,mBAAmB,EAAE,CAAC,MAAM,EAAE,qBAAqB,KAAK,OAAO,CAAA;CAChE"}

package/dist/utils/roles/machines/read/D/validators.d.ts

@@ -1,4 +1,4 @@
 import { MachineContext } from '../../interface';
 export declare const checkAdditionalFieldsFn: ({ role }: MachineContext) => boolean;
-export declare const checkIsValidFieldNameFn: (context: MachineContext) => Promise<import("bson/bson").Document>;
+export declare const checkIsValidFieldNameFn: (context: MachineContext) => Promise<import("bson").Document>;
 //# sourceMappingURL=validators.d.ts.map

package/dist/utils/roles/machines/read/D/validators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/roles/machines/read/D/validators.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,eAAO,MAAM,uBAAuB,GAAI,UAAU,cAAc,YAE/D,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAU,SAAS,cAAc,0CAOpE,CAAA"}
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/roles/machines/read/D/validators.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,eAAO,MAAM,uBAAuB,GAAI,UAAU,cAAc,YAE/D,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAU,SAAS,cAAc,qCAOpE,CAAA"}

package/dist/utils/roles/machines/write/C/validators.d.ts

@@ -1,4 +1,4 @@
 import { MachineContext } from '../../interface';
 export declare const checkAdditionalFieldsFn: ({ role }: MachineContext) => boolean;
-export declare const checkIsValidFieldNameFn: (context: MachineContext) => Promise<import("bson/bson").Document>;
+export declare const checkIsValidFieldNameFn: (context: MachineContext) => Promise<import("bson").Document>;
 //# sourceMappingURL=validators.d.ts.map

package/dist/utils/roles/machines/write/C/validators.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/roles/machines/write/C/validators.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,eAAO,MAAM,uBAAuB,GAAI,UAAU,cAAc,YAE/D,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAU,SAAS,cAAc,0CAIpE,CAAA"}
+{"version":3,"file":"validators.d.ts","sourceRoot":"","sources":["../../../../../../src/utils/roles/machines/write/C/validators.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAA;AAEhD,eAAO,MAAM,uBAAuB,GAAI,UAAU,cAAc,YAE/D,CAAA;AAED,eAAO,MAAM,uBAAuB,GAAU,SAAS,cAAc,qCAIpE,CAAA"}

package/package.json

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

package/src/auth/providers/custom-function/controller.ts

@@ -75,7 +75,8 @@ export async function customFunctionController(app: FastifyInstance) {
           url,
           method,
           ip,
-          id
+          id,
+          headers: req.headers
         }
       }) as CustomFunctionAuthResult
 

package/src/cli/call-function.ts

@@ -233,7 +233,8 @@ const executeLocal = async ({
         url: 'cli://local',
         host: 'cli',
         id: 'cli',
-        hostname: 'cli'
+        hostname: 'cli',
+        headers: {}
       }
     })
   } finally {

package/src/features/functions/__tests__/controller.test.ts

@@ -1,4 +1,5 @@
 import Fastify, { FastifyInstance, FastifyReply, FastifyRequest } from 'fastify'
+import { services } from '../../../services'
 import { GenerateContext } from '../../../utils/context'
 import { functionsController } from '../controller'
 
@@ -8,18 +9,19 @@ jest.mock('../../../utils/context', () => ({
 
 describe('functionsController', () => {
   let app: FastifyInstance
+  const originalMongoService = services['mongodb-atlas']
 
   beforeEach(async () => {
     app = Fastify()
 
     app.decorate('jwtAuthentication', async (request: FastifyRequest, _reply: FastifyReply) => {
-      ;(request as any).user = {
+      ; (request as any).user = {
         id: '507f191e810c19729de860ea',
         typ: 'access'
       }
     })
 
-    ;(GenerateContext as jest.Mock).mockResolvedValue({ ok: true })
+      ; (GenerateContext as jest.Mock).mockResolvedValue({ ok: true })
 
     await app.register(functionsController, {
       functionsList: {
@@ -33,6 +35,7 @@ describe('functionsController', () => {
   })
 
   afterEach(async () => {
+    services['mongodb-atlas'] = originalMongoService
     await app.close()
     jest.clearAllMocks()
   })
@@ -57,4 +60,41 @@ describe('functionsController', () => {
       })
     )
   })
+
+  it('passes mongodb-atlas distinct service arguments through POST /call', async () => {
+    const distinct = jest.fn().mockResolvedValue(['open'])
+    services['mongodb-atlas'] = jest.fn(() => ({
+      db: jest.fn().mockReturnValue({
+        collection: jest.fn().mockReturnValue({
+          distinct
+        })
+      })
+    })) as any
+
+    const response = await app.inject({
+      method: 'POST',
+      url: '/call',
+      payload: {
+        service: 'mongodb-atlas',
+        name: 'distinct',
+        arguments: [
+          {
+            database: 'app',
+            collection: 'todos',
+            key: 'status',
+            query: { archived: false },
+            options: { maxTimeMS: 250 }
+          }
+        ]
+      }
+    })
+
+    expect(response.statusCode).toBe(200)
+    expect(JSON.parse(response.body)).toEqual(['open'])
+    expect(distinct).toHaveBeenCalledWith(
+      'status',
+      { archived: false },
+      { maxTimeMS: 250 }
+    )
+  })
 })

package/src/features/functions/__tests__/utils.test.ts

@@ -30,4 +30,48 @@ describe('executeQuery', () => {
       { upsert: true }
     )
   })
+
+  it('passes distinct arguments through to the service method', async () => {
+    const currentMethod = jest.fn().mockResolvedValue(['open'])
+
+    const operators = await executeQuery({
+      currentMethod,
+      key: 'status',
+      query: { archived: false },
+      update: {},
+      options: { maxTimeMS: 500 }
+    } as any)
+
+    await operators.distinct()
+
+    expect(currentMethod).toHaveBeenCalledWith(
+      'status',
+      { archived: false },
+      { maxTimeMS: 500 }
+    )
+  })
+
+  it('passes bulkWrite operations through to the service method', async () => {
+    const currentMethod = jest.fn().mockResolvedValue({ acknowledged: true })
+    const operations = [
+      {
+        updateOne: {
+          filter: { archived: false },
+          update: { $set: { archived: true } }
+        }
+      }
+    ]
+
+    const operators = await executeQuery({
+      currentMethod,
+      query: {},
+      update: {},
+      operations,
+      options: { ordered: false }
+    } as any)
+
+    await operators.bulkWrite()
+
+    expect(currentMethod).toHaveBeenCalledWith(operations, { ordered: false })
+  })
 })

package/src/features/functions/controller.ts

@@ -9,6 +9,29 @@ import { Base64Function, FunctionCallBase64Dto, FunctionCallDto } from './dtos'
 import { FunctionController } from './interface'
 import { executeQuery } from './utils'
 
+const SUPPORTED_QUERY_METHODS = [
+  'find',
+  'findOne',
+  'count',
+  'countDocuments',
+  'distinct',
+  'deleteOne',
+  'insertOne',
+  'updateOne',
+  'findOneAndUpdate',
+  'aggregate',
+  'insertMany',
+  'bulkWrite',
+  'updateMany',
+  'deleteMany'
+] as const
+
+type SupportedQueryMethod = (typeof SUPPORTED_QUERY_METHODS)[number]
+
+const isSupportedQueryMethod = (value: unknown): value is SupportedQueryMethod =>
+  typeof value === 'string' &&
+  (SUPPORTED_QUERY_METHODS as readonly string[]).includes(value)
+
 const normalizeUser = (payload: Record<string, any> | undefined) => {
   if (!payload) return undefined
   const nestedUser =
@@ -352,6 +375,7 @@ export const functionsController: FunctionController = async (
       const [{
         database,
         collection,
+        key,
         query,
         filter,
         update,
@@ -360,9 +384,14 @@ export const functionsController: FunctionController = async (
         returnNewDocument,
         document,
         documents,
+        operations,
         pipeline = []
       }] = args
 
+      if (!isSupportedQueryMethod(method)) {
+        throw new Error(`Unsupported service method "${String(method)}"`)
+      }
+
       const currentMethod = serviceFn(app, { rules, user })
         .db(database)
         .collection(collection)[method]
@@ -371,6 +400,7 @@ export const functionsController: FunctionController = async (
       const operatorsByType = await executeQuery({
         currentMethod,
         query,
+        key,
         filter,
         update,
         projection,
@@ -378,10 +408,15 @@ export const functionsController: FunctionController = async (
         returnNewDocument,
         document,
         documents,
+        operations,
         pipeline,
         isClient: true
       })
-      const serviceResult = await operatorsByType[method as keyof typeof operatorsByType]()
+      const operator = operatorsByType[method]
+      if (typeof operator !== 'function') {
+        throw new Error(`Unsupported service method "${method}"`)
+      }
+      const serviceResult = await operator()
       res.type('application/json')
       return serializeEjson(serviceResult)
     }
@@ -406,7 +441,8 @@ export const functionsController: FunctionController = async (
         currentFunction,
         functionName: String(method),
         functionsList,
-        services
+        services,
+        request: req
       })
       const normalizedResult = await normalizeFunctionResult(result)
       if (isReturnedError(normalizedResult)) {

package/src/features/functions/dtos.ts

@@ -23,6 +23,7 @@ export type FunctionCallBase64Dto = {
 type ArgumentsData = Arguments<{
   database: string
   collection: string
+  key?: string
   filter?: Document
   query: Parameters<GetOperatorsFunction>
   update: Document
@@ -31,6 +32,7 @@ type ArgumentsData = Arguments<{
   returnNewDocument?: boolean
   document: Document
   documents: Document[]
+  operations?: Document[]
   pipeline?: Document[]
 }>
 

package/src/features/functions/interface.ts

@@ -27,12 +27,14 @@ export type ExecuteQueryParams = {
   currentMethod: ReturnType<GetOperatorsFunction>[keyof ReturnType<GetOperatorsFunction>]
   query: Parameters<GetOperatorsFunction>
   update: Document
+  key?: string
   filter?: Document
   projection?: Document
   options?: Document
   returnNewDocument?: boolean
   document: Document
   documents: Document[]
+  operations?: Document[]
   pipeline: Document[]
   isClient?: boolean
 }

package/src/features/functions/utils.ts

@@ -45,12 +45,14 @@ export const executeQuery = async ({
   currentMethod,
   query,
   update,
+  key,
   filter,
   projection,
   options,
   returnNewDocument,
   document,
   documents,
+  operations,
   pipeline,
   isClient = false
 }: ExecuteQueryParams) => {
@@ -113,6 +115,12 @@ export const executeQuery = async ({
         EJSON.deserialize(resolvedQuery),
         parsedOptions
       ),
+    distinct: () =>
+      (currentMethod as ReturnType<GetOperatorsFunction>['distinct'])(
+        key ?? '',
+        EJSON.deserialize(resolvedQuery),
+        parsedOptions
+      ),
     deleteOne: () =>
       (currentMethod as ReturnType<GetOperatorsFunction>['deleteOne'])(
         EJSON.deserialize(resolvedQuery),
@@ -144,6 +152,11 @@ export const executeQuery = async ({
       (currentMethod as ReturnType<GetOperatorsFunction>['insertMany'])(
         EJSON.deserialize(documents)
       ),
+    bulkWrite: () =>
+      (currentMethod as ReturnType<GetOperatorsFunction>['bulkWrite'])(
+        EJSON.deserialize(operations ?? []),
+        parsedOptions
+      ),
     updateMany: () =>
       (currentMethod as ReturnType<GetOperatorsFunction>['updateMany'])(
         EJSON.deserialize(resolvedQuery),

package/src/services/mongodb-atlas/__tests__/realmCompatibility.test.ts

@@ -1,3 +1,5 @@
+/// <reference types="jest" />
+
 import { ObjectId } from 'mongodb'
 import MongoDbAtlas from '..'
 import { Rules } from '../../../features/rules/interface'
@@ -178,6 +180,70 @@ describe('mongodb-atlas Realm compatibility', () => {
     )
   })
 
+  it('forwards bulkWrite to the underlying collection in system mode', async () => {
+    const operations = [
+      {
+        updateOne: {
+          filter: { done: false },
+          update: { $set: { done: true } }
+        }
+      }
+    ]
+    const bulkWriteResult = {
+      acknowledged: true,
+      matchedCount: 1,
+      modifiedCount: 1,
+      insertedCount: 0,
+      deletedCount: 0,
+      upsertedCount: 0,
+      insertedIds: {},
+      upsertedIds: {}
+    }
+    const bulkWrite = jest.fn().mockResolvedValue(bulkWriteResult)
+    const collection = {
+      collectionName: 'todos',
+      bulkWrite
+    }
+
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      run_as_system: true
+    }).db('db').collection('todos')
+
+    const result = await operators.bulkWrite(operations as any, { ordered: false } as any)
+
+    expect(result).toEqual(bulkWriteResult)
+    expect(bulkWrite).toHaveBeenCalledWith(operations, { ordered: false })
+  })
+
+  it('rejects bulkWrite outside run_as_system mode', async () => {
+    const bulkWrite = jest.fn()
+    const collection = {
+      collectionName: 'todos',
+      bulkWrite
+    }
+
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      rules: createRules(),
+      user: { id: 'user-1' }
+    }).db('db').collection('todos')
+
+    await expect(
+      operators.bulkWrite(
+        [
+          {
+            updateOne: {
+              filter: { done: false },
+              update: { $set: { done: true } }
+            }
+          }
+        ] as any,
+        { ordered: false } as any
+      )
+    ).rejects.toThrow('bulkWrite is available only when run_as_system is enabled')
+
+    expect(bulkWrite).not.toHaveBeenCalled()
+  })
+
   it('supports operator updates in updateMany without using invalid aggregate stages', async () => {
     const id = new ObjectId()
     const find = jest.fn().mockReturnValue({
@@ -513,6 +579,56 @@ describe('mongodb-atlas Realm compatibility', () => {
     expect(result.insertedIds).toEqual([id0, id1])
   })
 
+  it('computes distinct values from readable documents only', async () => {
+    const find = jest.fn().mockReturnValue({
+      toArray: jest.fn().mockResolvedValue([
+        { _id: new ObjectId(), visible: 'A', secret: 'internal-1' },
+        { _id: new ObjectId(), visible: 'A', secret: 'internal-2' },
+        { _id: new ObjectId(), visible: 'B', secret: 'internal-1' }
+      ])
+    })
+    const collection = {
+      collectionName: 'todos',
+      find
+    }
+    const operators = MongoDbAtlas(createAppWithCollection(collection) as any, {
+      rules: createRules({
+        roles: [
+          {
+            name: 'reader',
+            apply_when: {},
+            insert: true,
+            delete: true,
+            search: true,
+            read: true,
+            write: true,
+            fields: {
+              visible: { read: true },
+              secret: { read: false, write: false }
+            }
+          } as any
+        ]
+      }),
+      user: { id: 'user-1' }
+    }).db('db').collection('todos')
+
+    const visibleResult = await operators.distinct('visible', { archived: false })
+    const secretResult = await operators.distinct('secret', { archived: false })
+
+    expect(visibleResult).toEqual(['A', 'B'])
+    expect(secretResult).toEqual([])
+    expect(find).toHaveBeenNthCalledWith(
+      1,
+      { $and: [{ archived: false }] },
+      { projection: { _id: 1, visible: 1 } }
+    )
+    expect(find).toHaveBeenNthCalledWith(
+      2,
+      { $and: [{ archived: false }] },
+      { projection: { _id: 1, secret: 1 } }
+    )
+  })
+
   it('exposes startSession and delegates to the underlying MongoClient', async () => {
     const mockSession = { withTransaction: jest.fn() }
     const startSession = jest.fn().mockReturnValue(mockSession)