miolo 2.0.0-beta.3 → 2.0.0-beta.30

package/bin/build-client.mjs

@@ -0,0 +1,21 @@
+
+import {xeiraBundle} from 'xeira'
+//import { cleanFolder } from './util.mjs'
+
+process.env.NODE_ENV = 'production'
+
+export default async function(appName, entry, dest) {
+  console.log(`[${appName}][prod] Building client from entry ${entry}`)
+  //cleanFolder(dest)
+
+  // fs.copyFileSync(proot('./cli/index.html'), proot('./build/cli/index.html'))
+  await xeiraBundle({
+    source_index: entry,
+    target: 'browser',
+    bundle_folder: dest,
+    bundle_name: appName,
+    bundle_extension: 'iife.bundle.min',
+    bundler: 'rollup',
+    bundle_node_polyfill: true
+  })
+}

package/bin/build-server.mjs

@@ -0,0 +1,57 @@
+
+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'
+
+process.env.NODE_ENV = 'production'
+
+export async function _fixProdBuild(appName, filePath) {
+  try {
+    const content = await readFile(filePath, 'utf8')
+    const newContent = content.replace(
+      /var key = crypto\.pseudoRandomBytes\(32\)/g,
+      'var key = crypto.randomBytes(32)'
+    )
+    await writeFile(filePath, newContent, 'utf8')
+    console.log(`[${appName}][prod] Fixed server build (prod)!`)
+  } catch (error) {
+    console.error(`[${appName}][prod] Error fixing server build (prod): ${error}`)
+  }
+}
+
+export default async function(appName, ssrEntry, ssrDest, entry, dest) {
+  //cleanFolder(dest)
+
+  console.log(`[${appName}][prod] Building first the SSR entry ${ssrEntry}`)
+  await build({
+    build: {
+      outDir: path.resolve(process.cwd(), ssrDest),
+      ssr: path.resolve(process.cwd(), ssrEntry),
+      rollupOptions: {
+        // 
+      },
+    },
+    // server ssr's entry must bundle externals
+    ssr: {
+      noExternal: true
+    }
+  })
+  
+  console.log(`[${appName}][prod] Building server from entry ${entry}`)
+  const serverExt = 'node.bundle.mjs'
+  await xeiraBundle({
+    source_index: entry,
+    target: 'node',
+    bundle_folder: dest,
+    bundle_name: appName,
+    bundle_extension: serverExt,
+    bundler: 'rollup',
+    bundle_node_polyfill: true,
+  })
+  
+  console.log(`[${appName}][prod] Fixing server build (prod)...`)
+  const destFile =  path.join(process.cwd(), `${dest}/${appName}.${serverExt}`)
+  await _fixProdBuild(appName, destFile)
+}

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

@@ -0,0 +1,77 @@
+import path from 'node:path'
+import { fork } from 'node:child_process'
+
+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}`)
+  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

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+import yargs from 'yargs-parser'
+import { getAppName } from './util.mjs'
+
+async function main() {
+  const args = yargs(process.argv.slice(2))
+  const command = args._[0]
+
+  try {
+    const appName = await getAppName()
+    const serverName = args['server-name'] || 'miolo_server'
+
+    switch (command) {
+      case 'dev':
+        const devHandler = (await import ('./dev.mjs')).default
+        const devEntry = args.entry || './src/server/server-dev.mjs'
+        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)
+        break
+
+      case 'build-server':
+        const buildServerHandler = (await import ('./build-server.mjs')).default
+        const ssrEntry = args['ssr-entry'] || './server/ssr/entry-server.jsx'
+        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)
+        break
+
+      case 'start':
+        const startHandler = (await import ('./start.mjs')).default
+        const startDest = args.dest || './dist/server'
+        await startHandler(appName, /*dest*/ startDest, serverName)
+        break
+
+      case 'stop':
+        const stopHandler = (await import ('./stop.mjs')).default
+        await stopHandler(appName)
+        break
+
+      case 'restart':
+        const restartHandler = (await import ('./restart.mjs')).default
+        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:
+        console.error(`[miolo] Unknown command: ${command}`)
+        console.log('[miolo] Available commands: dev, build-client, build-server, start, stop, restart')
+        process.exit(1)
+    }
+  } catch (error) {
+    console.error('[miolo] Error during command execution:', error)
+    process.exit(1)
+  }
+}
+
+main()

package/bin/restart.mjs

@@ -0,0 +1,12 @@
+import start from "./start.mjs"
+import stop from "./stop.mjs"
+
+process.env.NODE_ENV = 'production'
+
+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

@@ -0,0 +1,28 @@
+import path from 'node:path'
+import { pidFileCreate } from "./util.mjs"
+
+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
+  // }
+  // if (! fs.existsSync(SRV_DEST_MAIN)) {
+  //   console.error(`[${appName}][prod][start] Cannot start server (prod): SERVER bundle does not exist ${SRV_DEST_MAIN}`)
+  //   return
+  // }
+
+  console.log(`[${appName}][prod][start] Starting server...`)
+
+  const serverExt = 'node.bundle.mjs'
+  const destFile =  path.join(process.cwd(), `${dest}/${appName}.${serverExt}`)
+
+  const srv_module = await import(destFile)  
+  const server = srv_module[serverName]
+
+  const pid = pidFileCreate(appName)
+  console.log(`[${appName}][prod][start] Starting server. PID is ${pid}...`)
+
+  await server()  
+}

package/bin/stop.mjs

@@ -0,0 +1,22 @@
+import { pidFileRead } from "./util.mjs"
+
+process.env.NODE_ENV = 'production'
+
+export default async function(appName) {
+  console.log(`[${appName}][prod][stop] Stopping server...`)
+
+  try {
+    const pid = pidFileRead(appName)
+    console.log(`[${appName}][prod][stop] Killing current process with PID ${pid}`)
+
+    process.kill(pid, 'SIGKILL')
+
+    return 1
+  } catch(_) {
+    console.log(`[${appName}][prod][stop] No current process to kill`)
+    console.error(_)
+
+    return 0
+  }  
+
+}

package/bin/util.mjs

@@ -0,0 +1,37 @@
+import {readdirSync, rmSync, writeFileSync, readFileSync} from 'node:fs'
+import { readFile } from 'node:fs/promises'
+import path from 'node:path'
+
+
+export async function getAppName() {
+  try {
+    const packageJsonPath = path.join(process.cwd(), 'package.json')
+    const content = await readFile(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
+}
+
+