@flowerforce/flowerbase 1.0.3-beta.2 → 1.0.3-beta.3

package/src/shared/handleUserRegistration.ts

@@ -0,0 +1,64 @@
+import { PROVIDER_TYPE } from "../auth/utils"
+import { AUTH_CONFIG, DB_NAME } from "../constants"
+import { hashPassword } from "../utils/crypto"
+import { HandleUserRegistration } from "./models/handleUserRegistration.model"
+
+/**
+ * Register user
+ *
+ * @param {FastifyInstance} app The Fastify instance.
+ * @param {Object} [opt] The options from the context
+ * @returns {Promise<InsertOneResult<Document>>} A promise resolving to the result of the insert operation.
+ */
+const handleUserRegistration: HandleUserRegistration = (app, opt) => async ({ email, password }) => {
+    const { run_as_system } = opt ?? {}
+    
+    if (!run_as_system) {
+        throw new Error('only run_as_system')
+    }
+
+    const { authCollection } = AUTH_CONFIG
+    const db = app?.mongo.client.db(DB_NAME)
+    const hashedPassword = await hashPassword(password)
+
+    const existingUser = await db?.collection(authCollection!).findOne({ email })
+    if (existingUser) {
+        throw new Error('This email address is already used')
+    }
+
+    const result = await db?.collection(authCollection!).insertOne({
+        email,
+        password: hashedPassword,
+        status: 'pending', // confirmed
+        custom_data: {
+            // TODO: aggiungere dati personalizzati alla registrazione
+        },
+        identities: [
+            {
+                provider_type: PROVIDER_TYPE,
+                provider_data: { email }
+            }
+        ]
+    })
+
+    await db?.collection(authCollection!).updateOne(
+        { email },
+        {
+            $set: {
+                identities: [
+                    {
+                        id: result?.insertedId.toString(),
+                        provider_id: result?.insertedId.toString(),
+                        provider_type: PROVIDER_TYPE,
+                        provider_data: { email }
+                    }
+                ]
+            }
+        }
+    )
+
+    return result
+
+}
+
+export default handleUserRegistration

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

@@ -0,0 +1,20 @@
+import { FastifyInstance } from "fastify/types/instance"
+import { InsertOneResult } from "mongodb/mongodb"
+import { User } from "../../auth/dtos"
+import { Rules } from "../../features/rules/interface"
+
+type RegistrationParams = {
+  email: string
+  password: string
+}
+
+export type Options = {
+  user?: User
+  rules?: Rules
+  run_as_system?: boolean
+}
+
+export type HandleUserRegistration = (
+  app: FastifyInstance,
+  opt: Options
+) => (params: RegistrationParams) => Promise<InsertOneResult<Document>>

package/src/state.ts

@@ -1,6 +1,7 @@
 import { FastifyInstance } from 'fastify'
 import { Endpoints } from './features/endpoints/interface'
 import { Functions } from './features/functions/interface'
+import { FunctionsQueue } from './features/functions/queue'
 import { Rules } from './features/rules/interface'
 import { Triggers } from './features/triggers/interface'
 import { Services } from './services/interface'
@@ -12,6 +13,7 @@ type State = {
   endpoints: Endpoints
   rules: Rules
   app?: FastifyInstance
+  functionsQueue: FunctionsQueue
 }
 
 export class StateManager {
@@ -19,7 +21,8 @@ export class StateManager {
     functions: {},
     triggers: [],
     endpoints: [],
-    rules: {}
+    rules: {},
+    functionsQueue: new FunctionsQueue()
   }
   static select<K extends keyof typeof this._state>(
     key: K

package/src/utils/context/index.ts

@@ -1,6 +1,7 @@
 import { createRequire } from 'node:module'
 import vm from 'vm'
 import { EJSON } from 'bson'
+import { StateManager } from '../../state'
 import { generateContextData } from './helpers'
 import { GenerateContextParams } from './interface'
 
@@ -23,35 +24,49 @@ export async function GenerateContext({
   currentFunction,
   functionsList,
   services,
-  runAsSystem
+  runAsSystem,
+  deserializeArgs = true,
+  enqueue
 }: GenerateContextParams) {
-  const contextFunction = { run_as_system: runAsSystem, ...currentFunction }
-  const contextData = generateContextData({
-    user,
-    services,
-    app,
-    rules,
-    currentFunction: contextFunction,
-    functionsList,
-    GenerateContext,
-    runAsSystem
-  })
-
-  try {
-    const entryFile = require.main?.filename ?? process.cwd();
-    const customRequire = createRequire(entryFile);
-
-    vm.runInContext(contextFunction.code, vm.createContext({
-      ...contextData, require: customRequire,
-      exports,
-      module,
-      __filename: __filename,
-      __dirname: __dirname
-    }));
-  }
-  catch (e) {
-    console.log(e)
-  }
 
-  return await module.exports(...EJSON.deserialize(args))
+  const functionsQueue = StateManager.select("functionsQueue")
+
+  const functionToRun = { run_as_system: runAsSystem, ...currentFunction }
+
+  const run = async () => {
+
+    const contextData = generateContextData({
+      user,
+      services,
+      app,
+      rules,
+      currentFunction: functionToRun,
+      functionsList,
+      GenerateContext
+    })
+
+    try {
+      const entryFile = require.main?.filename ?? process.cwd();
+      const customRequire = createRequire(entryFile);
+
+      vm.runInContext(functionToRun.code, vm.createContext({
+        ...contextData, require: customRequire,
+        exports,
+        module,
+        __filename: __filename,
+        __dirname: __dirname
+      }));
+    }
+    catch (e) {
+      console.log(e)
+    }
+
+    if (deserializeArgs) {
+      return await module.exports(...EJSON.deserialize(args))
+    }
+
+    return await module.exports(...args)
+  }
+  const res = await functionsQueue.add(run, enqueue)
+  return res
 }

package/src/utils/context/interface.ts

@@ -13,6 +13,8 @@ export interface GenerateContextParams {
   services: Services
   args: Arguments
   runAsSystem?: boolean
+  deserializeArgs?: boolean
+  enqueue?: boolean
 }
 
 export interface GenerateContextDataParams extends Omit<GenerateContextParams, 'args'> {

package/src/utils/roles/helpers.ts

@@ -44,7 +44,7 @@ const evaluateComplexExpression = async (
   const response = await GenerateContext({
     args: [params.cursor],
     app,
-    rules: {},
+    rules: StateManager.select("rules"),
     user,
     currentFunction,
     functionsList,