miolo 3.0.0-beta.21 → 3.0.0-beta.210

package/src/config/env.mjs

@@ -1,33 +1,51 @@
-import { config } from '@dotenvx/dotenvx'
-import path from 'node:path'
-import { intre_locale_init } from 'intre'
-import { getAppNameFromPkg, findClosestPackageJson } from './util.mjs'
-
-function _get_miolo_config_path(proyEnvPath) {
-  const appName = getAppNameFromPkg(proyEnvPath)
-
-  const mioloEnv = appName=='miolo-demo'
-    ? '../miolo/src/config/.env'
-    : 'node_modules/miolo/src/config/.env'
-
-  return path.join(proyEnvPath, mioloEnv)
+import { existsSync } from "node:fs"
+import path from "node:path"
+import { config } from "@dotenvx/dotenvx"
+import { intre_locale_init } from "intre"
+import { findClosestPackageJson, getInfoFromPkg } from "./util.mjs"
+
+function _get_miolo_config_path(proyEnvPath, appName) {
+  const mioloEnv =
+    appName === "miolo-demo" || appName === "miolo-sample"
+      ? "../miolo/src/config/.env"
+      : "node_modules/miolo/src/config/.env"
+
+  const mioloPath = path.join(proyEnvPath, mioloEnv)
+  if (existsSync(mioloPath)) {
+    return mioloPath
+  }
+  return null
 }
 
+function _get_miolo_config_path_on_build(proyEnvPath, srvDest) {
+  const mioloPath = path.join(proyEnvPath, srvDest, ".env")
+  if (existsSync(mioloPath)) {
+    return mioloPath
+  }
+  return null
+}
 
-export function init_env_config(production= true) {
-  process.env.NODE_ENV = production !== false ? 'production' : 'development'
-  intre_locale_init(process.env.MIOLO_INTRE_LOCALE)  
+export function init_env_config() {
+  intre_locale_init(process.env.MIOLO_INTRE_LOCALE)
 
   const proyEnvPath = findClosestPackageJson(process.cwd())
-  const debug = process.env.DOTENVX_DEBUG === 'true'
+  const [appName, srvDest] = getInfoFromPkg(proyEnvPath)
+  const debug = process.env.DOTENVX_DEBUG === "true"
 
   // miolo defaults
-  const libEnvPath = _get_miolo_config_path(proyEnvPath)
-  config({ path: libEnvPath, debug })
+  const libEnvPath = _get_miolo_config_path(proyEnvPath, appName)
+  if (libEnvPath) {
+    config({ path: libEnvPath, debug })
+  }
+
+  // Maybe miolo defs are on proyect's build folder
+  const buildEnvPath = _get_miolo_config_path_on_build(proyEnvPath, srvDest)
+  if (buildEnvPath) {
+    config({ path: buildEnvPath, debug })
+  }
 
-  // proyect config
-  
+  // proyect root config
   if (proyEnvPath) {
-    config({ path: path.join(proyEnvPath, '.env'), override: true, debug })
+    config({ path: path.join(proyEnvPath, ".env"), override: true, debug })
   }
 }

package/src/config/index.mjs

@@ -1,23 +1,7 @@
-import merge from 'deepmerge'
-import { init_env_config } from './env.mjs'
-import make_config_defaults from './defaults.mjs'
-
-function _get_auth_type(config) {
-  if (config?.auth?.basic) {
-    return 'basic'
-  }
-
-  if (config?.auth?.credentials) {
-    return 'credentials'
-  }
-
-  if (config?.auth?.custom) {
-    return 'custom'
-  }
-
-  return 'guest'
-}
-
+import merge from "deepmerge"
+import { isPlainObject } from "is-plain-object"
+import make_config_defaults from "./defaults.mjs"
+import { init_env_config } from "./env.mjs"
 
 export function init_config(makeConfig) {
   // Init environment vars
@@ -26,11 +10,22 @@ export function init_config(makeConfig) {
   // delay import of defaults, so env vars can be there
   const base_config = make_config_defaults()
   const custom_config = makeConfig()
-  const all_config= merge(base_config, custom_config)
-  
+
+  // isMergeableObject: objects like Joi schemas should be copied not merged
+  const all_config = merge(base_config, custom_config, { isMergeableObject: isPlainObject })
+
   // Some addendum
-  all_config.auth_type = _get_auth_type(all_config)
-  all_config.use_catcher = all_config?.http?.catcher_url ? true : false
+  all_config.use_catcher = all_config?.http?.catcher_url !== undefined
+
+  for (const auth_type of ["guest", "basic", "passport"]) {
+    if (all_config.auth?.[auth_type] === undefined) {
+      all_config.auth[auth_type] = {
+        enabled: false
+      }
+    } else if (all_config.auth[auth_type]?.enabled === undefined) {
+      all_config.auth[auth_type].enabled = true
+    }
+  }
 
   return all_config
 }

package/src/config/util.mjs

@@ -1,20 +1,36 @@
-import {readFileSync, existsSync} from 'node:fs'
-import path from 'node:path'
+import { existsSync, readFileSync } from "node:fs"
+import path from "node:path"
 
-export function getAppNameFromPkg(pkgPath) {
+export function getInfoFromPkg(pkgPath) {
   try {
-    const packageJsonPath = path.join(pkgPath, 'package.json')
-    const content = readFileSync(packageJsonPath, 'utf8')
+    const packageJsonPath = path.join(pkgPath, "package.json")
+    const content = readFileSync(packageJsonPath, "utf8")
     const packageData = JSON.parse(content)
-    return packageData.name
+    const appName = packageData.name
+
+    let srvDest = "./build/server"
+    try {
+      const start = packageData.scripts.start
+      if (start) {
+        const regex = /^node\s+(.*?)\/run\.mjs(?:$|\s)/
+        const match = start.match(regex)
+        if (match) {
+          srvDest = match[1]
+        }
+      }
+    } catch (err) {
+      console.error("[miolo] Error reading <start> package.json:", err)
+    }
+
+    return [appName, srvDest]
   } catch (error) {
-    console.error('[miolo] Error reading package.json:', error)
-    return 'miolo'
+    console.error("[miolo] Error reading <name> package.json:", error)
+    return ["miolo", "./build/server"]
   }
 }
 
 export function findClosestPackageJson(dir) {
-  if (existsSync(path.join(dir, 'package.json'))) {
+  if (existsSync(path.join(dir, "package.json"))) {
     return dir
   }
   const parentDir = path.dirname(dir)
@@ -23,4 +39,3 @@ export function findClosestPackageJson(dir) {
   }
   return findClosestPackageJson(parentDir)
 }
-

package/src/db-conn.mjs

@@ -0,0 +1,34 @@
+import { dropConnections, getConnection } from "calustra"
+import { init_config } from "./config/index.mjs"
+import { init_logger } from "./engines/logger/index.mjs"
+import { miolo_cacher_options_for_calustra } from "./middleware/context/cache/options.mjs"
+
+export async function miolo_db_connection_pg(makeConfig, options = undefined) {
+  const config = init_config(makeConfig)
+
+  // init logger first
+  const logger = init_logger(config.log, undefined, config?.name)
+
+  if (config.db.config.dialect === "sqlite") {
+    logger.error(`[miolo] SQLite is not supported yet`)
+    return undefined
+  }
+
+  // parse db options
+  const dbOptions = {
+    ...config.db.options,
+    ...(options || {}),
+    log: logger,
+    cache: miolo_cacher_options_for_calustra(config, logger)
+  }
+
+  const conn = await getConnection(config.db.config, dbOptions)
+
+  conn.get_model = conn.getModel
+
+  return conn
+}
+
+export async function miolo_db_drop_connections() {
+  await dropConnections()
+}

package/src/engines/cron/emails.mjs

@@ -1,10 +1,15 @@
 export function sys_email_queue_config() {
   return {
-    name: 'Emailer',
-    cronTime: '* * * * *',
+    name: "Emailer",
+    cronTime: "* * * * *",
     onTick: async (miolo, _onCompleted) => {
-      await miolo.emailer.queue_send_emails(miolo.logger)
+      const n = await miolo.emailer.queue_send_emails(miolo.logger)
+      if (n === -1) {
+        miolo.logger.error(`[emailer] Error sending emails`)
+      } else {
+        miolo.logger.verbose(`[emailer] Sent ${n} emails`)
+      }
     },
-    start: true   
+    start: true
   }
-}
+}

package/src/engines/cron/index.mjs

@@ -1,48 +1,41 @@
-import {
-  init_cron_job
-} from './init.mjs'
-import {
-  sys_check_config
-} from './syscheck.mjs'
-import {
-  ipsum_config
-} from './ipsum.mjs'
-import { cyan, green_bold, yellow_bold } from 'tinguir'
-import { sys_email_queue_config } from './emails.mjs'
-
+import { cyan, green_bold, yellow_bold } from "tinguir"
+import { sys_email_queue_config } from "./emails.mjs"
+import { init_cron_job } from "./init.mjs"
+import { ipsum_config } from "./ipsum.mjs"
+import { sys_check_config } from "./syscheck.mjs"
 
 export function init_cron(app, custom) {
   const miolo = app.context.miolo
-  const logger= miolo.logger
-  
-  const jobConfigs= [
+  const logger = miolo.logger
+
+  const jobConfigs = [
     sys_check_config(),
     ipsum_config(),
     sys_email_queue_config(),
-    ...custom || []
+    ...(custom || [])
   ]
-  
+
   // Keep trace of conr jobs to be accessible later
-  const jobInfos= [
-    // {name: 'name', job: <job>, isActive: true/false} 
+  const jobInfos = [
+    // {name: 'name', job: <job>, isActive: true/false}
   ]
-  
-  jobConfigs.map(config => {
+
+  jobConfigs.forEach((config) => {
     const name = config.name
-    const job= init_cron_job(miolo, config)
+    const job = init_cron_job(miolo, config)
     jobInfos.push({
-      name, 
+      name,
       job,
       isActive: false
-    })  
+    })
   })
-  
+
   const _find_job_by_idx_or_name = (idxOrName) => {
     let jobInfo
-    if (typeof idxOrName == 'number') {
-      jobInfo= jobInfos[idxOrName]
+    if (typeof idxOrName === "number") {
+      jobInfo = jobInfos[idxOrName]
     } else {
-      jobInfo= jobInfos.filter(j => j.name == idxOrName)[0]
+      jobInfo = jobInfos.filter((j) => j.name === idxOrName)[0]
     }
 
     if (!jobInfo) {
@@ -55,15 +48,15 @@ export function init_cron(app, custom) {
   const _start_job = async (jobInfo) => {
     try {
       await jobInfo.job.start()
-      jobInfo.isActive= true
-      logger.debug(`[cron][Job ${cyan(jobInfo.name)}] ${green_bold('started!')}`)
+      jobInfo.isActive = true
+      logger.debug(`[cron][Job ${cyan(jobInfo.name)}] ${green_bold("started!")}`)
       return 1
-    } catch(e) {
+    } catch (e) {
       logger.error(`[cron][Job ${cyan(jobInfo.name)}] Error starting it`)
       logger.error(e)
       return 0
     }
-  }  
+  }
 
   const _start_job_by_idx_or_name = async (idxOrName) => {
     const jobInfo = _find_job_by_idx_or_name(idxOrName)
@@ -71,15 +64,16 @@ export function init_cron(app, custom) {
       const done = await _start_job(jobInfo)
       return [done, jobInfo.name]
     }
-    return [0, '']
+    return [0, ""]
   }
 
   const _start_all_jobs = async () => {
     try {
-      let started= [], errors= []
+      const started = [],
+        errors = []
       for (const jobInfo of jobInfos) {
-        const done= await _start_job(jobInfo)
-        if (done == 1) {
+        const done = await _start_job(jobInfo)
+        if (done === 1) {
           started.push(jobInfo.name)
         } else {
           errors.push(jobInfo.name)
@@ -91,19 +85,18 @@ export function init_cron(app, custom) {
       if (errors.length > 0) {
         logger.warn(`[cron] Could not start ${errors.length} jobs: ${errors}`)
       }
-    } catch(error) {
+    } catch (error) {
       logger.error(`[cron] start() error: ${error}`)
     }
-  
   }
 
   const _stop_job = async (jobInfo) => {
     try {
       await jobInfo.job.stop()
-      jobInfo.isActive= false
-      logger.debug(`[cron][Job ${cyan(jobInfo.name)}] ${yellow_bold('stopped!')}`) 
+      jobInfo.isActive = false
+      logger.debug(`[cron][Job ${cyan(jobInfo.name)}] ${yellow_bold("stopped!")}`)
       return 1
-    } catch(e) {
+    } catch (e) {
       logger.error(`[cron][Job ${cyan(jobInfo.name)}] Error stopping it`)
       logger.error(e)
       return 0
@@ -116,15 +109,16 @@ export function init_cron(app, custom) {
       const done = await _stop_job(jobInfo)
       return [done, jobInfo.name]
     }
-    return [0, '']
+    return [0, ""]
   }
 
   const _stop_all_jobs = async () => {
     try {
-      let stopped= [], errors= []
+      const stopped = [],
+        errors = []
       for (const jobInfo of jobInfos) {
-        const done= await _stop_job(jobInfo)
-        if (done == 1) {
+        const done = await _stop_job(jobInfo)
+        if (done === 1) {
           stopped.push(jobInfo.name)
         } else {
           errors.push(jobInfo.name)
@@ -136,17 +130,17 @@ export function init_cron(app, custom) {
       if (errors.length > 0) {
         logger.warn(`[cron] Could not stop ${errors.length} jobs: ${errors}`)
       }
-    } catch(error) {
+    } catch (error) {
       logger.error(`[cron] stop() error: ${error}`)
     }
   }
 
-  app.cron= {
-    jobs:      jobInfos,
+  app.cron = {
+    jobs: jobInfos,
     start_one: _start_job_by_idx_or_name,
-    start:     _start_all_jobs,
-    stop_one : _stop_job_by_idx_or_name,
-    stop:      _stop_all_jobs
+    start: _start_all_jobs,
+    stop_one: _stop_job_by_idx_or_name,
+    stop: _stop_all_jobs
   }
 
   return app

package/src/engines/cron/init.mjs

@@ -1,27 +1,26 @@
-
-import {CronJob} from 'cron'
-import { cyan, green_bold } from 'tinguir'
+import { CronJob } from "cron"
+import { cyan, green_bold } from "tinguir"
 
 export function init_cron_job(miolo, config) {
-  const logger= miolo.logger
+  const logger = miolo.logger
   const onTickName = config?.onTick?.name
-    ? config.onTick.name != 'onTick'
+    ? config.onTick.name !== "onTick"
       ? config.onTick.name
-      : 'custom'
-      : 'custom'
+      : "custom"
+    : "custom"
 
   const name = config?.name || onTickName
 
-  const job= new CronJob(
+  const job = new CronJob(
     // cronTime
-    config?.cronTime || '*/5 * * * *',
-    
+    config?.cronTime || "*/5 * * * *",
+
     // onTick(miolo, onComplete)
     async (onComplete) => {
       try {
-        logger.silly(`[cron][Custom Job ${cyan(name)}] ${green_bold('ticks!')}`)
+        logger.silly(`[cron][Custom Job ${cyan(name)}] ${green_bold("ticks!")}`)
         await config.onTick(miolo, onComplete)
-      } catch(e) {
+      } catch (e) {
         logger.error(`[cron][Custom Job ${cyan(name)}] Error at onTick()`)
         logger.error(e)
       }
@@ -29,11 +28,11 @@ export function init_cron_job(miolo, config) {
 
     // onComplete(miolo)
     async () => {
-      logger.silly(`[cron][Custom Job ${cyan(name)}] ${green_bold('completed!')}`)
+      logger.silly(`[cron][Custom Job ${cyan(name)}] ${green_bold("completed!")}`)
       if (config?.onComplete) {
         try {
           await config.onComplete(miolo)
-        } catch(e) {
+        } catch (e) {
           logger.error(`[cron][Custom Job ${cyan(name)}] Error at onComplete()`)
           logger.error(e)
         }
@@ -43,11 +42,11 @@ export function init_cron_job(miolo, config) {
     // Do not start yet
     false,
 
-    config?.timezone || 'Europe/Madrid',
+    config?.timezone || "Europe/Madrid"
     // config?.context || null,
     // config?.runOnInit || null,
     // config?.utcOffset || null,
     // config?.unrefTimeout || null,
-  )    
+  )
   return job
-}
+}