@flowerforce/flowerbase 1.7.5-beta.5 → 1.7.5

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

@@ -1,5 +1,4 @@
 import { FastifyInstance } from 'fastify'
-import { ObjectId } from 'mongodb'
 import { AUTH_CONFIG, DB_NAME, DEFAULT_CONFIG } from '../../../constants'
 import { StateManager } from '../../../state'
 import { GenerateContext } from '../../../utils/context'
@@ -31,10 +30,7 @@ export async function customFunctionController(app: FastifyInstance) {
   app.post<LoginDto>(
     AUTH_ENDPOINTS.LOGIN,
     {
-      schema: LOGIN_SCHEMA,
-      errorHandler: (_error, _request, reply) => {
-        reply.code(500).send({ message: 'Internal Server Error' })
-      }
+      schema: LOGIN_SCHEMA
     },
     async function (req, reply) {
       const customFunctionProvider = AUTH_CONFIG.authProviders?.['custom-function']
@@ -58,7 +54,7 @@ export async function customFunctionController(app: FastifyInstance) {
         id
       } = req
 
-      type CustomFunctionAuthResult = { id?: string; email?: string }
+      type CustomFunctionAuthResult = { id?: string }
       const authResult = await GenerateContext({
         args: [
           req.body
@@ -81,35 +77,16 @@ export async function customFunctionController(app: FastifyInstance) {
         }
       }) as CustomFunctionAuthResult
 
+
       if (!authResult.id) {
         reply.code(401).send({ message: 'Unauthorized' })
         return
       }
 
-      const email = authResult?.email || authResult.id
-      let authUser = await db.collection(authCollection!).findOne({ email })
-
+      const authUser = await db.collection(authCollection!).findOne({ email: authResult.id })
       if (!authUser) {
-        const authUserId = new ObjectId()
-        await db.collection(authCollection!).insertOne({
-          _id: authUserId,
-          email,
-          status: 'confirmed',
-          createdAt: new Date(),
-          custom_data: {},
-          identities: [
-            {
-              id: authResult.id.toString(),
-              provider_id: authResult.id.toString(),
-              provider_type: 'custom-function',
-              provider_data: { email }
-            }
-          ]
-        })
-        authUser = {
-          _id: authUserId,
-          email
-        }
+        reply.code(401).send({ message: 'Unauthorized' })
+        return
       }
 
       const user =
@@ -130,7 +107,6 @@ export async function customFunctionController(app: FastifyInstance) {
           ...(user || {})
         }
       }
-
       const refreshToken = this.createRefreshToken(currentUserData)
       const refreshTokenHash = hashToken(refreshToken)
       await db.collection(refreshTokensCollection).insertOne({
@@ -140,15 +116,12 @@ export async function customFunctionController(app: FastifyInstance) {
         expiresAt: new Date(Date.now() + refreshTokenTtlMs),
         revokedAt: null
       })
-      const accessToken = this.createAccessToken(currentUserData)
-
-      const responsePayload = {
-        access_token: accessToken,
+      return {
+        access_token: this.createAccessToken(currentUserData),
         refresh_token: refreshToken,
         device_id: '',
         user_id: authUser._id.toString()
       }
-      reply.code(200).send(responsePayload)
     }
   )
 

package/src/features/triggers/utils.ts

@@ -277,17 +277,6 @@ const handleAuthenticationTrigger = async ({
   changeStream.on('error', (error) => {
     if (shouldIgnoreStreamError(error)) return
     console.error('Authentication trigger change stream error', error)
-    emitTriggerEvent({
-      status: 'error',
-      triggerName,
-      triggerType,
-      functionName,
-      meta: {
-        ...baseMeta,
-        event: 'CHANGE_STREAM'
-      },
-      error
-    })
   })
   changeStream.on('change', async function (change) {
     const operationType = change['operationType' as keyof typeof change] as
@@ -376,6 +365,13 @@ const handleAuthenticationTrigger = async ({
         updateDescription
       }
       try {
+        emitTriggerEvent({
+          status: 'fired',
+          triggerName,
+          triggerType,
+          functionName,
+          meta: { ...baseMeta, event: 'LOGOUT' }
+        })
         await GenerateContext({
           args: [{ user: userData, ...op }],
           app,
@@ -387,13 +383,6 @@ const handleAuthenticationTrigger = async ({
           services,
           runAsSystem: true
         })
-        emitTriggerEvent({
-          status: 'fired',
-          triggerName,
-          triggerType,
-          functionName,
-          meta: { ...baseMeta, event: 'LOGOUT' }
-        })
       } catch (error) {
         emitTriggerEvent({
           status: 'error',
@@ -428,6 +417,13 @@ const handleAuthenticationTrigger = async ({
         updateDescription
       }
       try {
+        emitTriggerEvent({
+          status: 'fired',
+          triggerName,
+          triggerType,
+          functionName,
+          meta: { ...baseMeta, event: 'DELETE' }
+        })
         await GenerateContext({
           args: isAutoTrigger ? [userData] : [{ user: userData, ...op }],
           app,
@@ -439,13 +435,6 @@ const handleAuthenticationTrigger = async ({
           services,
           runAsSystem: true
         })
-        emitTriggerEvent({
-          status: 'fired',
-          triggerName,
-          triggerType,
-          functionName,
-          meta: { ...baseMeta, event: 'DELETE' }
-        })
       } catch (error) {
         emitTriggerEvent({
           status: 'error',
@@ -482,6 +471,13 @@ const handleAuthenticationTrigger = async ({
         updateDescription
       }
       try {
+        emitTriggerEvent({
+          status: 'fired',
+          triggerName,
+          triggerType,
+          functionName,
+          meta: { ...baseMeta, event: 'UPDATE' }
+        })
         await GenerateContext({
           args: isAutoTrigger ? [userData] : [{ user: userData, ...op }],
           app,
@@ -493,13 +489,6 @@ const handleAuthenticationTrigger = async ({
           services,
           runAsSystem: true
         })
-        emitTriggerEvent({
-          status: 'fired',
-          triggerName,
-          triggerType,
-          functionName,
-          meta: { ...baseMeta, event: 'UPDATE' }
-        })
       } catch (error) {
         emitTriggerEvent({
           status: 'error',
@@ -586,6 +575,13 @@ const handleAuthenticationTrigger = async ({
     }
 
     try {
+      emitTriggerEvent({
+        status: 'fired',
+        triggerName,
+        triggerType,
+        functionName,
+        meta: { ...baseMeta, event: 'CREATE' }
+      })
       await GenerateContext({
         args: isAutoTrigger ? [userData] : [{ user: userData, ...op }],
         app,
@@ -597,13 +593,6 @@ const handleAuthenticationTrigger = async ({
         services,
         runAsSystem: true
       })
-      emitTriggerEvent({
-        status: 'fired',
-        triggerName,
-        triggerType,
-        functionName,
-        meta: { ...baseMeta, event: 'CREATE' }
-      })
     } catch (error) {
       emitTriggerEvent({
         status: 'error',

package/src/monitoring/routes/__tests__/collections.test.ts

@@ -0,0 +1,163 @@
+import Fastify, { FastifyInstance } from 'fastify'
+import { registerCollectionRoutes } from '../collections'
+import { StateManager } from '../../../state'
+
+jest.mock('../../../state', () => ({
+  StateManager: {
+    select: jest.fn()
+  }
+}))
+
+describe('monitoring collections routes', () => {
+  let app: FastifyInstance
+  let addCollectionHistory: jest.Mock
+  let selectMock: jest.Mock
+  let insertOne: jest.Mock
+  let insertMany: jest.Mock
+
+  beforeEach(async () => {
+    app = Fastify()
+    addCollectionHistory = jest.fn()
+    selectMock = StateManager.select as unknown as jest.Mock
+    insertOne = jest.fn()
+    insertMany = jest.fn()
+
+    const services = {
+      'mongodb-atlas': jest.fn(() => ({
+        db: jest.fn(() => ({
+          collection: jest.fn(() => ({
+            insertOne,
+            insertMany
+          }))
+        }))
+      }))
+    }
+
+    selectMock.mockImplementation((key: string) => {
+      if (key === 'rules') return {}
+      if (key === 'services') return services
+      return {}
+    })
+
+    registerCollectionRoutes(app, {
+      prefix: '/monit',
+      collectionHistory: [],
+      maxCollectionHistory: 20,
+      addCollectionHistory
+    })
+    await app.ready()
+  })
+
+  afterEach(async () => {
+    await app.close()
+    jest.clearAllMocks()
+  })
+
+  it('POST /collections/insert should insert one document', async () => {
+    insertOne.mockResolvedValue({
+      acknowledged: true,
+      insertedId: 'id-1'
+    })
+
+    const response = await app.inject({
+      method: 'POST',
+      url: '/monit/api/collections/insert',
+      payload: {
+        collection: 'todos',
+        mode: 'insertOne',
+        document: { title: 'Task 1' },
+        runAsSystem: true
+      }
+    })
+
+    expect(response.statusCode).toBe(200)
+    expect(JSON.parse(response.body)).toEqual({
+      mode: 'insertOne',
+      acknowledged: true,
+      insertedId: 'id-1',
+      count: 1
+    })
+    expect(insertOne).toHaveBeenCalledWith({ title: 'Task 1' })
+    expect(addCollectionHistory).toHaveBeenCalledWith(expect.objectContaining({
+      collection: 'todos',
+      mode: 'insertOne',
+      document: { title: 'Task 1' },
+      runAsSystem: true,
+      page: 1
+    }))
+  })
+
+  it('POST /collections/insert should insert many documents', async () => {
+    insertMany.mockResolvedValue({
+      acknowledged: true,
+      insertedIds: {
+        0: 'id-1',
+        1: 'id-2'
+      }
+    })
+
+    const response = await app.inject({
+      method: 'POST',
+      url: '/monit/api/collections/insert',
+      payload: {
+        collection: 'todos',
+        mode: 'insertMany',
+        documents: [{ title: 'Task 1' }, { title: 'Task 2' }],
+        runAsSystem: false
+      }
+    })
+
+    expect(response.statusCode).toBe(200)
+    expect(JSON.parse(response.body)).toEqual({
+      mode: 'insertMany',
+      acknowledged: true,
+      insertedCount: 2,
+      insertedIds: ['id-1', 'id-2'],
+      count: 2
+    })
+    expect(insertMany).toHaveBeenCalledWith([{ title: 'Task 1' }, { title: 'Task 2' }])
+    expect(addCollectionHistory).toHaveBeenCalledWith(expect.objectContaining({
+      collection: 'todos',
+      mode: 'insertMany',
+      documents: [{ title: 'Task 1' }, { title: 'Task 2' }],
+      runAsSystem: false,
+      page: 1
+    }))
+  })
+
+  it('POST /collections/insert should validate insertOne payload', async () => {
+    const response = await app.inject({
+      method: 'POST',
+      url: '/monit/api/collections/insert',
+      payload: {
+        collection: 'todos',
+        mode: 'insertOne',
+        document: ['invalid']
+      }
+    })
+
+    expect(response.statusCode).toBe(400)
+    expect(JSON.parse(response.body)).toEqual({
+      error: 'Document must be an object'
+    })
+    expect(insertOne).not.toHaveBeenCalled()
+  })
+
+  it('POST /collections/insert should validate insertMany payload', async () => {
+    const response = await app.inject({
+      method: 'POST',
+      url: '/monit/api/collections/insert',
+      payload: {
+        collection: 'todos',
+        mode: 'insertMany',
+        documents: [{ title: 'Task 1' }, 'invalid']
+      }
+    })
+
+    expect(response.statusCode).toBe(400)
+    expect(JSON.parse(response.body)).toEqual({
+      error: 'Every document must be an object'
+    })
+    expect(insertMany).not.toHaveBeenCalled()
+  })
+})

package/src/monitoring/routes/collections.ts

@@ -215,4 +215,103 @@ export const registerCollectionRoutes = (app: FastifyInstance, deps: CollectionR
       return { error: details.message, stack: details.stack }
     }
   })
+
+  app.post(`${prefix}/api/collections/insert`, async (req, reply) => {
+    const body = req.body as {
+      collection?: string
+      mode?: 'insertOne' | 'insertMany'
+      document?: unknown
+      documents?: unknown
+      recordHistory?: boolean
+      runAsSystem?: boolean
+      userId?: string
+    }
+    const collection = body?.collection
+    if (!collection) {
+      reply.code(400)
+      return { error: 'Missing collection name' }
+    }
+    const mode = body?.mode === 'insertMany' ? 'insertMany' : 'insertOne'
+    if (mode === 'insertOne') {
+      if (!isPlainObject(body?.document)) {
+        reply.code(400)
+        return { error: 'Document must be an object' }
+      }
+    } else {
+      if (!Array.isArray(body?.documents) || !body.documents.length) {
+        reply.code(400)
+        return { error: 'Documents must be a non-empty array' }
+      }
+      const invalid = body.documents.some((entry) => !isPlainObject(entry))
+      if (invalid) {
+        reply.code(400)
+        return { error: 'Every document must be an object' }
+      }
+    }
+
+    const rules = StateManager.select('rules') as Rules
+    const services = StateManager.select('services') as typeof coreServices
+    const resolvedUser = await resolveUserContext(app, body?.userId)
+    const runAsSystem = body?.runAsSystem !== false
+    const recordHistory = body?.recordHistory !== false
+
+    try {
+      const mongoService = services['mongodb-atlas'](app, {
+        rules,
+        user: resolvedUser ?? {},
+        run_as_system: runAsSystem
+      })
+      const collectionService = mongoService.db(DB_NAME).collection(collection)
+      if (mode === 'insertMany') {
+        const documents = body.documents as Record<string, unknown>[]
+        const result = await collectionService.insertMany(documents)
+        const insertedIds = Array.isArray(result?.insertedIds)
+          ? result.insertedIds
+          : Object.values(result?.insertedIds || {})
+        if (recordHistory) {
+          addCollectionHistory({
+            ts: Date.now(),
+            collection,
+            mode: 'insertMany',
+            documents: sanitize(documents),
+            runAsSystem,
+            user: getUserInfo(resolvedUser as Record<string, unknown> | undefined),
+            page: 1
+          })
+        }
+        return {
+          mode: 'insertMany',
+          acknowledged: !!result?.acknowledged,
+          insertedCount: insertedIds.length,
+          insertedIds: sanitize(insertedIds),
+          count: insertedIds.length
+        }
+      }
+
+      const document = body.document as Record<string, unknown>
+      const result = await collectionService.insertOne(document)
+      const insertedId = result?.insertedId
+      if (recordHistory) {
+        addCollectionHistory({
+          ts: Date.now(),
+          collection,
+          mode: 'insertOne',
+          document: sanitize(document),
+          runAsSystem,
+          user: getUserInfo(resolvedUser as Record<string, unknown> | undefined),
+          page: 1
+        })
+      }
+      return {
+        mode: 'insertOne',
+        acknowledged: !!result?.acknowledged,
+        insertedId: sanitize(insertedId),
+        count: insertedId ? 1 : 0
+      }
+    } catch (error) {
+      const details = getErrorDetails(error)
+      reply.code(500)
+      return { error: details.message, stack: details.stack }
+    }
+  })
 }

package/src/monitoring/ui.collections.js

@@ -42,6 +42,10 @@
   dom.collectionQueryHighlight = document.getElementById('collectionQueryHighlight');
   dom.collectionAggregate = document.getElementById('collectionAggregate');
   dom.collectionAggregateHighlight = document.getElementById('collectionAggregateHighlight');
+  dom.collectionInsertOne = document.getElementById('collectionInsertOne');
+  dom.collectionInsertOneHighlight = document.getElementById('collectionInsertOneHighlight');
+  dom.collectionInsertMany = document.getElementById('collectionInsertMany');
+  dom.collectionInsertManyHighlight = document.getElementById('collectionInsertManyHighlight');
   dom.runCollectionQuery = document.getElementById('runCollectionQuery');
   dom.collectionResult = document.getElementById('collectionResult');
   dom.collectionPrev = document.getElementById('collectionPrev');
@@ -71,6 +75,10 @@
     collectionQueryHighlight,
     collectionAggregate,
     collectionAggregateHighlight,
+    collectionInsertOne,
+    collectionInsertOneHighlight,
+    collectionInsertMany,
+    collectionInsertManyHighlight,
     runCollectionQuery,
     collectionResult,
     collectionPrev,
@@ -237,6 +245,22 @@
     collectionAggregateHighlight.scrollLeft = collectionAggregate.scrollLeft;
   };
 
+  const updateCollectionInsertOneHighlight = () => {
+    if (!collectionInsertOne || !collectionInsertOneHighlight) return;
+    const text = collectionInsertOne.value || '';
+    collectionInsertOneHighlight.innerHTML = highlightJson(text || '');
+    collectionInsertOneHighlight.scrollTop = collectionInsertOne.scrollTop;
+    collectionInsertOneHighlight.scrollLeft = collectionInsertOne.scrollLeft;
+  };
+
+  const updateCollectionInsertManyHighlight = () => {
+    if (!collectionInsertMany || !collectionInsertManyHighlight) return;
+    const text = collectionInsertMany.value || '';
+    collectionInsertManyHighlight.innerHTML = highlightJson(text || '');
+    collectionInsertManyHighlight.scrollTop = collectionInsertMany.scrollTop;
+    collectionInsertManyHighlight.scrollLeft = collectionInsertMany.scrollLeft;
+  };
+
   const formatCellValue = (value) => {
     if (value === null || value === undefined) return '';
     if (typeof value === 'string') {
@@ -483,6 +507,14 @@
       collectionAggregate.value = entry.pipeline ? JSON.stringify(entry.pipeline, null, 2) : '';
       updateCollectionAggregateHighlight();
     }
+    if (collectionInsertOne) {
+      collectionInsertOne.value = entry.document ? JSON.stringify(entry.document, null, 2) : '';
+      updateCollectionInsertOneHighlight();
+    }
+    if (collectionInsertMany) {
+      collectionInsertMany.value = entry.documents ? JSON.stringify(entry.documents, null, 2) : '';
+      updateCollectionInsertManyHighlight();
+    }
     if (entry.user && entry.user.id) {
       if (collectionUserInput) collectionUserInput.value = entry.user.id;
       setSelectedCollectionUser({
@@ -549,14 +581,16 @@
       setCollectionResult('Select a collection first', false);
       return;
     }
-    const keepPage = options && options.keepPage;
+    const mode = collectionMode ? collectionMode.value : 'query';
+    const supportsPaging = mode === 'query' || mode === 'aggregate';
+    const keepPage = supportsPaging && options && options.keepPage;
     const recordHistory = !keepPage;
     if (!keepPage) {
       state.collectionPage = 1;
     }
-    const shouldRefreshTotals = !keepPage || !state.collectionTotal;
+    const shouldRefreshTotals = supportsPaging && (!keepPage || !state.collectionTotal);
     state.collectionHasMore = false;
-    if (shouldRefreshTotals) {
+    if (shouldRefreshTotals || !supportsPaging) {
       state.collectionTotal = 0;
     }
     state.collectionLoading = true;
@@ -568,11 +602,10 @@
     const userId = selectedUser
       ? String(selectedUser.id || (selectedUser.auth && selectedUser.auth._id) || '')
       : fallbackUserId;
-    const mode = collectionMode ? collectionMode.value : 'query';
     try {
-      const sortRaw = collectionSort ? collectionSort.value.trim() : '';
-      const sort = parseJsonObject(sortRaw, 'Sort');
       if (mode === 'aggregate') {
+        const sortRaw = collectionSort ? collectionSort.value.trim() : '';
+        const sort = parseJsonObject(sortRaw, 'Sort');
         const raw = collectionAggregate ? collectionAggregate.value.trim() : '';
         const pipeline = raw ? JSON.parse(raw) : [];
         if (!Array.isArray(pipeline)) {
@@ -607,7 +640,58 @@
         updateCollectionPager();
         setCollectionTab('query');
         setCollectionResult(data, true);
+      } else if (mode === 'insertOne') {
+        const raw = collectionInsertOne ? collectionInsertOne.value.trim() : '';
+        const document = parseJsonObject(raw, 'Document');
+        if (!document) {
+          throw new Error('Document is required for insert one');
+        }
+        const data = await api('/collections/insert', {
+          method: 'POST',
+          body: JSON.stringify({
+            collection: name,
+            mode,
+            document,
+            runAsSystem,
+            userId: userId || undefined,
+            recordHistory
+          })
+        });
+        state.collectionHasMore = false;
+        state.collectionPage = 1;
+        state.collectionTotal = typeof data.count === 'number' ? data.count : 1;
+        updateCollectionPager();
+        setCollectionTab('query');
+        setCollectionResult(data, true);
+      } else if (mode === 'insertMany') {
+        const raw = collectionInsertMany ? collectionInsertMany.value.trim() : '';
+        const documents = raw ? JSON.parse(raw) : [];
+        if (!Array.isArray(documents)) {
+          throw new Error('Documents must be a JSON array for insert many');
+        }
+        if (!documents.length) {
+          throw new Error('Documents are required for insert many');
+        }
+        const data = await api('/collections/insert', {
+          method: 'POST',
+          body: JSON.stringify({
+            collection: name,
+            mode,
+            documents,
+            runAsSystem,
+            userId: userId || undefined,
+            recordHistory
+          })
+        });
+        state.collectionHasMore = false;
+        state.collectionPage = 1;
+        state.collectionTotal = typeof data.count === 'number' ? data.count : documents.length;
+        updateCollectionPager();
+        setCollectionTab('query');
+        setCollectionResult(data, true);
       } else {
+        const sortRaw = collectionSort ? collectionSort.value.trim() : '';
+        const sort = parseJsonObject(sortRaw, 'Sort');
         const raw = collectionQuery ? collectionQuery.value.trim() : '';
         const query = parseJsonObject(raw, 'Query') || {};
         const data = await api('/collections/query', {
@@ -806,6 +890,14 @@
       collectionAggregate.addEventListener('input', updateCollectionAggregateHighlight);
       collectionAggregate.addEventListener('scroll', updateCollectionAggregateHighlight);
     }
+    if (collectionInsertOne) {
+      collectionInsertOne.addEventListener('input', updateCollectionInsertOneHighlight);
+      collectionInsertOne.addEventListener('scroll', updateCollectionInsertOneHighlight);
+    }
+    if (collectionInsertMany) {
+      collectionInsertMany.addEventListener('input', updateCollectionInsertManyHighlight);
+      collectionInsertMany.addEventListener('scroll', updateCollectionInsertManyHighlight);
+    }
 
     if (collectionList) {
       collectionList.addEventListener('click', (event) => {
@@ -916,6 +1008,8 @@
     setCollectionResultView('json');
     updateCollectionQueryHighlight();
     updateCollectionAggregateHighlight();
+    updateCollectionInsertOneHighlight();
+    updateCollectionInsertManyHighlight();
     setRulesTabEnabled(false);
   };
 

package/src/monitoring/ui.css

@@ -929,12 +929,17 @@ button.small {
   align-items: stretch;
 }
 
-.collection-io[data-mode="query"] [data-collection-mode="aggregate"] {
+.collection-io [data-collection-mode] {
   display: none;
+  min-height: 0;
 }
 
-.collection-io[data-mode="aggregate"] [data-collection-mode="query"] {
-  display: none;
+.collection-io[data-mode="query"] [data-collection-mode="query"],
+.collection-io[data-mode="aggregate"] [data-collection-mode="aggregate"],
+.collection-io[data-mode="insertOne"] [data-collection-mode="insertOne"],
+.collection-io[data-mode="insertMany"] [data-collection-mode="insertMany"] {
+  display: flex;
+  flex-direction: column;
 }
 
 .collection-io {
@@ -1039,6 +1044,7 @@ button.small {
   border-right: 1px solid #2b2b2b;
   user-select: none;
   white-space: pre;
+  overflow: hidden;
 }
 
 .code-surface {

package/src/monitoring/ui.functions.js

@@ -78,7 +78,8 @@
       functionHighlight.innerHTML = highlightCode(code);
     }
     if (functionGutter) {
-      const lines = Math.max(1, code.split('\n').length);
+      const lineBreaks = code.match(/\r\n|\r|\n/g);
+      const lines = Math.max(1, (lineBreaks ? lineBreaks.length : 0) + 1);
       let out = '';
       for (let i = 1; i <= lines; i += 1) {
         out += i + (i === lines ? '' : '\n');