@flowerforce/flowerbase 1.2.1-beta.9 → 1.3.0

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

@@ -2,9 +2,9 @@ import { FastifyInstance } from 'fastify'
 import {
   Collection,
   Document,
-  Filter as MongoFilter,
   FindCursor,
   FindOneAndUpdateOptions,
+  Filter as MongoFilter,
   UpdateFilter,
   WithId
 } from 'mongodb'
@@ -67,7 +67,7 @@ export type GetOperatorsFunction = (
   watch: (...params: Parameters<Method<'watch'>>) => ReturnType<Method<'watch'>>
   aggregate: (
     ...params: [...Parameters<Method<'aggregate'>>, isClient: boolean]
-  ) => Promise<ReturnType<Method<'aggregate'>>>
+  ) => ReturnType<Method<'aggregate'>>
   insertMany: (
     ...params: Parameters<Method<'insertMany'>>
   ) => ReturnType<Method<'insertMany'>>

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

@@ -23,12 +23,14 @@ export const getValidRule = <T extends Role | Filter>({
   record = null
 }: GetValidRuleParams<T>) => {
   if (!filters.length) return []
+  const rootRecord = record ?? null
 
   return filters.filter((f) => {
     if (Object.keys(f.apply_when).length === 0) return true
 
     // expandQuery traduce i placeholder (%%user, %%true)
     const conditions = expandQuery(f.apply_when, {
+      '%%root': rootRecord,
       '%%user': user,
       '%%true': true
       /** values */
@@ -40,6 +42,7 @@ export const getValidRule = <T extends Role | Filter>({
       conditions as Parameters<typeof rulesMatcherUtils.checkRule>[0],
       {
         ...(record ?? {}),
+        '%%root': rootRecord,
         '%%user': user,
         '%%true': true
       },

package/src/shared/handleUserRegistration.ts

@@ -1,5 +1,7 @@
 import { AUTH_CONFIG, DB_NAME } from "../constants"
-import { hashPassword } from "../utils/crypto"
+import { StateManager } from "../state"
+import { GenerateContext } from "../utils/context"
+import { generateToken, hashPassword } from "../utils/crypto"
 import { HandleUserRegistration } from "./models/handleUserRegistration.model"
 
 /**
@@ -17,6 +19,10 @@ const handleUserRegistration: HandleUserRegistration = (app, opt) => async ({ em
     }
 
     const { authCollection } = AUTH_CONFIG
+    const localUserpassConfig = AUTH_CONFIG.localUserpassConfig
+    const autoConfirm = localUserpassConfig?.autoConfirm === true
+    const runConfirmationFunction = localUserpassConfig?.runConfirmationFunction === true
+    const confirmationFunctionName = localUserpassConfig?.confirmationFunctionName
     const mongo = app?.mongo
     const db = mongo.client.db(DB_NAME)
     const hashedPassword = await hashPassword(password)
@@ -29,7 +35,7 @@ const handleUserRegistration: HandleUserRegistration = (app, opt) => async ({ em
     const result = await db?.collection(authCollection!).insertOne({
         email,
         password: hashedPassword,
-        status: skipUserCheck ? 'confirmed' : 'pending',
+        status: skipUserCheck || autoConfirm ? 'confirmed' : 'pending',
         createdAt: new Date(),
         custom_data: {
             // TODO: aggiungere dati personalizzati alla registrazione
@@ -58,6 +64,81 @@ const handleUserRegistration: HandleUserRegistration = (app, opt) => async ({ em
         }
     )
 
+    if (!result?.insertedId || skipUserCheck || autoConfirm) {
+        return result
+    }
+
+    if (!runConfirmationFunction) {
+        throw new Error('Missing confirmation function')
+    }
+
+    if (!confirmationFunctionName) {
+        throw new Error('Missing confirmation function name')
+    }
+
+    const functionsList = StateManager.select('functions')
+    const services = StateManager.select('services')
+    const confirmationFunction = functionsList[confirmationFunctionName]
+    if (!confirmationFunction) {
+        throw new Error(`Confirmation function not found: ${confirmationFunctionName}`)
+    }
+
+    const token = generateToken()
+    const tokenId = generateToken()
+    await db?.collection(authCollection!).updateOne(
+        { _id: result.insertedId },
+        {
+            $set: {
+                confirmationToken: token,
+                confirmationTokenId: tokenId
+            }
+        }
+    )
+
+    type ConfirmationResult = { status?: 'success' | 'pending' | 'fail' }
+    let confirmationStatus: ConfirmationResult['status'] = 'fail'
+    try {
+        const response = await GenerateContext({
+            args: [{
+                token,
+                tokenId,
+                username: email
+            }],
+            app,
+            rules: {},
+            user: {},
+            currentFunction: confirmationFunction,
+            functionsList,
+            services,
+            runAsSystem: true
+        }) as ConfirmationResult
+        confirmationStatus = response?.status ?? 'fail'
+    } catch {
+        confirmationStatus = 'fail'
+    }
+
+    if (confirmationStatus === 'success') {
+        await db?.collection(authCollection!).updateOne(
+            { _id: result.insertedId },
+            {
+                $set: { status: 'confirmed' },
+                $unset: { confirmationToken: '', confirmationTokenId: '' }
+            }
+        )
+        return result
+    }
+
+    if (confirmationStatus === 'pending') {
+        return result
+    }
+
+    await db?.collection(authCollection!).updateOne(
+        { _id: result.insertedId },
+        {
+            $set: { status: 'failed' },
+            $unset: { confirmationToken: '', confirmationTokenId: '' }
+        }
+    )
     return result
 
 }

package/src/shared/models/handleUserRegistration.model.ts

@@ -28,5 +28,6 @@ export type HandleUserRegistration = (
 
 export enum PROVIDER {
   LOCAL_USERPASS = "local-userpass",
-  CUSTOM_FUNCTION = "custom-function"
+  CUSTOM_FUNCTION = "custom-function",
+  ANON_USER = "anon-user"
 }

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

@@ -3,6 +3,7 @@ import fastifyMongodb from '@fastify/mongodb'
 import { authController } from '../../auth/controller'
 import jwtAuthPlugin from '../../auth/plugins/jwt'
 import fastifyRawBody from 'fastify-raw-body'
+import { anonUserController } from '../../auth/providers/anon-user/controller'
 import { customFunctionController } from '../../auth/providers/custom-function/controller'
 import { localUserPassController } from '../../auth/providers/local-userpass/controller'
 import { Functions } from '../../features/functions/interface'
@@ -36,7 +37,7 @@ describe('registerPlugins', () => {
     })
 
     // Check Plugins Registration
-    expect(registerMock).toHaveBeenCalledTimes(7)
+    expect(registerMock).toHaveBeenCalledTimes(8)
     expect(registerMock).toHaveBeenCalledWith(cors, {
       origin: '*',
       methods: ['POST', 'GET']
@@ -63,6 +64,9 @@ describe('registerPlugins', () => {
     expect(registerMock).toHaveBeenCalledWith(customFunctionController, {
       prefix: `${MOCKED_API_VERSION}/app/:appId/auth/providers/custom-function`
     })
+    expect(registerMock).toHaveBeenCalledWith(anonUserController, {
+      prefix: `${MOCKED_API_VERSION}/app/:appId/auth/providers/anon-user`
+    })
   })
 
   it('should handle errors in the catch block', async () => {

package/src/utils/context/index.ts

@@ -214,11 +214,11 @@ export async function GenerateContext({
           const moduleCache = new Map<string, vm.Module>()
 
           const loadModule = async (specifier: string): Promise<vm.Module> => {
-          const importTarget = resolveImportTarget(specifier, customRequire)
-          const cached = moduleCache.get(importTarget)
-          if (cached) return cached
+            const importTarget = resolveImportTarget(specifier, customRequire)
+            const cached = moduleCache.get(importTarget)
+            if (cached) return cached
 
-          const namespace = await dynamicImport(importTarget)
+            const namespace = await dynamicImport(importTarget)
             const exportNames = Object.keys(namespace)
             if ('default' in namespace && !exportNames.includes('default')) {
               exportNames.push('default')
@@ -234,34 +234,25 @@ export async function GenerateContext({
               { context: vmContext, identifier: importTarget }
             )
 
-          moduleCache.set(importTarget, syntheticModule)
-          return syntheticModule
-        }
-
-        const importModuleDynamically = (async (
-          specifier: string
-        ): Promise<vm.Module> => {
-          const module = await loadModule(specifier)
-          if (module.status === 'unlinked') {
-            await module.link(loadModule)
-          }
-          if (module.status === 'linked') {
-            await module.evaluate()
+            moduleCache.set(importTarget, syntheticModule)
+            return syntheticModule
           }
-          return module
-        }) as unknown as vm.ScriptOptions['importModuleDynamically']
-
-        const sourceModule = new vmModules.SourceTextModule(
-          wrapEsmModule(functionToRun.code),
-          {
-            context: vmContext,
-            identifier: entryFile,
-            initializeImportMeta: (meta) => {
-              meta.url = pathToFileURL(entryFile).href
-            },
-            importModuleDynamically
-          }
-        )
+
+          const importModuleDynamically =
+            ((specifier: string) => loadModule(specifier) as unknown as vm.Module) as unknown as
+              vm.SourceTextModuleOptions['importModuleDynamically']
+
+          const sourceModule = new vmModules.SourceTextModule(
+            wrapEsmModule(functionToRun.code),
+            {
+              context: vmContext,
+              identifier: entryFile,
+              initializeImportMeta: (meta) => {
+                meta.url = pathToFileURL(entryFile).href
+              },
+              importModuleDynamically
+            }
+          )
 
           await sourceModule.link(loadModule)
           await sourceModule.evaluate()
@@ -281,9 +272,9 @@ export async function GenerateContext({
       }
 
       sandboxModule.exports = resolveExport(vmContext) ?? sandboxModule.exports
-    }
-    catch (e) {
-      console.log(e)
+    } catch (error) {
+      console.error(error)
+      throw error
     }
 
     if (deserializeArgs) {
@@ -294,6 +285,11 @@ export async function GenerateContext({
 
     return await (sandboxModule.exports as ExportedFunction)(...args)
   }
-  const res = await functionsQueue.add(run, enqueue)
-  return res
+  try {
+    const res = await functionsQueue.add(run, enqueue)
+    return res
+  } catch (error) {
+    console.error(error)
+    throw error
+  }
 }

package/src/utils/initializer/exposeRoutes.ts

@@ -18,7 +18,7 @@ export const exposeRoutes = async (fastify: FastifyInstance) => {
       const headerHost = req.headers.host ?? 'localhost:3000'
       const hostname = headerHost.split(':')[0]
       const port = DEFAULT_CONFIG?.PORT ?? 3000
-      const host = `${hostname}:${port}`
+      const host = port === 8080 ? hostname : `${hostname}:${port}`
       const wsSchema = 'wss'
 
       return {

package/src/utils/initializer/registerPlugins.ts

@@ -5,6 +5,7 @@ import fastifyRawBody from 'fastify-raw-body'
 import { CorsConfig } from '../../'
 import { authController } from '../../auth/controller'
 import jwtAuthPlugin from '../../auth/plugins/jwt'
+import { anonUserController } from '../../auth/providers/anon-user/controller'
 import { customFunctionController } from '../../auth/providers/custom-function/controller'
 import { localUserPassController } from '../../auth/providers/local-userpass/controller'
 import { API_VERSION } from '../../constants'
@@ -133,6 +134,13 @@ const getRegisterConfig = async ({
       options: {
         prefix: `${API_VERSION}/app/:appId/auth/providers/custom-function`
       }
+    },
+    {
+      pluginName: 'anonUserController',
+      plugin: anonUserController,
+      options: {
+        prefix: `${API_VERSION}/app/:appId/auth/providers/anon-user`
+      }
     }
   ] as RegisterConfig[]
 }

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

@@ -154,6 +154,9 @@ const rulesMatcherUtils: RulesMatcherUtils = {
   },
   forceArray: (a) => (Array.isArray(a) ? a : [a]),
   getPath: (path, prefix) => {
+    if (typeof path !== 'string' || path.length === 0) {
+      return ''
+    }
     if (path.indexOf('^') === 0) {
       return _trimStart(path, '^')
     }