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

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

@@ -492,6 +492,26 @@ const areUpdatedFieldsAllowed = (
   return updatedPaths.every((path) => isEqual(get(filtered, path), get(updated, path)))
 }
 
+const appendDistinctValue = (values: unknown[], candidate: unknown) => {
+  if (typeof candidate === 'undefined') return
+  if (!values.some((entry) => isEqual(entry, candidate))) {
+    values.push(candidate)
+  }
+}
+
+const collectDistinctValues = (documents: Document[], key: string) =>
+  documents.reduce<unknown[]>((values, document) => {
+    const currentValue = get(document, key)
+
+    if (Array.isArray(currentValue)) {
+      currentValue.forEach((entry) => appendDistinctValue(values, entry))
+      return values
+    }
+
+    appendDistinctValue(values, currentValue)
+    return values
+  }, [])
+
 const getOperators: GetOperatorsFunction = (
   mongo,
   { rules, dbName, collName, user, run_as_system, monitoringOrigin }
@@ -535,7 +555,48 @@ const getOperators: GetOperatorsFunction = (
     })
   }
 
-  return {
+  const validateReadableDocument = async (currentDoc: Document) => {
+    const winningRole = await getWinningRoleAsync(currentDoc, user, roles)
+
+    logDebug('find winningRole', {
+      collection: collName,
+      userId: getUserId(user),
+      winningRoleName: winningRole?.name ?? null,
+      rolesLength: roles.length
+    })
+
+    const { status, document } = winningRole
+      ? await checkValidation(
+        winningRole,
+        {
+          type: 'read',
+          roles,
+          cursor: currentDoc,
+          expansions: getValidationExpansions(currentDoc)
+        },
+        user
+      )
+      : fallbackAccess(currentDoc)
+
+    return status ? document : undefined
+  }
+
+  const getScopedQuery = (query: MongoFilter<Document> = {}) => {
+    const formattedQuery = getFormattedQuery(filters, query, user)
+    const currentQuery = formattedQuery.length ? { $and: formattedQuery } : {}
+    const safeQuery = Array.isArray(formattedQuery)
+      ? normalizeQuery(formattedQuery)
+      : formattedQuery
+
+    return {
+      formattedQuery,
+      currentQuery,
+      safeQuery,
+      builtQuery: buildAndQuery(safeQuery)
+    }
+  }
+
+  const operators: ReturnType<GetOperatorsFunction> = {
     /**
      * Finds a single document in a MongoDB collection with optional role-based filtering and validation.
      *
@@ -1068,30 +1129,7 @@ const getOperators: GetOperatorsFunction = (
             const response = await originalToArray()
 
             const filteredResponse = await Promise.all(
-              response.map(async (currentDoc) => {
-                const winningRole = await getWinningRoleAsync(currentDoc, user, roles)
-
-                logDebug('find winningRole', {
-                  collection: collName,
-                  userId: getUserId(user),
-                  winningRoleName: winningRole?.name ?? null,
-                  rolesLength: roles.length
-                })
-                const { status, document } = winningRole
-                  ? await checkValidation(
-                    winningRole,
-                    {
-                      type: 'read',
-                      roles,
-                      cursor: currentDoc,
-                      expansions: getValidationExpansions(currentDoc)
-                    },
-                    user
-                  )
-                  : fallbackAccess(currentDoc)
-
-                return status ? document : undefined
-              })
+              response.map((currentDoc) => validateReadableDocument(currentDoc))
             )
 
             return filteredResponse.filter(Boolean) as WithId<Document>[]
@@ -1164,6 +1202,45 @@ const getOperators: GetOperatorsFunction = (
         throw error
       }
     },
+    distinct: async (key, query = {}, options) => {
+      try {
+        if (!key) {
+          throw new Error('distinct key is required')
+        }
+
+        if (!run_as_system) {
+          checkDenyOperation(
+            normalizedRules,
+            collection.collectionName,
+            CRUD_OPERATIONS.READ
+          )
+
+          const { currentQuery } = getScopedQuery(query)
+          const projectedOptions = {
+            ...(options ?? {}),
+            projection: { _id: 1, [key]: 1 }
+          } as FindOptions
+          const documents = await collection.find(currentQuery, projectedOptions).toArray()
+          const readableDocuments = (
+            await Promise.all(documents.map((currentDoc) => validateReadableDocument(currentDoc)))
+          ).filter(Boolean) as Document[]
+          const result = collectDistinctValues(readableDocuments, key)
+
+          emitMongoEvent('distinct')
+          return result
+        }
+
+        const result =
+          typeof options === 'undefined'
+            ? await collection.distinct(key, query)
+            : await collection.distinct(key, query, options)
+        emitMongoEvent('distinct')
+        return result
+      } catch (error) {
+        emitMongoEvent('distinct', undefined, error)
+        throw error
+      }
+    },
     /**
      * Watches changes on a MongoDB collection with optional role-based filtering of change events.
      *
@@ -1450,6 +1527,24 @@ const getOperators: GetOperatorsFunction = (
         throw error
       }
     },
+    bulkWrite: async (operations, options) => {
+      try {
+        if (!run_as_system) {
+          throw new Error('bulkWrite is available only when run_as_system is enabled')
+        }
+
+        const result = await collection.bulkWrite(operations, options)
+        emitMongoEvent('bulkWrite', { operations: operations.length })
+        return result
+      } catch (error) {
+        emitMongoEvent(
+          'bulkWrite',
+          { operations: Array.isArray(operations) ? operations.length : 0 },
+          error
+        )
+        throw error
+      }
+    },
     updateMany: async (query, data, options) => {
       try {
         const normalizedData = normalizeUpdatePayload(data as Document)
@@ -1602,6 +1697,8 @@ const getOperators: GetOperatorsFunction = (
       }
     }
   }
+
+  return operators
 }
 
 const MongodbAtlas: MongodbAtlasFunction = (

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

@@ -93,6 +93,14 @@ export type GetOperatorsFunction = (
   aggregate: (
     ...params: [...Parameters<Method<'aggregate'>>, isClient: boolean]
   ) => ReturnType<Method<'aggregate'>>
+  distinct: (
+    key: Parameters<Method<'distinct'>>[0],
+    filter?: Parameters<Method<'distinct'>>[1],
+    options?: Parameters<Method<'distinct'>>[2]
+  ) => ReturnType<Method<'distinct'>>
+  bulkWrite: (
+    ...params: Parameters<Method<'bulkWrite'>>
+  ) => ReturnType<Method<'bulkWrite'>>
   insertMany: (
     ...params: Parameters<Method<'insertMany'>>
   ) => ReturnType<Method<'insertMany'>>

package/src/utils/context/helpers.ts

@@ -187,8 +187,24 @@ export const generateContextData = ({
     },
     context: {
       request: {
-        ...request,
-        remoteIPAddress: request?.ip
+        remoteIPAddress: request?.ip ?? '',
+        requestHeaders: request?.headers
+          ? Object.fromEntries(
+            Object.entries(request.headers).map(([key, value]) => [
+              key,
+              Array.isArray(value) ? value : value !== undefined ? [value] : []
+            ])
+          )
+          : {},
+        webhookUrl: request?.url?.split('?')[0],
+        httpMethod: request?.method,
+        rawQueryString: request?.url?.includes('?')
+          ? request.url.substring(request.url.indexOf('?'))
+          : '',
+        httpReferrer: request?.headers?.referer as string | undefined,
+        httpUserAgent: request?.headers?.['user-agent'] as string | undefined,
+        service: '',
+        action: ''
       },
       user,
       environment: {

package/src/utils/context/interface.ts

@@ -19,7 +19,7 @@ export interface GenerateContextParams {
   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/tsconfig.json

@@ -8,13 +8,8 @@
     "declarationMap": true,
     "noImplicitAny": true,
     "strict": true,
-    "moduleResolution": "node",
     "esModuleInterop": true,
     "skipLibCheck": true,
-    "baseUrl": ".",  
-    "paths": {
-      "*": ["../../node_modules/*"]
-    },
     "lib": ["ES2021", "DOM"]
   },
   "include": ["src/**/*"],

package/tsconfig.spec.json

@@ -3,5 +3,6 @@
   "compilerOptions": {
     "types": ["node", "jest"]
   },
-  "include": ["src/**/*.test.ts", "src/**/*.spec.ts"]
+  "include": ["src/**/*.test.ts", "src/**/*.spec.ts"],
+  "exclude": ["node_modules", "dist"]
 }