miolo 3.0.0-beta.13 → 3.0.0-beta.130

package/bin/{dev.mjs → dev/dev.mjs}

@@ -3,6 +3,7 @@ import path from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { fork } from 'node:child_process'
 
+
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
@@ -19,9 +20,19 @@ function _isProcessRunning(pid) {
   }
 }
 
-async function startDevServerProcess({ appName }) {
+async function startDevServerProcess({ appName, debug }) {  
   const serverPath = path.join(__dirname, './dev_start.mjs')
-  serverProcess = fork(serverPath)
+
+  const execArgv = [];
+  if (debug===true) {
+    const newDebugPort = process.debugPort + 1;
+    console.log(`[${appName}][dev] Debugging enabled. Attaching debugger to child process on port ${newDebugPort}`);
+    execArgv.push(`--inspect=${newDebugPort}`);
+  }
+
+  serverProcess = fork(serverPath, [], {
+    execArgv: execArgv
+  }) 
 
   console.log(`[${appName}][dev] Server process started with pid ${serverProcess.pid} from ${process.pid}`)
 
@@ -59,13 +70,16 @@ async function startDevServerProcess({ appName }) {
         }, 2000)
       }
 
-      startDevServerProcess({ appName }) // Inicia un nuevo proceso
+      startDevServerProcess({ appName, debug }) // Inicia un nuevo proceso
     }
   })
 }
 
 
-export default async function(appName) {
+export default async function(appName= undefined, debug= false) {
+  // Based on command line params or .env
+  appName = appName || process.env.MIOLO_NAME
+  
   console.log(`[${appName}][dev] Running DEV server`)
-  await startDevServerProcess({ appName })
+  await startDevServerProcess({ appName, debug })
 }

package/bin/{dev_start.mjs → dev/dev_start.mjs}

@@ -1,8 +1,9 @@
 import path from 'node:path'
-import {miolo_dev} from '../src/server-dev.mjs'
+import {miolo_dev} from '../../src/server-dev.mjs'
 
 async function _miolo_dev_start_server() {
-  const config = await import(path.join(process.cwd(), process.env.MIOLO_CONFIG))
+  process.env.NODE_ENV = 'development'
+  const config = await import(path.join(process.cwd(), process.env.MIOLO_DEV_CONFIG_ENTRY))
   const app = await miolo_dev(config.default)
   await app.start()
   return app  

package/bin/index.mjs

@@ -1,69 +1,83 @@
 #!/usr/bin/env node
+import path from 'node:path'
 import yargs from 'yargs-parser'
-import { intre_locale_init } from 'intre'
-import { init_env_config } from './env.mjs'
+import { init_env_config } from '../src/config/env.mjs'
 
 
 async function main() {
   const args = yargs(process.argv.slice(2))
   const command = args._[0]
 
+  // Init env
+  process.env.NODE_ENV = 'production'
+  init_env_config()
+
+  // Init vars
+  const appName = args['app-name'] || process.env.MIOLO_NAME
+  const serverExt = 'node.bundle.mjs'
+
   try {
-    init_env_config()
-    const appName = process.env.MIOLO_NAME
-    intre_locale_init(process.env.MIOLO_INTRE_LOCALE)
 
     switch (command) {
       case 'dev':
         process.env.NODE_ENV = 'development'
-        const devHandler = (await import ('./dev.mjs')).default
+        const devHandler = (await import ('./dev/dev.mjs')).default
         await devHandler(appName)
         break
+      
+      case 'deb':
+        process.env.NODE_ENV = 'development'
+        const debHandler = (await import ('./dev/dev.mjs')).default
+        await debHandler(appName, true)
+        break
 
       case 'build-client':
-        process.env.NODE_ENV = 'production'
-        const buildClientHandler = (await import ('./build-client.mjs')).default
-        const clientEntry = args.entry || process.env.MIOLO_BUILD_CLIENT_ENTRY
+        const entry = args.entry || process.env.MIOLO_BUILD_CLIENT_ENTRY
         const htmlFile = args['html-file'] || process.env.MIOLO_BUILD_HTML_FILE
-        const clientDest = args.dest || process.env.MIOLO_BUILD_CLIENT_DEST 
-        await buildClientHandler(appName, /*entry*/ clientEntry, htmlFile, /*dest*/ clientDest)
+        const cliDest = args.dest || process.env.MIOLO_BUILD_CLIENT_DEST 
+
+        const buildClientHandler = (await import ('./prod-build/build-client.mjs')).default
+        await buildClientHandler(appName, entry, htmlFile, cliDest)
         break
 
       case 'build-server':
-        process.env.NODE_ENV = 'production'
-        const buildServerHandler = (await import ('./build-server.mjs')).default
-        const ssrEntry = args['ssr-entry'] || process.env.MIOLO_BUILD_SERVER_SSR_ENTRY
-        const ssrDest = args['ssr-dest'] || process.env.MIOLO_BUILD_SERVER_DEST
-        const serverDest = args.dest || process.env.MIOLO_BUILD_SERVER_DEST
-        await buildServerHandler(appName, ssrEntry, ssrDest,  /*dest*/ serverDest)
+        // Based on command line params or .env
+        const srvEntry= args['entry'] || process.env.MIOLO_BUILD_SERVER_ENTRY
+        const ssrEntry= args['ssr-entry'] || process.env.MIOLO_BUILD_SERVER_SSR_ENTRY
+        const ssrDest= args['ssr-dest'] || process.env.MIOLO_BUILD_SERVER_DEST
+        const srvDest= args.dest || process.env.MIOLO_BUILD_SERVER_DEST
+      
+        const buildServerHandler = (await import ('./prod-build/build-server.mjs')).default
+        await buildServerHandler(appName, ssrEntry, ssrDest, srvEntry, srvDest)
         break
 
       case 'start':
-        process.env.NODE_ENV = 'production'
-        const startHandler = (await import ('./start.mjs')).default
-        const startDest = args.dest || process.env.MIOLO_BUILD_SERVER_DEST
-        await startHandler(appName, /*dest*/ startDest)
+        
+        const destFile =  args.dest || path.join(process.cwd(), `${process.env.MIOLO_BUILD_SERVER_DEST}/${appName}.${serverExt}`)
+
+        const startHandler = (await import ('./prod-run/start.mjs')).default
+        await startHandler(appName, destFile)
         break
 
       case 'stop':
-        process.env.NODE_ENV = 'production'
-        const stopHandler = (await import ('./stop.mjs')).default
+        const stopHandler = (await import ('./prod-run/stop.mjs')).default
         await stopHandler(appName)
         break
 
       case 'restart':
-        process.env.NODE_ENV = 'production'
-        const restartHandler = (await import ('./restart.mjs')).default
-        const restartDest = args.dest || process.env.MIOLO_BUILD_SERVER_DEST
-        await restartHandler({appName, /*dest*/ restartDest})
+        const restartDestFile =  args.dest || path.join(process.cwd(), `${process.env.MIOLO_BUILD_SERVER_DEST}/${appName}.${serverExt}`)
+
+        const restartHandler = (await import ('./prod-run/restart.mjs')).default
+        await restartHandler(appName, restartDestFile)
         break
 
-      //case 'create-bin':
-      //  process.env.NODE_ENV = 'production'
-      //  const createHandler = (await import ('./create-bin.mjs')).default
-      //  const createDest = args.dest || process.env.MIOLO_BUILD_SERVER_DEST
-      //  await createHandler(appName, /*dest*/ createDest, serverName)
-      //  break
+      case 'create-bin':
+        const dest = args.dest || process.env.MIOLO_BUILD_SERVER_DEST
+        const cbinDestFile = `./${appName}.${serverExt}`
+        
+        const createHandler = (await import ('./prod-bin/create-bin.mjs')).default
+        await createHandler(appName, dest, cbinDestFile)
+        break
 
       default:
         console.error(`[miolo] Unknown command: ${command}`)

package/bin/prod-bin/create-bin.mjs

@@ -0,0 +1,33 @@
+import {readFileSync, writeFileSync} from 'node:fs'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { copyFileSync } from '../util.mjs'
+
+const __my_filename = fileURLToPath(import.meta.url)
+const __my_dirname = path.dirname(__my_filename)
+
+export default async function(appName, dest, destFile) {
+  console.log(`[${appName}][prod][create-bin] Creating bin files...`)
+
+  const readSource = (f) => readFileSync(path.resolve(__my_dirname, '../prod-run', f), {encoding:'utf8'})
+  const writeDest = (f, content) => writeFileSync(path.join(process.cwd(), dest, f), content, {encoding:'utf8',flag:'w'})
+
+  const pidContent = readSource('./pid.mjs')
+  writeDest('pid.mjs', pidContent)
+
+  let startContent = readSource('./start.mjs')
+  startContent = startContent.replace('(appName, destFile) {', `(appName= '${appName}', destFile= '${destFile}') {`)
+  writeDest('start.mjs', startContent)
+  
+  let stopContent = readSource('./stop.mjs')
+  stopContent = stopContent.replace('(appName) {', `(appName= '${appName}') {`)
+  writeDest('stop.mjs', stopContent)
+
+  let restartContent = readSource('./restart.mjs')
+  restartContent = restartContent.replace('(appName, destFile) {', `(appName= '${appName}', destFile= '${destFile}') {`)
+  writeDest('restart.mjs', restartContent)
+  
+  copyFileSync(path.join(__my_dirname, './run.mjs'), path.join(process.cwd(), dest, 'run.mjs'))
+  copyFileSync(path.join(__my_dirname, '../../src/config/.env'), path.join(process.cwd(), dest, '.env'))
+
+}

package/bin/prod-bin/run.mjs

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+async function miolo_run() {
+  const args = process.argv.slice(2)
+  const command = args[0]
+  process.env.NODE_ENV = 'production'
+
+  try {
+    switch (command) {
+      case 'start':
+        const startHandler = (await import ('./start.mjs')).default
+        await startHandler()
+        break
+
+      case 'stop':
+        const stopHandler = (await import ('./stop.mjs')).default
+        await stopHandler()
+        break
+
+      case 'restart':
+        const restartHandler = (await import ('./restart.mjs')).default
+        await restartHandler()
+        break
+
+      default:
+        console.error(`[miolo] Unknown command: ${command}`)
+        console.log('[miolo] Available commands: start, stop, restart')
+        process.exit(1)
+    }
+  } catch (error) {
+    console.error('[miolo] Error during command execution:', error)
+    process.exit(1)
+  }
+}
+
+miolo_run()

package/bin/{build-client.mjs → prod-build/build-client.mjs}

@@ -1,9 +1,18 @@
 
+import path from 'node:path'
 import {xeiraBundle} from 'xeira'
-import { cleanFolder, copyFileSync, isFileExistingSync } from './util.mjs'
+import { nanoid } from 'nanoid'
+import { cleanFolder, copyFileSync, isFileExistingSync } from '../util.mjs'
 
 function _addCssLinkToHead(appName, htmlString, dest) {
-  const linkTag = `  <link href="${dest}/${appName}.${process.env.MIOLO_BUNDLE_SUFFIX}.css" rel="stylesheet" media="all">`
+  
+  const webDest = dest.startsWith('./') 
+    ? dest.replace('./', '/')
+    : dest.startsWith('/') 
+    ? dest
+    : `/${dest}`
+
+  const linkTag = `  <link href="${webDest}/${appName}.${process.env.MIOLO_BUILD_CLIENT_SUFFIX}.css?v=${nanoid()}" rel="stylesheet" media="all">`
   
   // Expresión regular para encontrar la etiqueta </head> de cierre.
   // Usamos un grupo de captura para mantener el contenido antes de </head>.
@@ -28,25 +37,28 @@ function _addCssLinkToHead(appName, htmlString, dest) {
 export default async function(appName, entry, htmlFile, dest) {
   console.log(`[${appName}][prod] Building client from entry ${entry}`)
 
+  // Clean dest folder
   cleanFolder(dest)
   
+  // Build client
   await xeiraBundle({
     source_index: entry,
     target: 'browser',
     bundle_folder: dest,
     bundle_name: appName,
-    bundle_extension: process.env.MIOLO_BUNDLE_SUFFIX,
+    bundle_extension: process.env.MIOLO_BUILD_CLIENT_SUFFIX,
     bundler: 'rollup',
     bundle_node_polyfill: true
   })
 
-  const destCssFile = `${dest}/${appName}.${process.env.MIOLO_BUNDLE_SUFFIX}.css`
+  // Fix css file
+  const destCssFile = `${dest}/${appName}.${process.env.MIOLO_BUILD_CLIENT_SUFFIX}.css`
   const destCssFileExists = isFileExistingSync(destCssFile)
 
   console.log(`[${appName}][prod] destCssFile ${destCssFile} exists?: ${destCssFileExists}`)
   
   console.log(`[${appName}][prod] Copying HTML file ${htmlFile} to ${dest}/index.html`)
-  copyFileSync(htmlFile, `${dest}/index.html`, (content) => {
+  copyFileSync(path.join(process.cwd(), htmlFile), path.join(process.cwd(), `${dest}/index.html`), (content) => {
     if (destCssFileExists) {
       content = _addCssLinkToHead(appName, content, dest)
     }

package/bin/{build-server.mjs → prod-build/build-server.mjs}

@@ -3,8 +3,7 @@ import path from 'node:path'
 import { readFile, writeFile} from 'node:fs/promises'
 import { build } from 'vite'
 import {xeiraBundle} from 'xeira'
-import { cleanFolder } from './util.mjs'
-
+import { cleanFolder } from '../util.mjs'
 
 
 export async function _fixProdBuild(appName, filePath) {
@@ -21,10 +20,13 @@ export async function _fixProdBuild(appName, filePath) {
   }
 }
 
-export default async function(appName, ssrEntry, ssrDest, dest) {
-  cleanFolder(dest)
-
+export default async function(appName, ssrEntry, ssrDest, srvEntry, srvDest) {
   console.log(`[${appName}][prod] Building first the SSR entry ${ssrEntry}`)
+
+  // clean dest folder
+  cleanFolder(srvDest)
+
+  // Build SSR entry
   await build({
     build: {
       outDir: path.resolve(process.cwd(), ssrDest),
@@ -35,15 +37,15 @@ export default async function(appName, ssrEntry, ssrDest, dest) {
     ssr: {
       noExternal: true
     }
-  })
+  })  
 
+  console.log(`[${appName}][prod] Building server entry for ${srvEntry}`)
 
   const serverExt = 'node.bundle.mjs'
   await xeiraBundle({
-    //source_index: 'node_modules/miolo/packages/miolo/bin/prod_start.mjs',
-    source_index: '../miolo/bin/prod_start.mjs',
+    source_index: srvEntry,
     target: 'node',
-    bundle_folder: dest,
+    bundle_folder: srvDest,
     bundle_name: appName,
     bundle_extension: serverExt,
     bundler: 'rollup',
@@ -51,6 +53,6 @@ export default async function(appName, ssrEntry, ssrDest, dest) {
   })
   
   console.log(`[${appName}][prod] Fixing server build (prod)...`)
-  const destFile =  path.join(process.cwd(), `${dest}/${appName}.${serverExt}`)
+  const destFile =  path.join(process.cwd(), `${srvDest}/${appName}.${serverExt}`)
   await _fixProdBuild(appName, destFile)
 }

package/bin/prod-run/pid.mjs

@@ -0,0 +1,13 @@
+import {writeFileSync, readFileSync} from 'node:fs'
+
+export function pidFileCreate(appName) {
+  const pidFilePath = `/tmp/${appName}.pid`
+  writeFileSync(pidFilePath, `${process.pid}`, {encoding:'utf8',flag:'w'})
+  return process.pid
+}
+
+export function pidFileRead(appName) {
+  const pidFilePath = `/tmp/${appName}.pid`
+  const pid = readFileSync(pidFilePath, {encoding:'utf8'})
+  return pid
+}

package/bin/{restart.mjs → prod-run/restart.mjs}

@@ -1,10 +1,9 @@
 import start from "./start.mjs"
 import stop from "./stop.mjs"
 
-export default async function(appName, dest) {
+export default async function restart(appName, destFile) {
   console.log(`[${appName}][prod][restart] Restarting server...`)
 
   await stop(appName)
-  await start(appName, dest)
-
-}
+  await start(appName, destFile)
+}

package/bin/prod-run/start.mjs

@@ -0,0 +1,14 @@
+import { pidFileCreate } from "./pid.mjs"
+
+export default async function start(appName, destFile) {
+  // Start server
+  console.log(`[${appName}][prod][start] Starting server from ${destFile}...`)
+
+  const srv_module = await import(destFile)  
+  const server = srv_module.default
+
+  const pid = pidFileCreate(appName)
+  console.log(`[${appName}][prod][start] Starting server. PID is ${pid}...`)
+
+  await server()  
+}

package/bin/{stop.mjs → prod-run/stop.mjs}

@@ -1,6 +1,7 @@
-import { pidFileRead } from "./util.mjs"
+import { pidFileRead } from "./pid.mjs"
 
-export default async function(appName) {
+export default async function stop(appName) {
+  // stop server by killin gprocess
   console.log(`[${appName}][prod][stop] Stopping server...`)
 
   try {
@@ -16,4 +17,4 @@ export default async function(appName) {
 
     return 0
   }
-}
+}

package/bin/util.mjs

@@ -2,40 +2,13 @@ import {readdirSync, rmSync, writeFileSync, readFileSync} from 'node:fs'
 import path from 'node:path'
 
 
-// export function getAppName() {
-//   try {
-//     const packageJsonPath = path.join(process.cwd(), 'package.json')
-//     const content = readFileSync(packageJsonPath, 'utf8')
-//     const packageData = JSON.parse(content)
-//     return packageData.name
-//   } catch (error) {
-//     console.error('[miolo] Error reading package.json:', error)
-//     return 'miolo'
-//   }
-// }
-
 export function cleanFolder(folder) {
   readdirSync(folder).forEach(file => {
     rmSync(`${folder}/${file}`, { recursive: true, force: true });
   })
 }
 
-
-export function pidFileCreate(appName) {
-  const pidFilePath = `/tmp/${appName}.pid`
-  writeFileSync(pidFilePath, `${process.pid}`, {encoding:'utf8',flag:'w'})
-  return process.pid
-}
-
-export function pidFileRead(appName) {
-  const pidFilePath = `/tmp/${appName}.pid`
-  const pid = readFileSync(pidFilePath, {encoding:'utf8'})
-  return pid
-}
-
-export function copyFileSync(src, dest, modifier= undefined) {
-  const srcPath = path.join(process.cwd(), src)
-  const destPath = path.join(process.cwd(), dest)
+export function copyFileSync(srcPath, destPath, modifier= undefined) {
   try {
     let content = readFileSync(srcPath, 'utf8')
     if (modifier) {
@@ -56,4 +29,4 @@ export function isFileExistingSync(filePath) {
     console.error(`[miolo] Error checking if file exists: ${filePath}`, error)
     return false
   }
-} 
+} 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miolo",
-  "version": "3.0.0-beta.13",
+  "version": "3.0.0-beta.130",
   "description": "all-in-one koa-based server",
   "author": "Donato Lorenzo <donato@afialapis.com>",
   "contributors": [
@@ -20,43 +20,41 @@
   },
   "type": "module",
   "exports": {
-    "./server": {
-      "node": "./src/index.mjs", 
-      "import": "./src/index.mjs",
-      "default": "./dist/miolo.node.mjs"
-    },
-    "./server-dev": {
-      "default": "./src/server-dev.mjs"
-    }
+    "node": "./src/index.mjs",
+    "import": "./src/index.mjs",
+    "default": "./dist/miolo.node.mjs"
   },
   "files": [
     "bin",
     "src"
   ],
   "scripts": {
+    "lint": "npx xeira lint ./src",
     "reset": "rm -fr package-lock.json npm-lock.yaml dist/* && npm i",
     "clean": "rm -fr ./dist/*",
     "bundle": "npx xeira bundle --target=node --source_index=./src/index.mjs --bundle_folder=./dist --bundle_name=miolo --bundle_extension=node.mjs",
-    "dist": "npm run clean && npm run bundle",
-    "test": "npx xeira test --files=./test/index.mjs"
+    "dist": "npm run clean && npm run bundle"
   },
   "dependencies": {
     "@babel/plugin-proposal-decorators": "^7.28.0",
-    "@dotenvx/dotenvx": "^1.47.6",
+    "@dotenvx/dotenvx": "^1.51.1",
     "@koa/bodyparser": "^6.0.0",
     "@koa/cors": "^5.0.0",
-    "@koa/router": "^13.1.1",
-    "@maxmind/geoip2-node": "^6.1.0",
-    "@vitejs/plugin-react": "^4.6.0",
-    "cacheiro": "^0.4.4",
-    "calustra": "^0.15.3",
-    "cron": "^4.3.2",
+    "@koa/router": "^14.0.0",
+    "@maxmind/geoip2-node": "^6.2.0",
+    "@tailwindcss/vite": "^4.1.17",
+    "@vitejs/plugin-react": "^5.1.0",
+    "cacheiro": "^0.5.0-beta.4",
+    "calustra": "^1.0.0-beta.3",
+    "cron": "^4.3.4",
     "deepmerge": "^4.3.1",
     "diskspace": "^2.0.0",
     "http-terminator": "^3.2.0",
-    "intre": "^2.6.1",
+    "intre": "^3.0.0-beta.2",
+    "is-plain-object": "^5.0.0",
+    "joi": "^18.0.1",
     "jwt-simple": "^0.5.6",
-    "koa": "^3.0.0",
+    "koa": "^3.1.1",
     "koa-compress": "^5.1.1",
     "koa-connect": "^2.1.0",
     "koa-favicon": "^2.1.0",
@@ -67,20 +65,21 @@
     "koa-session": "^7.0.2",
     "koa-socket-2": "^2.0.0",
     "koa-static": "^5.0.0",
-    "nodemailer": "^7.0.5",
+    "nanoid": "^5.1.6",
+    "nodemailer": "^7.0.10",
     "passport-local": "^1.0.0",
     "socket.io": "^4.8.1",
     "socket.io-client": "^4.8.1",
+    "statuses": "^2.0.2",
+    "tailwindcss": "^4.1.17",
     "tinguir": "^0.0.7",
-    "vite": "^7.0.4",
-    "winston": "^3.17.0",
+    "vite": "^7.2.2",
+    "winston": "^3.18.3",
     "winston-daily-rotate-file": "^5.0.0",
     "yargs-parser": "^22.0.0"
   },
   "devDependencies": {
-    "esbuild": "^0.25.6",
-    "node-fetch": "^3.3.2",
-    "xeira": "^1.2.3"
+    "xeira": "^2.0.0-beta.8"
   },
   "eslintConfig": {
     "extends": [

package/{bin → src/config}/.env

@@ -2,20 +2,20 @@
 # General
 #
 MIOLO_NAME=miolo
-MIOLO_CONFIG=./src/server/config.mjs
 MIOLO_INTRE_LOCALE=es
 
 #
 # HTTP
 #
 MIOLO_PORT=8001
+MIOLO_DEV_PORT=7001
 MIOLO_HOSTNAME=localhost
-
+MIOLO_HOSTNAME_DOCKER=0.0.0.0
 MIOLO_HTTP_CORS=simple # true | false | simple. For {options}, use JS
-MIOLO_HTTP_PROXY=true # true | false. For {options}, use JS
+MIOLO_HTTP_PROXY=false # true | false. For {options}, use JS
 
 MIOLO_RATELIMIT_MAX=1000
-MIOLO_RATELIMIT_DURATION=60 * 1000
+MIOLO_RATELIMIT_DURATION=60000
 #MIOLO_RATELIMIT_WHITELIST_IPS=
 #MIOLO_RATELIMIT_BLACKLIST_IPS=
 MIOLO_REQUEST_LAZY=1 # seconds to consider lazy a request
@@ -28,16 +28,20 @@ MIOLO_GEOIP_LOCAL_IPS=127.0.0.1
 #
 # Session
 #
+MIOLO_SESSION_KEY='miolo.sess'
 MIOLO_SESSION_SALT=11111111-2222-3333-4444-555555555555
 MIOLO_SESSION_SECRET=secret
 MIOLO_SESSION_MAX_AGE=864000000
 MIOLO_SESSION_SECURE=true
+MIOLO_SESSION_RENEW=false
+MIOLO_SESSION_SAME_SITE=lax # lax | strict
 
 #
 # Database
 #
 MIOLO_DB_DIALECT=postgres
 MIOLO_DB_HOST=localhost
+MIOLO_DB_DOCKER_HOST=postgres
 MIOLO_DB_PORT=5432
 MIOLO_DB_DATABASE=my_database
 MIOLO_DB_USER=my_user
@@ -58,7 +62,7 @@ MIOLO_LOG_LEVEL=verbose
 MIOLO_LOG_CONSOLE_ENABLED=true
 #MIOLO_LOG_CONSOLE_LEVEL=verbose
 
-MIOLO_LOG_FILE_ENABLED=true
+MIOLO_LOG_FILE_ENABLED=false
 #MIOLO_LOG_FILE_LEVEL=verbose
 
 MIOLO_LOG_FILE_PATH=/var/log/afialapis/%MIOLO%.log
@@ -84,6 +88,11 @@ MIOLO_MAILER_SMTP_PASS=****
 #
 # Cache
 #
+MIOLO_REDIS_HOSTNAME=localhost
+MIOLO_REDIS_HOSTNAME_DOCKER=redis
+MIOLO_REDIS_PORT=6379
+
+MIOLO_CACHE_TYPE=combined
 MIOLO_CACHE_VERSION=1
 MIOLO_CACHE_CALUSTRA_VERSION=1
 MIOLO_CACHE_CALUSTRA_TTL=86400000
@@ -101,8 +110,10 @@ MIOLO_DOTENVX_DEBUG=false
 MIOLO_BUILD_HTML_FILE=./src/cli/index.html
 MIOLO_BUILD_CLIENT_ENTRY=./src/cli/entry-cli.jsx
 MIOLO_BUILD_CLIENT_DEST=./dist/cli
+MIOLO_BUILD_CLIENT_SUFFIX=iife.bundle.min
 MIOLO_BUILD_SERVER_SSR_ENTRY=./src/server/ssr/entry-server.jsx
+MIOLO_BUILD_SERVER_ENTRY=./src/server/server.mjs
 MIOLO_BUILD_SERVER_DEST=./dist/server
-MIOLO_BUNDLE_SUFFIX=iife.bundle.min
+MIOLO_DEV_CONFIG_ENTRY=./src/server/config.mjs
 MIOLO_DEV_WATCH_ENABLED=true
 MIOLO_DEV_WATCH_DIRS=./src/server