@volcanicminds/backend 2.0.4 → 2.1.1

package/lib/api/users/controller/user.ts

@@ -1,11 +1,11 @@
 import { FastifyReply, FastifyRequest } from 'fastify'
-import { AuthenticatedUser } from '../../../../types/global'
+import type { AuthenticatedUser } from '../../../../types/global.js'
 
 export async function getRoles(req: FastifyRequest, reply: FastifyReply) {
   const allRoles = Object.keys(roles).map((key) => roles[key])
   return reply.send(allRoles)
 }
-
+// ... resto del file invariato ...
 export async function count(req: FastifyRequest, reply: FastifyReply) {
   return req.server['userManager'].countQuery(req.data())
 }

package/lib/api/users/routes.ts

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
   config: {
     title: 'User functions',
     description: 'User functions',

package/lib/apollo/resolvers.ts

@@ -1,6 +1,6 @@
 'use strict'
 
-import { MyContext } from './context'
+import { MyContext } from './context.js'
 
 const resolvers = {
   Query: {

package/lib/config/general.ts

@@ -1,6 +1,4 @@
-'use strict'
-
-module.exports = {
+export default {
   name: 'general',
   enable: true,
   options: {

package/lib/config/plugins.ts

@@ -1,6 +1,4 @@
-'use strict'
-
-module.exports = [
+export default [
   {
     name: 'cors',
     enable: true,

package/lib/config/roles.ts

@@ -1,4 +1,4 @@
-module.exports = [
+export default [
   {
     code: 'public',
     name: 'Public',

package/lib/config/tracking.ts

@@ -1,4 +1,4 @@
-module.exports = {
+export default {
   config: {
     enableAll: false, // optional, default true
     changeEntity: 'Change', // optional, default 'Change'

package/lib/hooks/onError.ts

@@ -1,4 +1,4 @@
-module.exports = async (req, reply, error) => {
+export default async (req, reply, error) => {
   log.e && log.error(`${error}`)
   log.t && log.trace(error)
 }

package/lib/hooks/onRequest.ts

@@ -1,5 +1,5 @@
-import { getParams, getData } from '../util/common'
-import { AuthenticatedUser, AuthenticatedToken, Role } from '../../types/global'
+import { getParams, getData } from '../util/common.js'
+import type { AuthenticatedUser, AuthenticatedToken, Role } from '../../types/global.js'
 
 const { embedded_auth = true } = global.config?.options || {}
 
@@ -22,7 +22,7 @@ const normalizeRoles = (rolesArray: any[] | undefined): string[] => {
   return [roles.public.code]
 }
 
-module.exports = async (req, reply) => {
+export default async (req, reply) => {
   log.i && (req.startedAt = new Date())
 
   // Request enrichment
@@ -88,9 +88,11 @@ module.exports = async (req, reply) => {
       } catch (error) {
         const isRoutePublic = (cfg.requiredRoles || []).some((role: Role) => role.code === roles.public.code)
         if (!isRoutePublic) {
-          return reply
-            .status(401)
-            .send({ statusCode: 401, code: 'UNAUTHORIZED', message: error.message || 'Invalid or expired token' })
+          return reply.status(401).send({
+            statusCode: 401,
+            code: 'UNAUTHORIZED',
+            message: (error as any)?.message || 'Invalid or expired token'
+          })
         }
       }
     }

package/lib/hooks/onResponse.ts

@@ -1,4 +1,4 @@
-module.exports = async (req, reply) => {
+export default async (req, reply) => {
   let extraMessage: string = ''
   if (log.i && req.startedAt) {
     const elapsed: number = new Date().getTime() - req.startedAt.getTime()

package/lib/hooks/preHandler.ts

@@ -1,5 +1,5 @@
-import * as tracking from '../util/tracker'
+import * as tracking from '../util/tracker.js'
 
-module.exports = async (req, reply) => {
+export default async (req, reply) => {
   tracking.initialize(req, reply)
 }

package/lib/hooks/preSerialization.ts

@@ -1,7 +1,7 @@
 import sizeof from 'object-sizeof'
-import * as tracking from '../util/tracker'
+import * as tracking from '../util/tracker.js'
 
-module.exports = async (req, reply, payload) => {
+export default async (req, reply, payload) => {
   if (log.t) {
     req.payloadSize = sizeof(req.body) + sizeof(req.params) + sizeof(req.query)
     reply.payloadSize = sizeof(payload)

package/lib/loader/general.ts

@@ -1,8 +1,8 @@
-import { GeneralConfig } from '../../types/global'
-import { normalizePatterns } from '../util/path'
-const glob = require('glob')
+import type { GeneralConfig } from '../../types/global.js'
+import { normalizePatterns } from '../util/path.js'
+import { globSync } from 'glob'
 
-export function load() {
+export async function load() {
   const generalConfig: GeneralConfig = {
     name: 'general',
     enable: true,
@@ -15,10 +15,14 @@ export function load() {
   }
 
   const patterns = normalizePatterns(['..', 'config', 'general.{ts,js}'], ['src', 'config', 'general.{ts,js}'])
-  patterns.forEach((pattern) => {
+
+  for (const pattern of patterns) {
     log.t && log.trace('Looking for ' + pattern)
-    glob.sync(pattern).forEach((f: string) => {
-      const config: GeneralConfig = require(f)
+    const files = globSync(pattern, { windowsPathsNoEscape: true })
+
+    for (const f of files) {
+      const module = await import(f)
+      const config: GeneralConfig = module.default || module
 
       if (config.name === generalConfig.name) {
         generalConfig.enable = config.enable
@@ -27,8 +31,8 @@ export function load() {
           ...(config.options || {})
         }
       }
-    })
-  })
+    }
+  }
 
   log.d && log.debug('General configuration loaded')
   return generalConfig

package/lib/loader/hooks.ts

@@ -1,4 +1,6 @@
-import { normalizePatterns } from '../util/path'
+import { normalizePatterns } from '../util/path.js'
+import { globSync } from 'glob'
+import path from 'path'
 
 const hooks = [
   'onRequest',
@@ -16,27 +18,29 @@ const hooks = [
   'preHandler'
 ]
 
-const glob = require('glob')
-const path = require('path')
-
-export function apply(server: any): void {
+export async function apply(server: any): Promise<void> {
   const patterns = normalizePatterns(['..', 'hooks', '*.{ts,js}'], ['src', 'hooks', '*.{ts,js}'])
   const allHooks: any = hooks.reduce((acc, v) => ({ ...acc, [v]: [] as Function[] }), {})
 
-  patterns.forEach((pattern) => {
+  for (const pattern of patterns) {
     log.t && log.trace('Looking for ' + pattern)
-    glob.sync(pattern).forEach((f: string) => {
+    const files = globSync(pattern, { windowsPathsNoEscape: true })
+
+    for (const f of files) {
+      if (f.endsWith('.d.ts')) continue
+
       const hookName = path.basename(f, path.extname(f))
-      const fn = require(f)
+      const module = await import(f)
+      const fn = module.default || module
 
-      if (fn != null) {
+      if (fn != null && typeof fn === 'function') {
         if (allHooks[hookName] == null) {
           allHooks[hookName] = [] as Function[]
         }
         allHooks[hookName].push((...args) => fn(...args))
       }
-    })
-  })
+    }
+  }
 
   hooks.map((hookName) => {
     const fns: Function[] = allHooks[hookName]

package/lib/loader/plugins.ts

@@ -1,22 +1,26 @@
-import { config } from 'dotenv'
-import { normalizePatterns } from '../util/path'
+import { normalizePatterns } from '../util/path.js'
+import { globSync } from 'glob'
 
-const glob = require('glob')
-
-export function load() {
+export async function load() {
   const plugins: any = {}
 
   const patterns = normalizePatterns(['..', 'config', 'plugins.{ts,js}'], ['src', 'config', 'plugins.{ts,js}'])
-  patterns.forEach((pattern) => {
+
+  for (const pattern of patterns) {
     log.t && log.trace('Looking for ' + pattern)
-    glob.sync(pattern).forEach((f: string) => {
-      const configPlugins = require(f)
+    const files = globSync(pattern, { windowsPathsNoEscape: true })
+
+    for (const f of files) {
+      const module = await import(f)
+      const configPlugins = module.default || module
+
       configPlugins.forEach((plugin) => {
         plugins[plugin.name] = plugin.enable ? plugin.options : false
         log.t && log.trace(`* Plugin ${plugin.name} ${plugin.enable ? 'enabled' : 'disabled'}`)
       })
-    })
-  })
+    }
+  }
+
   const enabledPulgins = Object.keys(plugins).filter((p) => !!plugins[p])
   log.d && log.debug(`Plugins loaded: ${enabledPulgins.length > 0 ? enabledPulgins.join(', ') : 0}`)
   return plugins

package/lib/loader/roles.ts

@@ -1,21 +1,26 @@
-import { Role, Roles } from '../../types/global'
-import { normalizePatterns } from '../util/path'
-const glob = require('glob')
+import type { Role, Roles } from '../../types/global.js'
+import { normalizePatterns } from '../util/path.js'
+import { globSync } from 'glob'
 
-export function load() {
+export async function load() {
   const roles: Roles = {}
 
   const patterns = normalizePatterns(['..', 'config', 'roles.{ts,js}'], ['src', 'config', 'roles.{ts,js}'])
-  patterns.forEach((pattern) => {
+
+  for (const pattern of patterns) {
     log.t && log.trace('Looking for ' + pattern)
-    glob.sync(pattern).forEach((f: string) => {
-      const configRoles = require(f)
+    const files = globSync(pattern, { windowsPathsNoEscape: true })
+
+    for (const f of files) {
+      const module = await import(f)
+      const configRoles = module.default || module
 
       configRoles.forEach((role: Role) => {
         roles[role.code] = role
       })
-    })
-  })
+    }
+  }
+
   log.d && log.debug('Roles loaded: ' + Object.keys(roles).join(', '))
   return roles
 }

package/lib/loader/router.ts

@@ -1,26 +1,89 @@
-import yn from '../util/yn'
-import { Role, Route, ConfiguredRoute, RouteConfig } from '../../types/global'
+import yn from '../util/yn.js'
+import type { Role, Route, ConfiguredRoute, RouteConfig } from '../../types/global.js'
 import { FastifyReply, FastifyRequest } from 'fastify'
-import { normalizePatterns } from '../util/path'
+import { normalizePatterns } from '../util/path.js'
+import { globSync } from 'glob'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import require from '../util/require.js'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
 
-const glob = require('glob')
-const path = require('path')
 const methods = ['GET', 'POST', 'PUT', 'DELETE', 'HEAD', 'PATCH', 'OPTIONS']
 
-export function load(): ConfiguredRoute[] {
+async function tryToLoadFile(fileName: string) {
+  try {
+    const module = await import(fileName)
+    return module.default || module
+  } catch (err) {
+    return null
+  }
+}
+
+async function loadMiddleware(base: string, middleware: string = '') {
+  const key = 'global.'
+  const isGlobal = middleware.indexOf(key) > -1
+  let loadedModule: any = null
+
+  if (isGlobal) {
+    const name = middleware.substring(key.length)
+    // Prova path locali (es. src/middleware/auth.ts)
+    const localPath = path.resolve(process.cwd() + '/src/middleware/' + name + '.ts') // Prova TS
+    const localPathJs = path.resolve(process.cwd() + '/src/middleware/' + name + '.js') // Prova JS (dist)
+
+    loadedModule = await tryToLoadFile(localPath)
+    if (!loadedModule) loadedModule = await tryToLoadFile(localPathJs)
+
+    // Se non trova locale, prova interno alla lib
+    if (!loadedModule) {
+      const libPath = path.resolve(__dirname + '/../middleware/' + name + '.js')
+      loadedModule = await tryToLoadFile(libPath)
+    }
+  } else {
+    // Middleware locale alla route
+    const routeMiddPath = path.resolve(base + '/middleware/' + middleware)
+    // Qui è difficile indovinare l'estensione se non fornita, assumiamo che il loader sappia cosa fa o proviamo entrambe
+    loadedModule = await tryToLoadFile(routeMiddPath + '.ts')
+    if (!loadedModule) loadedModule = await tryToLoadFile(routeMiddPath + '.js')
+    if (!loadedModule) loadedModule = await tryToLoadFile(routeMiddPath) // Magari ha già estensione
+  }
+
+  if (!loadedModule) {
+    log.error(`Middleware ${middleware} not loaded`)
+    throw new Error(`Middleware ${middleware} not loaded`)
+  }
+  return loadedModule
+}
+
+async function loadMiddlewares(base: string, middlewares: string[] = []) {
+  const midds = {}
+  for (const m of middlewares) {
+    const middleware = await loadMiddleware(base, m)
+    // I middleware possono esportare più funzioni (preHandler, preSerialization, ecc.)
+    Object.keys(middleware).map((name) => (midds[name] = [...(midds[name] || []), middleware[name]]))
+  }
+  return midds
+}
+
+async function load(): Promise<ConfiguredRoute[]> {
   const validRoutes: ConfiguredRoute[] = []
   const patterns = normalizePatterns(['..', 'api', '**', 'routes.{ts,js}'], ['src', 'api', '**', 'routes.{ts,js}'])
   const authMiddlewares = ['global.isAuthenticated', 'global.isAdmin']
 
-  patterns.forEach((pattern) => {
+  for (const pattern of patterns) {
     log.t && log.trace('Looking for ' + pattern)
-    glob.sync(pattern).forEach((f: string, index: number, values: string[]) => {
+    const files = globSync(pattern, { windowsPathsNoEscape: true })
+
+    for (const f of files) {
+      if (f.endsWith('.d.ts')) continue
+
       const base = path.dirname(f)
       const dir = path.basename(base)
       const file = path.join(dir, path.basename(f))
 
-      // allow array or structure
-      const routesjs = require(f)
+      const module = await import(f)
+      const routesjs = module.default || module
       const { routes = [], config: defaultConfig = {} } = routesjs || {}
 
       log.t && log.trace(`* Add ${routes.length} routes from ${file}`)
@@ -41,7 +104,7 @@ export function load(): ConfiguredRoute[] {
         let requiredRoles: Role[] = []
 
         try {
-          requiredRoles = rsp.some((r) => r.code === roles.admin.code) ? rsp : [...rsp, roles.admin] // admin is always present
+          requiredRoles = rsp.some((r) => r.code === roles.admin.code) ? rsp : [...rsp, roles.admin]
         } catch (err) {
           log.e && log.error(`Error in loading roles for ${methodCase} ${pathName} (${handler})`)
           log.t && log.trace(err)
@@ -56,7 +119,6 @@ export function load(): ConfiguredRoute[] {
           config.security = 'bearer'
         }
 
-        // specific route config
         const {
           title = '',
           description = '',
@@ -73,24 +135,15 @@ export function load(): ConfiguredRoute[] {
           rawBody = false
         } = config || {}
 
-        // adjust something
         const endpoint = `${dir}${pathName.replace(/\/+$/, '')}`
         const method = methodCase.toUpperCase()
         const num = index + 1
         const handlerParts = handler.split('.')
 
         if (enable) {
-          if (!pathName.startsWith('/')) {
-            errors.push(`Error in [${file}] bad path [${pathName}] at route n. ${num}`)
-          }
-
-          if (!methods.includes(method)) {
-            errors.push(`Error in [${file}] bad method [${method}] at route n. ${num}`)
-          }
-
-          if (handlerParts.length !== 2) {
-            errors.push(`Error in [${file}] bad handler [${handler}] at route n. ${num}`)
-          }
+          if (!pathName.startsWith('/')) errors.push(`Error in [${file}] bad path [${pathName}] at route n. ${num}`)
+          if (!methods.includes(method)) errors.push(`Error in [${file}] bad method [${method}] at route n. ${num}`)
+          if (handlerParts.length !== 2) errors.push(`Error in [${file}] bad handler [${handler}] at route n. ${num}`)
 
           const key = method + endpoint + version
           if (validRoutes.some((r) => `${r.method}${r.path}${r.doc?.version}` === key)) {
@@ -121,19 +174,7 @@ export function load(): ConfiguredRoute[] {
             version,
             security: security === 'bearer' ? [{ Bearer: [] }] : security,
             response
-          } as {
-            summary: string
-            description: string
-            deprecated: boolean
-            tags: string[]
-            version: string
-            security: any
-            response: any
-            querystring: any | undefined
-            params: any | undefined
-            body: any | undefined
-            consumes: any | undefined
-          }
+          } as any
 
           if (query) doc.querystring = query
           if (params) doc.params = params
@@ -152,67 +193,26 @@ export function load(): ConfiguredRoute[] {
             base,
             file: path.join(base, defaultConfig.controller || 'controller', handlerParts[0]),
             func: handlerParts[1],
-            doc: doc // swagger & schema validation
+            doc: doc
           })
         }
       })
-    })
-  })
+    }
+  }
 
   log.d && log.debug(`Routes loaded: ${validRoutes.length}`)
   return validRoutes
 }
 
-async function tryToLoadFile(fileName: string) {
-  return new Promise((resolve, reject) => {
-    try {
-      const required = fileName ? require(fileName) : null
-      resolve(required)
-    } catch (err) {
-      reject(err)
-    }
-  })
-}
-
-async function loadMiddleware(base: string, middleware: string = '') {
-  const key = 'global.'
-  const isGlobal = middleware.indexOf(key) > -1
-  let required: any = null
-
-  if (isGlobal) {
-    const name = middleware.substring(key.length)
-    required = await tryToLoadFile(path.resolve(process.cwd() + '/src/middleware/' + name)).catch(async () => {
-      return await tryToLoadFile(path.resolve(__dirname + '/../middleware/' + name))
-    })
-  } else {
-    required = await tryToLoadFile(path.resolve(base + '/middleware/' + middleware))
-  }
-
-  if (!required) {
-    log.error(`Middleware ${middleware} not loaded`)
-    throw new Error(`Middleware ${middleware} not loaded`)
+async function applyRoutes(server: any, routes: ConfiguredRoute[]): Promise<void> {
+  if (!routes || routes.length === 0) {
+    log.w && log.warn('No routes to apply to server')
+    return
   }
-  return required
-}
-
-async function loadMiddlewares(base: string, middlewares: string[] = []) {
-  const midds = {}
-  await Promise.all(
-    middlewares.map(async (m) => {
-      const middleware = await loadMiddleware(base, m)
-      Object.keys(middleware).map((name) => (midds[name] = [...(midds[name] || []), middleware[name]]))
-    })
-  )
-  // log.debug(base + ' middleware ' + middlewares.length + ' -> ' + Object.keys(midds))
-  return midds
-}
-
-// preParsing, preValidation, preHandler, preSerialization, ..
 
-export function apply(server: any, routes: ConfiguredRoute[]): void {
   log.t && log.trace(`Apply ${routes.length} routes to server with pid ${process.pid}`)
 
-  routes.forEach(async (route) => {
+  for (const route of routes) {
     if (route?.enable) {
       const { handler, method, path, middlewares, roles, rawBody, rateLimit, base, file, func, doc } = route
 
@@ -231,7 +231,20 @@ export function apply(server: any, routes: ConfiguredRoute[]): void {
         },
         handler: async function (req: FastifyRequest, reply: FastifyReply) {
           try {
-            const module = await import(file)
+            // Import dinamico del controller
+            // Dobbiamo assicurarci che 'file' abbia l'estensione corretta o che il resolver la trovi
+            // In ESM strict, meglio provare ad aggiungere .js se manca, o lasciare che Node risolva se è un path assoluto
+            let module
+            try {
+              module = await import(file + '.js')
+            } catch {
+              try {
+                module = await import(file + '.ts')
+              } catch {
+                module = await import(file)
+              }
+            }
+
             return await module[func](req, reply)
           } catch (err) {
             log.e && log.error(`Cannot find ${file} or method ${func}: ${err}`)
@@ -240,5 +253,10 @@ export function apply(server: any, routes: ConfiguredRoute[]): void {
         }
       })
     }
-  })
+  }
+}
+
+export async function apply(server: any): Promise<void> {
+  const routes = await load()
+  return await applyRoutes(server, routes)
 }

package/lib/loader/schedules.ts

@@ -1,10 +1,10 @@
 import _ from 'lodash'
-import { JobSchedule } from '../../types/global'
-import { normalizePatterns } from '../util/path'
+import type { JobSchedule } from '../../types/global.js'
+import { normalizePatterns } from '../util/path.js'
 import { CronJob, SimpleIntervalJob, Task, AsyncTask } from 'toad-scheduler'
-
-const glob = require('glob')
-const path = require('path')
+import { globSync } from 'glob'
+import path from 'path'
+import require from '../util/require.js'
 
 export function load(): any[] {
   const patterns = normalizePatterns(['..', 'schedules', '*.job.{ts,js}'], ['src', 'schedules', '*.job.{ts,js}'])
@@ -33,7 +33,7 @@ export function load(): any[] {
 
   patterns.forEach((pattern) => {
     log.t && log.trace('Looking for ' + pattern)
-    glob.sync(pattern).forEach((f: string) => {
+    globSync(pattern, { windowsPathsNoEscape: true }).forEach((f: string) => {
       log.t && log.trace(`* Add job schedule from ${f}`)
 
       const jobName = path.basename(f, path.extname(f))