miolo 3.0.0-beta.2 → 3.0.0-beta.20

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,7 +20,7 @@ function _isProcessRunning(pid) {
   }
 }
 
-async function startDevServerProcess({ appName }) {
+async function startDevServerProcess({ appName }) {  
   const serverPath = path.join(__dirname, './dev_start.mjs')
   serverProcess = fork(serverPath)
 
@@ -65,7 +66,12 @@ async function startDevServerProcess({ appName }) {
 }
 
 
-export default async function(appName) {
+export default async function(appName= undefined) {
+
+
+  // Based on command line params or .env
+  appName = appName || process.env.MIOLO_NAME
+  
   console.log(`[${appName}][dev] Running DEV server`)
   await startDevServerProcess({ appName })
 }

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

@@ -1,8 +1,8 @@
 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))
+  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,66 +1,75 @@
 #!/usr/bin/env node
+import path from 'node:path'
 import yargs from 'yargs-parser'
-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
+  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
-    const serverName = args['server-name'] || 'miolo_server'
 
     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 '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, serverName)
+        
+        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, serverName})
+        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)
+        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:

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

@@ -0,0 +1,31 @@
+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'))
+}

package/bin/prod-bin/run.mjs

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+async function miolo_run() {
+  const args = process.argv.slice(2)
+  const command = args[0]
+
+  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,17 @@
 
+import path from 'node:path'
 import {xeiraBundle} from 'xeira'
-import { cleanFolder, copyFileSync, isFileExistingSync } from './util.mjs'
+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" 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 +36,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, serverName) {
+export default async function restart(appName, destFile) {
   console.log(`[${appName}][prod][restart] Restarting server...`)
 
   await stop(appName)
-  await start(appName, dest, serverName)
-
-}
+  await start(appName, destFile)
+}

package/bin/prod-run/start.mjs

@@ -0,0 +1,15 @@
+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.2",
+  "version": "3.0.0-beta.20",
   "description": "all-in-one koa-based server",
   "author": "Donato Lorenzo <donato@afialapis.com>",
   "contributors": [
@@ -20,14 +20,9 @@
   },
   "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",
@@ -38,8 +33,7 @@
     "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",
-    "publish": "npm publish"
+    "test": "npx xeira test --files=./test/index.mjs"
   },
   "dependencies": {
     "@babel/plugin-proposal-decorators": "^7.28.0",

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

@@ -2,7 +2,7 @@
 # General
 #
 MIOLO_NAME=miolo
-MIOLO_CONFIG=./src/server/config.mjs
+MIOLO_INTRE_LOCALE=es
 
 #
 # HTTP
@@ -11,7 +11,7 @@ MIOLO_PORT=8001
 MIOLO_HOSTNAME=localhost
 
 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
@@ -57,7 +57,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
@@ -100,8 +100,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