@flowerforce/flowerbase 1.2.0 → 1.2.1-beta.11

package/src/utils/context/index.ts

@@ -1,10 +1,116 @@
 import { createRequire } from 'node:module'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
 import vm from 'vm'
 import { EJSON } from 'bson'
 import { StateManager } from '../../state'
 import { generateContextData } from './helpers'
 import { GenerateContextParams } from './interface'
 
+const dynamicImport = new Function('specifier', 'return import(specifier)') as (
+  specifier: string
+) => Promise<Record<string, unknown>>
+
+const transformImportsToRequire = (code: string): string => {
+  let importIndex = 0
+  const lines = code.split(/\r?\n/)
+
+  return lines
+    .map((line) => {
+      const trimmed = line.trim()
+
+      if (/^import\s+type\s+/.test(trimmed)) {
+        return ''
+      }
+
+      const sideEffectMatch = trimmed.match(/^import\s+['"]([^'"]+)['"]\s*;?$/)
+      if (sideEffectMatch) {
+        return `require('${sideEffectMatch[1]}')`
+      }
+
+      const match = trimmed.match(/^import\s+(.+?)\s+from\s+['"]([^'"]+)['"]\s*;?$/)
+      if (!match) return line
+
+      const [, importClause, source] = match
+      const clause = importClause.trim()
+
+      if (clause.startsWith('{') && clause.endsWith('}')) {
+        const named = clause.slice(1, -1).trim()
+        return `const { ${named} } = require('${source}')`
+      }
+
+      const namespaceMatch = clause.match(/^\*\s+as\s+(\w+)$/)
+      if (namespaceMatch) {
+        return `const ${namespaceMatch[1]} = require('${source}')`
+      }
+
+      if (clause.includes(',')) {
+        const [defaultPart, restRaw] = clause.split(',', 2)
+        const defaultName = defaultPart.trim()
+        const rest = restRaw.trim()
+        const tmpName = `__fb_import_${importIndex++}`
+        const linesOut = [`const ${tmpName} = require('${source}')`]
+
+        if (defaultName) {
+          linesOut.push(`const ${defaultName} = ${tmpName}`)
+        }
+
+        if (rest.startsWith('{') && rest.endsWith('}')) {
+          const named = rest.slice(1, -1).trim()
+          linesOut.push(`const { ${named} } = ${tmpName}`)
+        } else {
+          const nsMatch = rest.match(/^\*\s+as\s+(\w+)$/)
+          if (nsMatch) {
+            linesOut.push(`const ${nsMatch[1]} = ${tmpName}`)
+          }
+        }
+
+        return linesOut.join('\n')
+      }
+
+      return `const ${clause} = require('${source}')`
+    })
+    .join('\n')
+}
+
+const wrapEsmModule = (code: string): string => {
+  const prelude = [
+    'const __fb_module = { exports: {} };',
+    'let exports = __fb_module.exports;',
+    'let module = __fb_module;',
+    'const __fb_require = globalThis.__fb_require;',
+    'const require = __fb_require;',
+    'const __filename = globalThis.__fb_filename;',
+    'const __dirname = globalThis.__fb_dirname;'
+  ].join('\n')
+
+  const trailer = [
+    'globalThis.__fb_module = __fb_module;',
+    'globalThis.__fb_exports = exports;'
+  ].join('\n')
+
+  return `${prelude}\n${code}\n${trailer}`
+}
+
+const resolveImportTarget = (specifier: string, customRequire: NodeRequire): string => {
+  try {
+    const resolved = customRequire.resolve(specifier)
+    if (resolved.startsWith('node:')) return resolved
+    if (path.isAbsolute(resolved)) {
+      return pathToFileURL(resolved).href
+    }
+    return resolved
+  } catch {
+    return specifier
+  }
+}
+
+const shouldFallbackFromVmModules = (error: unknown): boolean => {
+  if (!error || typeof error !== 'object') return false
+  const code = (error as { code?: string }).code
+  return code === 'ERR_VM_MODULES_DISABLED' || code === 'ERR_VM_MODULES_NOT_SUPPORTED'
+}
+
 /**
  * > Used to generate the current context
  * @testable
@@ -28,7 +134,8 @@ export async function GenerateContext({
   deserializeArgs = true,
   enqueue,
   request
-}: GenerateContextParams) {
+}: GenerateContextParams): Promise<unknown> {
+  if (!currentFunction) return
 
   const functionsQueue = StateManager.select("functionsQueue")
 
@@ -47,27 +154,145 @@ export async function GenerateContext({
       request
     })
 
+    type ExportedFunction = (...args: unknown[]) => unknown
+    type SandboxModule = { exports: unknown }
+    type SandboxContext = vm.Context & {
+      exports?: unknown
+      module?: SandboxModule
+      __fb_module?: SandboxModule
+      __fb_exports?: unknown
+      __fb_require?: NodeRequire
+      __fb_filename?: string
+      __fb_dirname?: string
+    }
+
+    const isExportedFunction = (value: unknown): value is ExportedFunction =>
+      typeof value === 'function'
+
+    const getDefaultExport = (value: unknown): ExportedFunction | undefined => {
+      if (!value || typeof value !== 'object') return undefined
+      if (!('default' in value)) return undefined
+      const maybeDefault = (value as { default?: unknown }).default
+      return isExportedFunction(maybeDefault) ? maybeDefault : undefined
+    }
+
+    const resolveExport = (ctx: SandboxContext): ExportedFunction | undefined => {
+      const moduleExports = ctx.module?.exports ?? ctx.__fb_module?.exports
+      if (isExportedFunction(moduleExports)) return moduleExports
+      const contextExports = ctx.exports ?? ctx.__fb_exports
+      if (isExportedFunction(contextExports)) return contextExports
+      return getDefaultExport(moduleExports) ?? getDefaultExport(contextExports)
+    }
+
+    const sandboxModule: SandboxModule = { exports: {} }
+
     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
-      }));
+      const entryFile = require.main?.filename ?? process.cwd()
+      const customRequire = createRequire(entryFile)
+
+      const vmContext: SandboxContext = vm.createContext({
+        ...contextData,
+        require: customRequire,
+        exports: sandboxModule.exports,
+        module: sandboxModule,
+        __filename,
+        __dirname,
+        __fb_require: customRequire,
+        __fb_filename: __filename,
+        __fb_dirname: __dirname
+      }) as SandboxContext
+
+      const vmModules = vm as typeof vm & {
+        SourceTextModule?: typeof vm.SourceTextModule
+        SyntheticModule?: typeof vm.SyntheticModule
+      }
+      const hasStaticImport = /\bimport\s+/.test(functionToRun.code)
+      let usedVmModules = false
+
+      if (hasStaticImport && vmModules.SourceTextModule && vmModules.SyntheticModule) {
+        try {
+          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 namespace = await dynamicImport(importTarget)
+            const exportNames = Object.keys(namespace)
+            if ('default' in namespace && !exportNames.includes('default')) {
+              exportNames.push('default')
+            }
+
+            const syntheticModule = new vmModules.SyntheticModule(
+              exportNames,
+              function () {
+                for (const name of exportNames) {
+                  this.setExport(name, namespace[name])
+                }
+              },
+              { 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()
+          }
+          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
+          }
+        )
+
+          await sourceModule.link(loadModule)
+          await sourceModule.evaluate()
+          usedVmModules = true
+        } catch (error) {
+          if (!shouldFallbackFromVmModules(error)) {
+            throw error
+          }
+        }
+      }
+
+      if (!usedVmModules) {
+        const codeToRun = functionToRun.code.includes('import ')
+          ? transformImportsToRequire(functionToRun.code)
+          : functionToRun.code
+        vm.runInContext(codeToRun, vmContext)
+      }
+
+      sandboxModule.exports = resolveExport(vmContext) ?? sandboxModule.exports
     }
     catch (e) {
       console.log(e)
     }
 
     if (deserializeArgs) {
-      return await module.exports(...EJSON.deserialize(args))
+      return await (sandboxModule.exports as ExportedFunction)(
+        ...EJSON.deserialize(args)
+      )
     }
 
-    return await module.exports(...args)
+    return await (sandboxModule.exports as ExportedFunction)(...args)
   }
   const res = await functionsQueue.add(run, enqueue)
   return res

package/src/utils/context/interface.ts

@@ -20,5 +20,5 @@ export interface GenerateContextParams {
 
 type ContextRequest = Pick<FastifyRequest, "ips" | "host" | "hostname" | "url" | "method" | "ip" | "id">
 export interface GenerateContextDataParams extends Omit<GenerateContextParams, 'args'> {
-  GenerateContext: (params: GenerateContextParams) => Promise<void>
+  GenerateContext: (params: GenerateContextParams) => Promise<unknown>
 }

package/src/utils/crypto/index.ts

@@ -36,6 +36,10 @@ export const comparePassword = async (plaintext: string, storedPassword: string)
  * > Generate a random token
  * @param length -> the token length
  */
-export const generateToken = (length = 32) => {
+export const generateToken = (length = 64) => {
   return crypto.randomBytes(length).toString('hex')
 }
+
+export const hashToken = (token: string) => {
+  return crypto.createHash('sha256').update(token).digest('hex')
+}

package/src/utils/initializer/exposeRoutes.ts

@@ -13,12 +13,21 @@ import { hashPassword } from '../crypto'
  */
 export const exposeRoutes = async (fastify: FastifyInstance) => {
   try {
-    fastify.get(`${API_VERSION}/app/:appId/location`, async (req) => ({
-      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}`
-    }))
+    fastify.get(`${API_VERSION}/app/:appId/location`, async (req) => {
+      const schema = DEFAULT_CONFIG?.HTTPS_SCHEMA ?? 'http'
+      const headerHost = req.headers.host ?? 'localhost:3000'
+      const hostname = headerHost.split(':')[0]
+      const port = DEFAULT_CONFIG?.PORT ?? 3000
+      const host = `${hostname}:${port}`
+      const wsSchema = 'wss'
+
+      return {
+        deployment_model: 'LOCAL',
+        location: 'IE',
+        hostname: `${schema}://${host}`,
+        ws_hostname: `${wsSchema}://${host}`
+      }
+    })
 
     fastify.get('/health', async () => ({
       status: 'ok',
@@ -77,5 +86,3 @@ export const exposeRoutes = async (fastify: FastifyInstance) => {
     console.error('Error while exposing routes', (e as Error).message)
   }
 }
-
-

package/src/utils/initializer/registerPlugins.ts

@@ -2,6 +2,7 @@ import cors from '@fastify/cors'
 import fastifyMongodb from '@fastify/mongodb'
 import { FastifyInstance } from 'fastify'
 import fastifyRawBody from 'fastify-raw-body'
+import { CorsConfig } from '../../'
 import { authController } from '../../auth/controller'
 import jwtAuthPlugin from '../../auth/plugins/jwt'
 import { customFunctionController } from '../../auth/providers/custom-function/controller'
@@ -17,6 +18,7 @@ type RegisterPluginsParams = {
   mongodbUrl: string
   jwtSecret: string
   functionsList: Functions
+  corsConfig?: CorsConfig
 }
 
 type RegisterConfig = {
@@ -36,12 +38,14 @@ export const registerPlugins = async ({
   register,
   mongodbUrl,
   jwtSecret,
-  functionsList
+  functionsList,
+  corsConfig
 }: RegisterPluginsParams) => {
   try {
     const registersConfig = await getRegisterConfig({
       mongodbUrl,
       jwtSecret,
+      corsConfig,
       functionsList
     })
 
@@ -52,6 +56,7 @@ export const registerPlugins = async ({
       } catch (e) {
         console.log('Registration FAILED --->', pluginName)
         console.log('Error --->', e)
+        throw e
       }
     })
   } catch (e) {
@@ -67,18 +72,21 @@ export const registerPlugins = async ({
  */
 const getRegisterConfig = async ({
   mongodbUrl,
-  jwtSecret
-}: Pick<RegisterPluginsParams, 'jwtSecret' | 'mongodbUrl' | 'functionsList'>): Promise<
+  jwtSecret,
+  corsConfig
+}: Pick<RegisterPluginsParams, 'jwtSecret' | 'mongodbUrl' | 'functionsList' | 'corsConfig'>): Promise<
   RegisterConfig[]
 > => {
+  const corsOptions = corsConfig ?? {
+    origin: '*',
+    methods: ['POST', 'GET']
+  }
+
   return [
     {
       pluginName: 'cors',
       plugin: cors,
-      options: {
-        origin: '*',
-        methods: ['POST', 'GET', 'DELETE']
-      }
+      options: corsOptions
     },
     {
       pluginName: 'fastifyMongodb',

package/src/utils/roles/helpers.ts

@@ -22,7 +22,7 @@ export const evaluateExpression = async (
     '%%true': true
   }
   const conditions = expandQuery(expression, value)
-  const complexCondition = Object.entries<Record<string, any>>(conditions).find(([key]) =>
+  const complexCondition = Object.entries(conditions as Record<string, any>).find(([key]) =>
     functionsConditions.includes(key)
   )
   return complexCondition
@@ -34,15 +34,32 @@ const evaluateComplexExpression = async (
   condition: [string, Record<string, any>],
   params: MachineContext['params'],
   user: MachineContext['user']
-) => {
+): Promise<boolean> => {
   const [key, config] = condition
 
-  const { name } = config['%function']
+  const functionConfig = config['%function']
+  const { name, arguments: fnArguments } = functionConfig
   const functionsList = StateManager.select('functions')
   const app = StateManager.select('app')
   const currentFunction = functionsList[name]
+
+  const expansionContext = {
+    ...params.expansions,
+    ...params.cursor,
+    '%%root': params.cursor,
+    '%%user': user,
+    '%%true': true,
+    '%%false': false
+  }
+
+  const expandedArguments =
+    fnArguments && fnArguments.length
+      ? ((expandQuery({ args: fnArguments }, expansionContext) as { args: unknown[] })
+          .args ?? [])
+      : [params.cursor]
+
   const response = await GenerateContext({
-    args: [params.cursor],
+    args: expandedArguments,
     app,
     rules: StateManager.select("rules"),
     user,
@@ -50,5 +67,6 @@ const evaluateComplexExpression = async (
     functionsList,
     services
   })
-  return key === '%%true' ? response : !response
+  const isTruthy = Boolean(response)
+  return key === '%%true' ? isTruthy : !isTruthy
 }

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

@@ -3,7 +3,7 @@ import { evaluateExpression } from '../helpers'
 import { DocumentFiltersPermissions } from '../interface'
 import { MachineContext } from './interface'
 
-const readOnlyPermissions = ['read']
+const readOnlyPermissions = ['read', 'search']
 const readWritePermissions = ['write', 'delete', 'insert', ...readOnlyPermissions]
 
 export const evaluateDocumentFiltersFn = async (
@@ -23,11 +23,16 @@ export const evaluateTopLevelPermissionsFn = async (
   { params, role, user }: MachineContext,
   currentType: MachineContext['params']['type']
 ) => {
-  return role[currentType]
-    ? await evaluateExpression(params, role[currentType], user)
-    : undefined
+  const permission = role?.[currentType]
+  if (typeof permission === 'undefined') {
+    return undefined
+  }
+
+  return await evaluateExpression(params, permission, user)
 }
 
 export const checkFieldsPropertyExists = ({ role }: MachineContext) => {
-  return !!Object.keys(role.fields ?? {}).length
+  const hasFields = !!Object.keys(role?.fields ?? {}).length
+  const hasAdditional = !!Object.keys(role?.additional_fields ?? {}).length
+  return hasFields || hasAdditional
 }

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

@@ -0,0 +1,8 @@
+import { MachineContext } from '../../interface'
+import { evaluateDocumentFiltersFn } from '../../commonValidators'
+
+export const evaluateDocumentFiltersReadFn = (context: MachineContext) =>
+  evaluateDocumentFiltersFn(context, 'read')
+
+export const evaluateDocumentFiltersWriteFn = (context: MachineContext) =>
+  evaluateDocumentFiltersFn(context, 'write')

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

@@ -1,7 +1,8 @@
 import {
   checkFieldsPropertyExists,
-  evaluateTopLevelPermissionsFn
-} from '../../commonValidators'
+  evaluateTopLevelReadFn,
+  evaluateTopLevelWriteFn
+} from './validators'
 import { States } from '../../interface'
 import { logMachineInfo } from '../../utils'
 
@@ -13,10 +14,13 @@ export const STEP_C_STATES: States = {
       step: 1,
       stepName: 'evaluateTopLevelRead'
     })
-    const check = await evaluateTopLevelPermissionsFn(context, 'read')
-    return check
-      ? endValidation({ success: true })
-      : next('evaluateTopLevelWrite', { check })
+    const check = await evaluateTopLevelReadFn(context)
+    if (check) {
+      return checkFieldsPropertyExists(context)
+        ? next('checkFieldsProperty')
+        : endValidation({ success: true })
+    }
+    return next('evaluateTopLevelWrite', { check })
   },
   evaluateTopLevelWrite: async ({ context, next, endValidation }) => {
     logMachineInfo({
@@ -25,7 +29,7 @@ export const STEP_C_STATES: States = {
       step: 2,
       stepName: 'evaluateTopLevelWrite'
     })
-    const check = await evaluateTopLevelPermissionsFn(context, 'write')
+    const check = await evaluateTopLevelWriteFn(context)
     if (check) return endValidation({ success: true })
     return context?.prevParams?.check === false
       ? endValidation({ success: false })

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

@@ -0,0 +1,21 @@
+import { MachineContext } from '../../interface'
+import {
+  checkFieldsPropertyExists,
+  evaluateTopLevelPermissionsFn
+} from '../../commonValidators'
+
+export const evaluateTopLevelReadFn = async (context: MachineContext) => {
+  if (context.params.type !== 'read') {
+    return false
+  }
+  return evaluateTopLevelPermissionsFn(context, 'read')
+}
+
+export const evaluateTopLevelWriteFn = async (context: MachineContext) => {
+  if (!['read', 'write'].includes(context.params.type)) {
+    return undefined
+  }
+  return evaluateTopLevelPermissionsFn(context, 'write')
+}
+
+export { checkFieldsPropertyExists } from '../../commonValidators'

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

@@ -1,7 +1,25 @@
-import { States } from '../../interface'
+import { Document } from 'mongodb'
+import { MachineContext, States } from '../../interface'
 import { logMachineInfo } from '../../utils'
 import { checkAdditionalFieldsFn, checkIsValidFieldNameFn } from './validators'
 
+const runCheckIsValidFieldName = async ({
+  context,
+  endValidation
+}: {
+  context: MachineContext
+  endValidation: ({ success, document }: { success: boolean; document?: Document }) => void
+}) => {
+  logMachineInfo({
+    enabled: context.enableLog,
+    machine: 'D',
+    step: 2,
+    stepName: 'checkIsValidFieldName'
+  })
+  const document = checkIsValidFieldNameFn(context)
+  return endValidation({ success: !!Object.keys(document).length, document })
+}
+
 export const STEP_D_STATES: States = {
   checkAdditionalFields: async ({ context, next, endValidation }) => {
     logMachineInfo({
@@ -11,16 +29,8 @@ export const STEP_D_STATES: States = {
       stepName: 'checkAdditionalFields'
     })
     const check = checkAdditionalFieldsFn(context)
-    return check ? next('checkIsValidFieldName') : endValidation({ success: false })
+    return check ? next('evaluateRead') : endValidation({ success: false })
   },
-  checkIsValidFieldName: async ({ context, endValidation }) => {
-    logMachineInfo({
-      enabled: context.enableLog,
-      machine: 'D',
-      step: 2,
-      stepName: 'checkIsValidFieldName'
-    })
-    const document = checkIsValidFieldNameFn(context)
-    return endValidation({ success: !!Object.keys(document).length, document })
-  }
+  evaluateRead: runCheckIsValidFieldName,
+  checkIsValidFieldName: runCheckIsValidFieldName
 }

package/src/utils/rules.ts

@@ -1,31 +1,40 @@
 import get from 'lodash/get'
 
-const removeExtraColons = (val: unknown) => {
-  return val?.toString().replace(/:+/g, ":")
+const resolvePlaceholder = (value: string, objs: Record<string, unknown>) => {
+  if (!value.startsWith('%%')) return value
+
+  const path = value.slice(2)
+  const [rootKey, ...rest] = path.split('.')
+  const rootToken = `%%${rootKey}`
+  const rootValue = objs[rootToken]
+
+  if (!rest.length) {
+    return rootValue === undefined ? value : rootValue
+  }
+
+  const resolved = get(rootValue as object, rest.join('.'))
+  return resolved === undefined ? value : resolved
 }
 
-// Funzione che espande dinamicamente i placeholder con supporto per percorsi annidati
+const expandValue = (input: unknown, objs: Record<string, unknown>): unknown => {
+  if (Array.isArray(input)) {
+    return input.map((item) => expandValue(item, objs))
+  }
+  if (input && typeof input === 'object') {
+    return Object.fromEntries(
+      Object.entries(input).map(([key, val]) => [key, expandValue(val, objs)])
+    )
+  }
+  if (typeof input === 'string') {
+    return resolvePlaceholder(input, objs)
+  }
+  return input
+}
+
+// Espande dinamicamente i placeholder con supporto per array e percorsi annidati
 export function expandQuery(
   template: Record<string, unknown>,
   objs: Record<string, unknown>
 ) {
-  let expandedQuery = JSON.stringify(template) // Converti l'oggetto in una stringa per sostituire i placeholder
-  const regex = /:\s*"%%([a-zA-Z0-9_.]+)"/g
-  Object.keys(objs).forEach(() => {
-    // Espandi tutti i placeholder %%values.<nested.property>
-
-    const callback = (match: string, path: string) => {
-      const value = get(objs, `%%${path}`) // Recupera il valore annidato da values
-      const finalValue = typeof value === 'string' ? `"${value}"` : value && JSON.stringify(value)
-      // TODO tolto i primi : creava questo tipo di oggetto {"userId"::"%%user.id"}
-      const val = `:${value !== undefined ? finalValue : match}`; // Sostituisci se esiste, altrimenti lascia il placeholder
-      return removeExtraColons(val)
-    }
-
-    expandedQuery = expandedQuery.replace(
-      regex,
-      callback as Parameters<typeof expandedQuery.replaceAll>[1]
-    )
-  })
-  return JSON.parse(expandedQuery) // Converti la stringa JSON di nuovo in un oggetto
+  return expandValue(template, objs) as Record<string, unknown>
 }

package/tsconfig.spec.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "types": ["node", "jest"]
+  },
+  "include": ["src/**/*.test.ts", "src/**/*.spec.ts"]
+}