miolo 2.0.0-beta.9 → 2.0.0

package/bin/build-client.mjs

@@ -1,10 +1,12 @@
 
 import {xeiraBundle} from 'xeira'
-import { cleanFolder } from './util.mjs'
+//import { cleanFolder } from './util.mjs'
 
-export default async function({ appName, entry, dest }) {
+process.env.NODE_ENV = 'production'
+
+export default async function(appName, entry, dest) {
   console.log(`[${appName}][prod] Building client from entry ${entry}`)
-  cleanFolder(dest)
+  //cleanFolder(dest)
 
   // fs.copyFileSync(proot('./cli/index.html'), proot('./build/cli/index.html'))
   await xeiraBundle({

package/bin/build-server.mjs

@@ -3,7 +3,9 @@ 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'
+
+process.env.NODE_ENV = 'production'
 
 export async function _fixProdBuild(appName, filePath) {
   try {
@@ -19,8 +21,8 @@ export async function _fixProdBuild(appName, filePath) {
   }
 }
 
-export default async function({ appName, ssrEntry, ssrDest, entry, dest }) {
-  cleanFolder(dest)
+export default async function(appName, ssrEntry, ssrDest, entry, dest) {
+  //cleanFolder(dest)
 
   console.log(`[${appName}][prod] Building first the SSR entry ${ssrEntry}`)
   await build({
@@ -28,12 +30,13 @@ export default async function({ appName, ssrEntry, ssrDest, entry, dest }) {
       outDir: path.resolve(process.cwd(), ssrDest),
       ssr: path.resolve(process.cwd(), ssrEntry),
       rollupOptions: {
-        // Opciones adicionales de Rollup si las necesitas
+        // 
       },
     },
-    // Otras opciones de Vite si son necesarias
-    // root: path.resolve(process.cwd(), 'demo'), // Si tu root del proyecto es /demo
-    // plugins: [/* tus plugins */],
+    // server ssr's entry must bundle externals
+    ssr: {
+      noExternal: true
+    }
   })
   
   console.log(`[${appName}][prod] Building server from entry ${entry}`)

package/bin/create-bin.mjs

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

package/bin/dev.mjs

@@ -1,8 +1,77 @@
 import path from 'node:path'
+import { fork } from 'node:child_process'
 
-export default async function({ appName, entry, serverName }) {
+process.env.NODE_ENV = 'development'
+
+let serverProcess = null
+// let retryCount = 0
+// const maxRetries = 5
+
+function _isProcessRunning(pid) {
+  try {
+    process.kill(pid, 0) // Sending a signal 0 does nothing but checks if the process exists
+    return true
+  } catch (error) {
+    return false
+  }
+}
+
+async function startDevServerProcess({ appName, entry }) {
+  const serverPath = path.join(process.cwd(), entry)
+  serverProcess = fork(serverPath)
+
+  console.log(`[${appName}][dev] Server process started with pid ${serverProcess.pid} from ${process.pid}`)
+
+  serverProcess.on('exit', (code, args) => {
+    console.log(`[${appName}][dev] Server process exited with code ${code} -  ${args}`)
+    serverProcess = null
+    // Puedes implementar lógica de reintento aquí si es necesario
+    //  if (code !== 0 && retryCount < maxRetries) {
+    //    retryCount++
+    //    console.log(`[${serverName}][dev] Attempting to restart server (${retryCount}/${maxRetries})...`)
+    //    // Espera un breve tiempo antes de intentar reiniciar
+    //    await new Promise(resolve => setTimeout(resolve, 2000))
+    //    startDevServerProcess({ entry, serverName })
+    //  } else if (code !== 0) {
+    //    console.error(`[${serverName}][dev] Server failed to start after ${maxRetries} retries. Exiting.`)
+    //    process.exit(1)
+    //  }    
+  })
+
+  serverProcess.on('message', (message) => {
+    if (message === 'miolo_restart') {
+      console.log(`[${appName}][dev] Received restart signal. Restarting server...`)
+
+      const pidToKill = serverProcess ? serverProcess.pid : null
+      if (pidToKill) {
+        console.log(`[${appName}][dev] Killing process with PID: ${pidToKill}`)
+        // Clean kill
+        process.kill(pidToKill, 'SIGTERM')
+
+        // Harder if still alive
+        setTimeout(() => {
+          if (_isProcessRunning(pidToKill)) {
+            process.kill(pidToKill, 'SIGKILL')
+          }
+        }, 2000)
+      }
+
+      startDevServerProcess({ appName, entry }) // Inicia un nuevo proceso
+    }
+  })
+}
+
+
+export default async function(appName, entry, serverName) {
   console.log(`[${appName}][dev] Running DEV server ${serverName} from entry ${entry}`)
-  const srv_module = await import(path.join(process.cwd(), entry))
-  const server = srv_module[serverName]
-  await server()  
-}
+  await startDevServerProcess({ appName, entry })
+}
+
+
+
+// export default async function({ appName, entry, serverName }) {
+//   console.log(`[${appName}][dev] Running DEV server ${serverName} from entry ${entry}`)
+//   const srv_module = await import(path.join(process.cwd(), entry))
+//   const server = srv_module[serverName]
+//   await server()  
+// }

package/bin/index.mjs

@@ -14,15 +14,14 @@ async function main() {
       case 'dev':
         const devHandler = (await import ('./dev.mjs')).default
         const devEntry = args.entry || './src/server/server-dev.mjs'
-        const devServerName = args['server-name'] || 'miolo_server'
-        await devHandler({ appName, entry: devEntry, serverName: devServerName })
+        await devHandler(appName, /*entry*/ devEntry, serverName)
         break
 
       case 'build-client':
         const buildClientHandler = (await import ('./build-client.mjs')).default
         const clientEntry = args.entry || './cli/entry-cli.jsx'
         const clientDest = args.dest || './dist/cli'
-        await buildClientHandler({ appName, entry: clientEntry, dest: clientDest })
+        await buildClientHandler(appName, /*entry*/ clientEntry, /*dest*/ clientDest)
         break
 
       case 'build-server':
@@ -31,23 +30,30 @@ async function main() {
         const ssrDest = args['ssr-dest'] || './dist/server'
         const serverEntry = args.entry || './src/server/server-prod.mjs'
         const serverDest = args.dest || './dist/server'
-        await buildServerHandler({ appName, ssrEntry, ssrDest, entry: serverEntry, dest: serverDest })
+        await buildServerHandler(appName, ssrEntry, ssrDest, /*entry*/ serverEntry, /*dest*/ serverDest)
         break
 
       case 'start':
         const startHandler = (await import ('./start.mjs')).default
         const startDest = args.dest || './dist/server'
-        await startHandler({appName, serverName, dest: startDest})
+        await startHandler(appName, /*dest*/ startDest, serverName)
         break
 
       case 'stop':
         const stopHandler = (await import ('./stop.mjs')).default
-        await stopHandler({appName})
+        await stopHandler(appName)
         break
 
       case 'restart':
         const restartHandler = (await import ('./restart.mjs')).default
-        await restartHandler({appName, serverName})
+        const restartDest = args.dest || './dist/server'
+        await restartHandler({appName, /*dest*/ restartDest, serverName})
+        break
+
+      case 'create-bin':
+        const createHandler = (await import ('./create-bin.mjs')).default
+        const createDest = args.dest || './dist/server'
+        await createHandler(appName, /*dest*/ createDest, serverName)
         break
 
       default:

package/bin/restart.mjs

@@ -1,10 +1,12 @@
 import start from "./start.mjs"
 import stop from "./stop.mjs"
 
-export default async function({appName, dest, serverName}) {
-  console.log(`[${appName}][prod][stop] Restarting server...`)
+process.env.NODE_ENV = 'production'
 
-  await stop({appName})
-  await start({appName, dest, serverName})
+export default async function(appName, dest, serverName) {
+  console.log(`[${appName}][prod][restart] Restarting server...`)
+
+  await stop(appName)
+  await start(appName, dest, serverName)
 
 }

package/bin/start.mjs

@@ -1,7 +1,9 @@
 import path from 'node:path'
 import { pidFileCreate } from "./util.mjs"
 
-export default async function({appName, dest, serverName}) {
+process.env.NODE_ENV = 'production'
+
+export default async function(appName, dest, serverName) {
   // if (! fs.existsSync(CLI_DEST_MAIN)) {
   //   console.error(`[${appName}][prod][start] Cannot start server (prod): CLI bundle does not exist ${CLI_DEST_MAIN}`)
   //   return

package/bin/stop.mjs

@@ -1,6 +1,8 @@
-import { pidFileRead } from "./util.mjs";
+import { pidFileRead } from "./util.mjs"
 
-export default async function({appName}) {
+process.env.NODE_ENV = 'production'
+
+export default async function(appName) {
   console.log(`[${appName}][prod][stop] Stopping server...`)
 
   try {