@flowerforce/flowerbase 1.0.1-beta.8 → 1.0.2

package/src/utils/initializer/exposeRoutes.ts

@@ -1,6 +1,9 @@
 import { uptime } from 'node:process'
 import { FastifyInstance } from 'fastify'
-import { API_VERSION, DEFAULT_CONFIG } from '../../constants'
+import { RegistrationDto } from '../../auth/providers/local-userpass/dtos'
+import { AUTH_ENDPOINTS, PROVIDER_TYPE, REGISTRATION_SCHEMA } from '../../auth/utils'
+import { API_VERSION, AUTH_CONFIG, DB_NAME, DEFAULT_CONFIG } from '../../constants'
+import { hashPassword } from '../crypto'
 
 /**
  * > Used to expose all app routes
@@ -13,14 +16,65 @@ export const exposeRoutes = async (fastify: FastifyInstance) => {
       deployment_model: 'LOCAL',
       location: 'IE',
       hostname: `${DEFAULT_CONFIG.HTTPS_SCHEMA}://${req.headers.host}`,
-      ws_hostname: `${DEFAULT_CONFIG.HTTPS_SCHEMA === "https" ? "wss" : "ws"}://${req.headers.host}`
+      ws_hostname: `${DEFAULT_CONFIG.HTTPS_SCHEMA === 'https' ? 'wss' : 'ws'}://${req.headers.host}`
     }))
 
     fastify.get('/health', async () => ({
       status: 'ok',
       uptime: uptime()
     }))
+
+    fastify.post<RegistrationDto>(AUTH_ENDPOINTS.FIRST_USER, {
+      schema: REGISTRATION_SCHEMA
+    }, async function (req, res) {
+      const { authCollection } = AUTH_CONFIG
+      const db = fastify.mongo.client.db(DB_NAME)
+      const { email, password } = req.body
+      const hashedPassword = await hashPassword(password)
+
+      const users = db.collection(authCollection!).find()
+
+      const list = await users?.toArray()
+
+      if (list?.length) {
+        res.status(409)
+        return {
+          error: `The ${authCollection} collection is not empty`
+        }
+      }
+
+      const result = await db.collection(authCollection!).insertOne({
+        email: email,
+        password: hashedPassword,
+        custom_data: {}
+      })
+
+      await db?.collection(authCollection!).updateOne(
+        {
+          email: email
+        },
+        {
+          $set: {
+            identities: [
+              {
+                id: result?.insertedId.toString(),
+                provider_id: result?.insertedId.toString(),
+                provider_type: PROVIDER_TYPE,
+                provider_data: { email }
+              }
+            ]
+          }
+        }
+      )
+
+      res.status(201)
+      return {
+        userId: result?.insertedId
+      }
+    })
   } catch (e) {
     console.error('Error while exposing routes', (e as Error).message)
   }
 }
+
+

package/src/utils/initializer/registerPlugins.ts

@@ -46,13 +46,11 @@ export const registerPlugins = async ({
     registersConfig.forEach(({ plugin, options, pluginName }) => {
       try {
         register(plugin, options)
-        console.log("registration COMPLETED --->", pluginName)
+        console.log('registration COMPLETED --->', pluginName)
+      } catch (e) {
+        console.log('Registration FAILED --->', pluginName)
+        console.log('Error --->', e)
       }
-      catch (e) {
-        console.log("Registration FAILED --->", pluginName)
-        console.log("Error --->", e)
-      }
-
     })
   } catch (e) {
     console.error('Error while registering plugins', (e as Error).message)
@@ -63,7 +61,7 @@ export const registerPlugins = async ({
  * > Used to generate the register congig
  * @param mongodbUrl -> the database connection string
  * @param jwtSecret -> connection jwt
- * @testable  
+ * @testable
  */
 const getRegisterConfig = async ({
   mongodbUrl,
@@ -73,15 +71,15 @@ const getRegisterConfig = async ({
 > => {
   return [
     {
-      pluginName: "cors",
+      pluginName: 'cors',
       plugin: cors,
       options: {
         origin: '*',
-        methods: ['POST', 'GET']
+        methods: ['POST', 'GET', 'DELETE']
       }
     },
     {
-      pluginName: "fastifyMongodb",
+      pluginName: 'fastifyMongodb',
       plugin: fastifyMongodb,
       options: {
         forceClose: true,
@@ -89,19 +87,19 @@ const getRegisterConfig = async ({
       }
     },
     {
-      pluginName: "jwtAuthPlugin",
+      pluginName: 'jwtAuthPlugin',
       plugin: jwtAuthPlugin,
       options: {
         secret: jwtSecret
       }
     },
     {
-      pluginName: "authController",
+      pluginName: 'authController',
       plugin: authController,
       options: { prefix: `${API_VERSION}/auth` }
     },
     {
-      pluginName: "localUserPassController",
+      pluginName: 'localUserPassController',
       plugin: localUserPassController,
       options: {
         prefix: `${API_VERSION}/app/:appId/auth/providers/local-userpass`

package/src/utils/roles/helpers.ts

@@ -6,29 +6,40 @@ import rulesMatcherUtils from '../rules-matcher/utils'
 import { PermissionExpression } from './interface'
 import { MachineContext } from './machines/interface'
 
-const functionsConditions = ["%%true", "%%false"]
+const functionsConditions = ['%%true', '%%false']
 
-export const evaluateExpression = async (params: MachineContext["params"], expression?: PermissionExpression, user?: MachineContext["user"]): Promise<boolean> => {
+export const evaluateExpression = async (
+  params: MachineContext['params'],
+  expression?: PermissionExpression,
+  user?: MachineContext['user']
+): Promise<boolean> => {
   if (!expression || typeof expression === 'boolean') return !!expression
 
   const value = {
     ...params.expansions,
     ...params.cursor,
-    "%%user": user,
+    '%%user': user,
     '%%true': true
   }
   const conditions = expandQuery(expression, value)
-  const complexCondition = Object.entries<Record<string, any>>(conditions).find(([key]) => functionsConditions.includes(key))
-  return complexCondition ? await evaluateComplexExpression(complexCondition, params, user) : rulesMatcherUtils.checkRule(conditions, value, {})
-
+  const complexCondition = Object.entries<Record<string, any>>(conditions).find(([key]) =>
+    functionsConditions.includes(key)
+  )
+  return complexCondition
+    ? await evaluateComplexExpression(complexCondition, params, user)
+    : rulesMatcherUtils.checkRule(conditions, value, {})
 }
 
-const evaluateComplexExpression = async (condition: [string, Record<string, any>], params: MachineContext["params"], user: MachineContext["user"]) => {
+const evaluateComplexExpression = async (
+  condition: [string, Record<string, any>],
+  params: MachineContext['params'],
+  user: MachineContext['user']
+) => {
   const [key, config] = condition
 
-  const { name } = config["%function"]
-  const functionsList = StateManager.select("functions")
-  const app = StateManager.select("app")
+  const { name } = config['%function']
+  const functionsList = StateManager.select('functions')
+  const app = StateManager.select('app')
   const currentFunction = functionsList[name]
   const response = await GenerateContext({
     args: [params.cursor],
@@ -39,9 +50,5 @@ const evaluateComplexExpression = async (condition: [string, Record<string, any>
     functionsList,
     services
   })
-  return key === "%%true" ? response : !response
-
+  return key === '%%true' ? response : !response
 }
-
-
-

package/src/utils/roles/interface.ts

@@ -1,7 +1,7 @@
 export type PermissionExpression = boolean // TODO: add complex condition (%%true: %function)
 
 export type FieldPermissionExpression = {
-  read?: boolean,
+  read?: boolean
   write?: boolean
 }
 
@@ -37,6 +37,5 @@ export interface Params {
   type: 'insert' | 'read' | 'delete' | 'search' | 'write'
 }
 
-
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-export type Condition = Record<string, any>
+export type Condition = Record<string, any>

package/src/utils/roles/machines/commonValidators.ts

@@ -1,24 +1,33 @@
-import { someAsync } from "../../helpers/someAsync"
-import { evaluateExpression } from "../helpers"
-import { DocumentFiltersPermissions } from "../interface"
-import { MachineContext } from "./interface"
+import { someAsync } from '../../helpers/someAsync'
+import { evaluateExpression } from '../helpers'
+import { DocumentFiltersPermissions } from '../interface'
+import { MachineContext } from './interface'
 
 const readOnlyPermissions = ['read']
 const readWritePermissions = ['write', 'delete', 'insert', ...readOnlyPermissions]
 
-export const evaluateDocumentFiltersFn = async ({ params, role, user }: MachineContext, currentType: keyof DocumentFiltersPermissions) => {
-    const permissions = currentType === "read" ? readOnlyPermissions : readWritePermissions
-    return await someAsync([
-        permissions.includes(params.type) && role.document_filters?.[currentType]
-    ]
-        .filter(Boolean), async (expr) => evaluateExpression(params, expr, user))
+export const evaluateDocumentFiltersFn = async (
+  { params, role, user }: MachineContext,
+  currentType: keyof DocumentFiltersPermissions
+) => {
+  const permissions = currentType === 'read' ? readOnlyPermissions : readWritePermissions
+  return await someAsync(
+    [permissions.includes(params.type) && role.document_filters?.[currentType]].filter(
+      Boolean
+    ),
+    async (expr) => evaluateExpression(params, expr, user)
+  )
 }
 
-
-export const evaluateTopLevelPermissionsFn = async ({ params, role, user }: MachineContext, currentType: MachineContext["params"]["type"]) => {
-    return role[currentType] ? await evaluateExpression(params, role[currentType], user) : undefined
+export const evaluateTopLevelPermissionsFn = async (
+  { params, role, user }: MachineContext,
+  currentType: MachineContext['params']['type']
+) => {
+  return role[currentType]
+    ? await evaluateExpression(params, role[currentType], user)
+    : undefined
 }
 
 export const checkFieldsPropertyExists = ({ role }: MachineContext) => {
-    return !!Object.keys(role.fields ?? {}).length
+  return !!Object.keys(role.fields ?? {}).length
 }

package/src/utils/roles/machines/index.ts

@@ -9,12 +9,15 @@ import { StateMachine } from './machine'
  * @param {Role} role - The role configuration for validation.
  * @param {Params} params - The parameters relevant to the validation process.
  * @param {User} user - The user for whom the validation is being performed.
- * 
+ *
  * @returns {Promise<StepResult>} - The result of the state machine's validation process.
  */
-export const checkValidation = async (role: Role, params: Params, user: User, enableLog?: boolean): Promise<StepResult> => {
+export const checkValidation = async (
+  role: Role,
+  params: Params,
+  user: User,
+  enableLog?: boolean
+): Promise<StepResult> => {
   const stateMachine = new StateMachine(role, params, user, enableLog)
   return await stateMachine.runValidation()
 }
-
-

package/src/utils/roles/machines/interface.ts

@@ -17,7 +17,13 @@ type StateFunction = (
     context: MachineContext
   } & {
     next: (step: string, params?: Record<string, any>) => void
-    endValidation: ({ success, document }: { success: boolean, document?: Document }) => void
+    endValidation: ({
+      success,
+      document
+    }: {
+      success: boolean
+      document?: Document
+    }) => void
     goToNextValidationStage: (initialStep?: string | null) => void
   }
 ) => Promise<void>
@@ -33,14 +39,20 @@ export interface ValidationStatus {
   document?: Document
 }
 
+export interface StepResult {
+  status: boolean | null
+  nextInitialStep: string | null
+  document?: Document
+}
 
-export interface StepResult { status: boolean | null; nextInitialStep: string | null; document?: Document }
-
-export interface EndValidationParams { success: boolean, document?: Document }
+export interface EndValidationParams {
+  success: boolean
+  document?: Document
+}
 
 export type LogMachineInfoParams = {
   enabled?: boolean
   machine: string
   step: number
   stepName: string
-}
+}

package/src/utils/roles/machines/machine.ts

@@ -1,85 +1,110 @@
-import { Document } from "mongodb"
-import { User } from "../../../auth/dtos";
-import { Params, Role } from "../interface";
-import { MachineContext, PrevParams, States, StepResult, ValidationStatus } from "./interface";
-import { READ_MACHINE } from "./read";
-import { WRITE_MACHINE } from "./write";
+import { Document } from 'mongodb'
+import { User } from '../../../auth/dtos'
+import { Params, Role } from '../interface'
+import {
+  MachineContext,
+  PrevParams,
+  States,
+  StepResult,
+  ValidationStatus
+} from './interface'
+import { READ_MACHINE } from './read'
+import { WRITE_MACHINE } from './write'
 
 export class StateMachine {
-    private _context: MachineContext
-    private _validation: StepResult = {
-        status: null,
-        nextInitialStep: null
-    }
-    private _machines: States[]
-    private _currentStep: {
-        names: readonly string[]
-        states: States
-        validation: ValidationStatus,
-        completed?: boolean,
-        initialStep: string | null
-    }
-    constructor(role: Role, params: Params, user: User, enableLog?: boolean) {
-        this._context = { role, params, user, enableLog }
-        this._machines = params.type === "read" ? READ_MACHINE : WRITE_MACHINE
-        this._currentStep = {
-            names: [],
-            states: {},
-            validation: {
-                status: null
-            },
-            initialStep: null
-        }
+  private _context: MachineContext
+  private _validation: StepResult = {
+    status: null,
+    nextInitialStep: null
+  }
+  private _machines: States[]
+  private _currentStep: {
+    names: readonly string[]
+    states: States
+    validation: ValidationStatus
+    completed?: boolean
+    initialStep: string | null
+  }
+  constructor(role: Role, params: Params, user: User, enableLog?: boolean) {
+    this._context = { role, params, user, enableLog }
+    this._machines = params.type === 'read' ? READ_MACHINE : WRITE_MACHINE
+    this._currentStep = {
+      names: [],
+      states: {},
+      validation: {
+        status: null
+      },
+      initialStep: null
     }
+  }
 
-    async runValidation() {
-        for await (const machine of this._machines) {
-            this._currentStep = { names: Object.freeze(Object.keys(machine)) as readonly (keyof typeof machine)[], states: machine, validation: { status: null }, initialStep: null }
-            await this.runMachine(this._validation.nextInitialStep);
+  async runValidation() {
+    for await (const machine of this._machines) {
+      this._currentStep = {
+        names: Object.freeze(Object.keys(machine)) as readonly (keyof typeof machine)[],
+        states: machine,
+        validation: { status: null },
+        initialStep: null
+      }
+      await this.runMachine(this._validation.nextInitialStep)
 
-            this._validation.nextInitialStep = this._currentStep.initialStep;
-            if (this._currentStep.validation.status !== null) {
-                this._validation.status = this._currentStep.validation.status;
-                this._validation.document = this._currentStep.validation.document;
-                break;
-            }
-        }
-        return this._validation;
+      this._validation.nextInitialStep = this._currentStep.initialStep
+      if (this._currentStep.validation.status !== null) {
+        this._validation.status = this._currentStep.validation.status
+        this._validation.document = this._currentStep.validation.document
+        break
+      }
     }
+    return this._validation
+  }
 
-    private async runMachine(initialStep: string | null) {
-        const executeStep = async (step: keyof typeof this._currentStep.states, params?: PrevParams) => {
-            const currentStep = this._currentStep.states[step]
-            const next = (nextStep: keyof typeof this._currentStep.states, params?: PrevParams) =>
-                executeStep(nextStep, params)
-
-            await currentStep({
-                context: { ...this._context, prevParams: params },
-                next,
-                endValidation: this.endValidation.bind(this),
-                goToNextValidationStage: this.goToNextValidationStage.bind(this),
-                initialStep
-            })
+  private async runMachine(initialStep: string | null) {
+    const executeStep = async (
+      step: keyof typeof this._currentStep.states,
+      params?: PrevParams
+    ) => {
+      const currentStep = this._currentStep.states[step]
+      const next = (
+        nextStep: keyof typeof this._currentStep.states,
+        params?: PrevParams
+      ) => executeStep(nextStep, params)
 
-            if (this._currentStep.validation.status !== null || this._currentStep.completed !== undefined)
-                return { isValid: this._currentStep.validation.status, ...this._currentStep }
-        }
-        const nextStep = initialStep && this._currentStep.states[initialStep] ? initialStep : this._currentStep.names[0]
-        await executeStep(nextStep)
-    }
+      await currentStep({
+        context: { ...this._context, prevParams: params },
+        next,
+        endValidation: this.endValidation.bind(this),
+        goToNextValidationStage: this.goToNextValidationStage.bind(this),
+        initialStep
+      })
 
-    private endValidation({ success, document }: { success: boolean, document?: Document }) {
-        this._currentStep.validation.status = success
-        if (success) {
-            this._currentStep.validation.document = document || this._context.params.cursor
-        }
+      if (
+        this._currentStep.validation.status !== null ||
+        this._currentStep.completed !== undefined
+      )
+        return { isValid: this._currentStep.validation.status, ...this._currentStep }
     }
+    const nextStep =
+      initialStep && this._currentStep.states[initialStep]
+        ? initialStep
+        : this._currentStep.names[0]
+    await executeStep(nextStep)
+  }
 
-
-    private goToNextValidationStage(initialStep: string | null = null) {
-        this._currentStep.completed = true
-        this._currentStep.initialStep = initialStep
+  private endValidation({
+    success,
+    document
+  }: {
+    success: boolean
+    document?: Document
+  }) {
+    this._currentStep.validation.status = success
+    if (success) {
+      this._currentStep.validation.document = document || this._context.params.cursor
     }
+  }
 
-
-}
+  private goToNextValidationStage(initialStep: string | null = null) {
+    this._currentStep.completed = true
+    this._currentStep.initialStep = initialStep
+  }
+}

package/src/utils/roles/machines/read/A/index.ts

@@ -3,17 +3,25 @@ import { logMachineInfo } from '../../utils'
 
 export const STEP_A_STATES: States = {
   checkSearchRequest: async ({ context, next, goToNextValidationStage }) => {
-    logMachineInfo({ enabled: context.enableLog, machine: "A", step: 1, stepName: "checkSearchRequest" })
+    logMachineInfo({
+      enabled: context.enableLog,
+      machine: 'A',
+      step: 1,
+      stepName: 'checkSearchRequest'
+    })
     if (context.params.type === 'search') {
       return next('evaluateSearch')
     }
     return goToNextValidationStage()
   },
   evaluateSearch: async ({ context, endValidation }) => {
-    logMachineInfo({ enabled: context.enableLog, machine: "A", step: 2, stepName: "evaluateSearch" })
+    logMachineInfo({
+      enabled: context.enableLog,
+      machine: 'A',
+      step: 2,
+      stepName: 'evaluateSearch'
+    })
     // NOTE -> we don't support search operations
     return endValidation({ success: false })
   }
 }
-
-

package/src/utils/roles/machines/read/B/index.ts

@@ -4,7 +4,12 @@ import { logMachineInfo } from '../../utils'
 
 export const STEP_B_STATES: States = {
   checkDocumentsFilters: async ({ context, next, goToNextValidationStage }) => {
-    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 1, stepName: "checkDocumentsFilters" })
+    logMachineInfo({
+      enabled: context.enableLog,
+      machine: 'B',
+      step: 1,
+      stepName: 'checkDocumentsFilters'
+    })
     const { role } = context
     if (role.document_filters) {
       return next('evaluateDocumentsFiltersRead')
@@ -12,8 +17,13 @@ export const STEP_B_STATES: States = {
     return goToNextValidationStage()
   },
   evaluateDocumentsFiltersRead: async ({ context, next, goToNextValidationStage }) => {
-    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 2, stepName: "evaluateDocumentsFiltersRead" })
-    const hasDocumentFiltersRead = await evaluateDocumentFiltersFn(context, "read")
+    logMachineInfo({
+      enabled: context.enableLog,
+      machine: 'B',
+      step: 2,
+      stepName: 'evaluateDocumentsFiltersRead'
+    })
+    const hasDocumentFiltersRead = await evaluateDocumentFiltersFn(context, 'read')
     if (!hasDocumentFiltersRead) return next('evaluateDocumentsFiltersWrite')
     return goToNextValidationStage()
   },
@@ -22,10 +32,13 @@ export const STEP_B_STATES: States = {
     endValidation,
     goToNextValidationStage
   }) => {
-    logMachineInfo({ enabled: context.enableLog, machine: "B", step: 3, stepName: "evaluateDocumentsFiltersWrite" })
-    const check = await evaluateDocumentFiltersFn(context, "write")
+    logMachineInfo({
+      enabled: context.enableLog,
+      machine: 'B',
+      step: 3,
+      stepName: 'evaluateDocumentsFiltersWrite'
+    })
+    const check = await evaluateDocumentFiltersFn(context, 'write')
     return check ? goToNextValidationStage() : endValidation({ success: false })
   }
 }
-
-

package/src/utils/roles/machines/read/C/index.ts

@@ -1,30 +1,46 @@
-import { checkFieldsPropertyExists, evaluateTopLevelPermissionsFn } from '../../commonValidators'
+import {
+  checkFieldsPropertyExists,
+  evaluateTopLevelPermissionsFn
+} from '../../commonValidators'
 import { States } from '../../interface'
 import { logMachineInfo } from '../../utils'
 
-
 export const STEP_C_STATES: States = {
   evaluateTopLevelRead: async ({ context, next, endValidation }) => {
-    logMachineInfo({ enabled: context.enableLog, machine: "C", step: 1, stepName: "evaluateTopLevelRead" })
-    const check = await evaluateTopLevelPermissionsFn(context, "read")
+    logMachineInfo({
+      enabled: context.enableLog,
+      machine: 'C',
+      step: 1,
+      stepName: 'evaluateTopLevelRead'
+    })
+    const check = await evaluateTopLevelPermissionsFn(context, 'read')
     return check
       ? endValidation({ success: true })
       : next('evaluateTopLevelWrite', { check })
   },
   evaluateTopLevelWrite: async ({ context, next, endValidation }) => {
-    logMachineInfo({ enabled: context.enableLog, machine: "C", step: 2, stepName: "evaluateTopLevelWrite" })
-    const check = await evaluateTopLevelPermissionsFn(context, "write")
+    logMachineInfo({
+      enabled: context.enableLog,
+      machine: 'C',
+      step: 2,
+      stepName: 'evaluateTopLevelWrite'
+    })
+    const check = await evaluateTopLevelPermissionsFn(context, 'write')
     if (check) return endValidation({ success: true })
     return context?.prevParams?.check === false
       ? endValidation({ success: false })
       : next('checkFieldsProperty')
   },
   checkFieldsProperty: async ({ context, goToNextValidationStage }) => {
-    logMachineInfo({ enabled: context.enableLog, machine: "C", step: 3, stepName: "checkFieldsProperty" })
+    logMachineInfo({
+      enabled: context.enableLog,
+      machine: 'C',
+      step: 3,
+      stepName: 'checkFieldsProperty'
+    })
     const check = checkFieldsPropertyExists(context)
     return goToNextValidationStage(
       check ? 'checkIsValidFieldName' : 'checkAdditionalFields'
     )
   }
 }
-