miolo 2.0.0-beta.13 → 2.0.0-beta.15

package/bin/dev.mjs

@@ -5,13 +5,24 @@ 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)
 
-  serverProcess.on('exit', (code) => {
-    console.log(`[${appName}][dev] Server process exited with code ${code}`)
+  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++
@@ -26,15 +37,23 @@ async function startDevServerProcess({ appName, entry }) {
   })
 
   serverProcess.on('message', (message) => {
-    if (message === 'restart') {
+    if (message === 'miolo_restart') {
       console.log(`[${appName}][dev] Received restart signal. Restarting server...`)
-      serverProcess.kill('SIGTERM') // Intenta un cierre limpio primero
-      // Después de un breve tiempo, si no se cierra, puedes forzarlo con 'SIGKILL'
-      setTimeout(() => {
-        if (serverProcess && !serverProcess.killed) {
-          serverProcess.kill('SIGKILL')
-        }
-      }, 2000)
+
+      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
     }
   })
@@ -43,9 +62,6 @@ async function 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()  
   await startDevServerProcess({ appName, entry })
 }
 

package/dist/cli/miolo.cli.umd.js

@@ -1,5 +1,5 @@
 /**
- * miolo v2.0.0-beta.13
+ * miolo v2.0.0-beta.15
  *
  * https://www.afialapis.com/os/miolo
  *

package/dist/cli-react/miolo.cli-react.umd.js

@@ -1,5 +1,5 @@
 /**
- * miolo v2.0.0-beta.13
+ * miolo v2.0.0-beta.15
  *
  * https://www.afialapis.com/os/miolo
  *

package/dist/server/miolo.server.node.mjs

@@ -1,5 +1,5 @@
 /**
- * miolo v2.0.0-beta.13
+ * miolo v2.0.0-beta.15
  *
  * https://www.afialapis.com/os/miolo
  *
@@ -8004,7 +8004,10 @@ function _miolo() {
                   return app.http.stop();
                 case 3:
                   app.cron.stop();
-                case 4:
+                  if (app != null && app.vite) {
+                    app.vite.close();
+                  }
+                case 5:
                 case "end":
                   return _context2.stop();
               }
@@ -8038,4 +8041,74 @@ function _miolo() {
   return _miolo.apply(this, arguments);
 }
 
-export { miolo, init_emailer_transporter as miolo_emailer, init_logger as miolo_logger, init_parser as miolo_parser };
+function miolo_cron(_x) {
+  return _miolo_cron.apply(this, arguments);
+}
+function _miolo_cron() {
+  _miolo_cron = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee4(sconfig) {
+    var app, config;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) switch (_context4.prev = _context4.next) {
+        case 0:
+          app = {
+            use: function use() {}
+          }; // Init some pieces
+          config = init_config(sconfig); // attach to app some custom miolo methods
+          init_context_middleware(app, config);
+
+          // Init cron (will not start jobs yet)
+          init_cron(app, config == null ? void 0 : config.cron);
+
+          // Util callbacks
+          app.start = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+            return _regeneratorRuntime().wrap(function _callee$(_context) {
+              while (1) switch (_context.prev = _context.next) {
+                case 0:
+                  _context.next = 2;
+                  return app.context.miolo.db.init_connection();
+                case 2:
+                  app.cron.start();
+                case 3:
+                case "end":
+                  return _context.stop();
+              }
+            }, _callee);
+          }));
+          app.stop = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+            return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+              while (1) switch (_context2.prev = _context2.next) {
+                case 0:
+                  app.context.miolo.db.drop_connections();
+                  app.cron.stop();
+                case 2:
+                case "end":
+                  return _context2.stop();
+              }
+            }, _callee2);
+          }));
+          app.restart = /*#__PURE__*/_asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+            return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+              while (1) switch (_context3.prev = _context3.next) {
+                case 0:
+                  _context3.next = 2;
+                  return app.stop();
+                case 2:
+                  _context3.next = 4;
+                  return app.start();
+                case 4:
+                case "end":
+                  return _context3.stop();
+              }
+            }, _callee3);
+          }));
+          return _context4.abrupt("return", app);
+        case 8:
+        case "end":
+          return _context4.stop();
+      }
+    }, _callee4);
+  }));
+  return _miolo_cron.apply(this, arguments);
+}
+
+export { miolo, miolo_cron, init_emailer_transporter as miolo_emailer, init_logger as miolo_logger, init_parser as miolo_parser };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miolo",
-  "version": "2.0.0-beta.13",
+  "version": "2.0.0-beta.15",
   "description": "all-in-one koa-based server",
   "author": "Donato Lorenzo <donato@afialapis.com>",
   "contributors": [

package/src/server/index.mjs

@@ -1,4 +1,5 @@
 import { miolo } from './server.mjs'
+import { miolo_cron } from './server-cron.mjs'
 import { init_emailer_transporter as miolo_emailer} from './engines/emailer/index.mjs'
 import { init_logger as miolo_logger } from './engines/logger/index.mjs'
 import { init_parser as miolo_parser } from './engines/parser/index.mjs'
@@ -8,6 +9,7 @@ import { getConnection as miolo_db_connection} from 'calustra/conn-postgres'
 
 export {
   miolo,
+  miolo_cron,
   miolo_emailer,
   miolo_logger,
   miolo_parser,

package/src/server/middleware/vite/watcher.mjs

@@ -14,27 +14,28 @@ export async function init_watcher_dev_server_middleware(app, watcherConfig, ssr
     watcher = app.vite.watcher
 
     // Extra dirs to watch
-    const serverDirsToWatch = watcherConfig?.dirs || [
-      path.resolve(process.cwd(), path.basename(ssrConfig.server))
-    ]
+    const serverDirsToWatch = watcherConfig?.dirs || ['server', 'src/server']
 
     // Listen to changes in the extra dirs
     serverDirsToWatch.forEach((dir) => {
-      watcher.add(dir)
-      app.context.miolo.logger.info(`[watcher] Vite is now watching for changes in: ${dir}`)
+      watcher.add(path.resolve(process.cwd(), dir))
+      app.context.miolo.logger.info(`[watcher] Vite is now watching for changes also in: ${dir}`)
     })
    
     // Listen to changes in the extra dirs
-    watcher.on('change', (filePath) => {
+    watcher.on('change', async (filePath) => {
+      let isCustom = false
+      serverDirsToWatch.forEach((dir) => {
+        if (filePath.startsWith(path.resolve(process.cwd(), dir))) {
+          isCustom = true
+        }
+      })
+      if (!isCustom) return // Ignore changes outside the custom watched directories
       app.context.miolo.logger.info(`[watcher] File changed: ${filePath}. Reloading server...`)
-      // Aquí puedes implementar la lógica para reiniciar tu servidor Koa
-      // Por ejemplo, podrías cerrar el servidor actual y crear uno nuevo,
-      // o usar alguna forma de recarga en caliente específica de Koa (si existe).
-      // Un reinicio completo del proceso de Node.js suele ser la forma más segura.
-      //process.exit(0) // Forzar la salida del proceso para que un gestor de procesos lo reinicie
-      process.send('restart') // Envía un mensaje al proceso padre para reiniciar
-    })
 
+      await app.stop()
+      process.send('miolo_restart') // Envía un mensaje al proceso padre para reiniciar
+    })
   } 
 
   app.watcher= watcher

package/src/server/server-cron.mjs

@@ -0,0 +1,39 @@
+import { init_config }                    from './config/index.mjs'
+import { init_context_middleware }         from './middleware/context/index.mjs'
+import { init_cron }                       from './engines/cron/index.mjs'
+
+export async function miolo_cron(sconfig) {
+
+  const app = {
+    use: () => {},
+  }
+
+  // Init some pieces
+  const config = init_config(sconfig)
+  
+  // attach to app some custom miolo methods
+  init_context_middleware(app, config)
+
+
+  // Init cron (will not start jobs yet)
+  init_cron(app, config?.cron)
+    
+  // Util callbacks
+  app.start = async () => {
+    // Init and reset db connection
+    await app.context.miolo.db.init_connection()
+    app.cron.start()
+  }
+  
+  app.stop = async () => {
+    app.context.miolo.db.drop_connections()
+    app.cron.stop()
+  }
+
+  app.restart = async () => {
+    await app.stop()
+    await app.start()
+  }
+
+  return app
+}

package/src/server/server.mjs

@@ -119,6 +119,9 @@ async function miolo(sconfig, devInit= undefined, devRender= undefined) {
     app.context.miolo.db.drop_connections()
     await app.http.stop()
     app.cron.stop()
+    if (app?.vite) {
+      app.vite.close()
+    }
   }
 
   app.restart = async () => {