noxt-server 0.1.0

package/README.md

@@ -0,0 +1,118 @@
+# noxt-js
+
+A zero-config JSX web server powered by [Express](https://expressjs.com/) and [noxt-js-middleware](https://npmjs.com/package/noxt-js-middleware).  
+Run it with `npx noxt-js` and drop `.jsx` files into your `views/` folder — routes are created automatically.  
+
+No React required. No heavy framework. Just JSX + Express.  
+
+---
+
+## Installation
+
+```sh
+npm install noxt-js
+```
+
+or run it directly without installing:
+
+```sh
+npx noxt-js
+```
+
+---
+
+## Quick Start
+
+```sh
+npx noxt-js
+```
+
+By default, this will:
+
+- Serve pages from `./views/`
+- Start an HTTP server on port `3000`
+- Look for configuration in `noxt.config.yaml` (optional)
+
+---
+
+## Configuration
+
+`noxt-js` reads options from `noxt.config.yaml` in your project root, or from CLI flags.  
+CLI flags override config file values.
+
+Example `noxt.config.yaml`:
+
+```yaml
+port: 4000
+host: localhost
+views: views
+logLevel: info
+ssl: false
+```
+
+Run with CLI overrides:
+
+```sh
+npx noxt-js --port 8080 --views src/pages
+```
+
+### Available options
+
+- **`port`**: HTTP port number (default: `3000`)  
+- **`host`**: Hostname or IP (default: `0.0.0.0`)  
+- **`views`**: Directory containing `.jsx` files (default: `views`)  
+- **`logLevel`**: One of `error`, `warn`, `info`, `debug`  
+- **`ssl`**:  
+  - `false` (disable SSL)  
+  - or object with `cert` and `key` paths for HTTPS  
+
+---
+
+## Context
+
+You can provide shared helpers/utilities to all components via a `context.js` file (or any path you specify in config). For example:
+
+```js
+// context.js
+export async function fetchUser(id) {
+  return db.users.findById(id);
+}
+```
+
+Then in a page:
+
+```jsx
+export const route = '/user/:id';
+
+export default async function UserPage({ id }, { fetchUser }) {
+  const user = await fetchUser(id);
+  return <h1>{user.name}</h1>;
+}
+```
+
+---
+
+## Pages & Routing
+
+- Any `.jsx` file in `views/` is loaded as a component.  
+- If it exports `route`, it becomes a page at that route.  
+- Props come from route params, query string, and optional `params` export.  
+
+Example:
+
+```jsx
+export const route = '/hello/:name';
+
+export default function HelloPage({ name }) {
+  return <h1>Hello, {name}!</h1>;
+}
+```
+
+---
+
+
+---
+
+## License
+
+LGPL-3.0-or-later

package/bin/noxt-server

@@ -0,0 +1,65 @@
+#!/usr/bin/env node
+import fs from 'fs';
+import path from 'path';
+import minimist from 'minimist';
+import yaml from 'js-yaml';
+import { startServer } from '../index.js';
+
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+
+// read deafault config
+let config = yaml.load(fs.readFileSync(path.resolve(__dirname, '../default.config.yaml'), 'utf8'));
+
+// read local config if exists
+const configPath = 'noxt.config.yaml';
+const configFullPath = path.resolve(process.cwd(), configPath);
+if (fs.existsSync(configFullPath)) {
+  console.log(`Using config file: ${configFullPath}`);
+  try {
+    const localConfig = yaml.load(fs.readFileSync(configFullPath, 'utf8'));
+    Object.assign(config, localConfig);
+  } catch (e) {
+    console.error(`Error loading config file: ${e.message}`);
+    process.exit(1);
+  }
+} else {
+  // guess some defaults based on common project structure
+  if (fs.existsSync(path.resolve(process.cwd(), 'views'))) {
+    config.views.push('views');
+  } 
+  if (fs.existsSync(path.resolve(process.cwd(), 'pages'))) {
+    config.views.push('pages');
+  } 
+  if (fs.existsSync(path.resolve(process.cwd(), 'templates'))) {
+    config.views.push('templates');
+  } 
+  if (fs.existsSync(path.resolve(process.cwd(), 'public'))) {
+    config.static.push('public');
+  }
+  if (fs.existsSync(path.resolve(process.cwd(), 'static'))) {
+    config.static.push('static');
+  }
+  if (fs.existsSync(path.resolve(process.cwd(), 'app.js'))) {
+    config.context = 'app.js';
+  }
+}
+// override config with command line options
+const options = minimist(process.argv.slice(2), {
+  string: ['views'],   // treat as strings
+  unknown: (arg) => true
+});
+
+for (const key in options) {
+  if (key === '_') continue; // ignore non-keyed args
+  if (!(key in config)) {
+    console.warn(`Unknown config option: ${key}`);
+    continue;
+  }
+  config[key] = options[key] ?? config[key];
+}
+
+startServer(config).catch(err => {
+  console.error(`Error starting server: ${err.message}`);
+  console.log(err.stack);
+  process.exit(1);
+});

package/config.js

@@ -0,0 +1,83 @@
+import fs from 'fs';
+import path from 'path';
+
+export const handlers = {
+  port: (val) => Number.isInteger(val) && val > 0 && val < 65536 ? + val : new Error('Port must be an integer between 1 and 65535'),
+  host: (val) => typeof val === 'string' && val.length > 0 ? val : new Error('Host must be a non-empty string'),
+  views: (val) => {
+    val = [].concat(val); // ensure array
+    for (const dir of val) {
+      if (typeof dir !== 'string' || dir.length === 0 || !fs.existsSync(path.resolve(process.cwd(), dir))) {
+        return new Error(`Each views directory must be a valid directory path. Invalid: ${dir}`);
+      }
+      return val;
+    }
+  },
+  static: (val) => {
+    if (!val) return val; // allow empty
+    val = [].concat(val); // ensure array
+    for (const dir of val) {
+      if (typeof dir !== 'string' || dir.length === 0 || !fs.existsSync(path.resolve(process.cwd(), dir))) {
+        return new Error(`Each static directory must be a valid directory path. Invalid: ${dir}`);
+      }
+      return val;
+    }
+  },
+  logLevel: (val) => ['error', 'warn', 'info', 'debug'].includes(val) ? val : new Error('Log level must be one of: error, warn, info, debug'),
+  ssl: (val) => {
+    // either boolean false, or object with cert and key and any other options for https.createServer
+    if (val === false) return val;
+    if (typeof val === 'object' && val !== null && typeof val.cert === 'string' && val.cert.length > 0 && typeof val.key === 'string' && val.key.length > 0) {
+      // check if files exist
+      if (!fs.existsSync(path.resolve(process.cwd(), val.cert))) return new Error('SSL certificate file does not exist');
+      if (!fs.existsSync(path.resolve(process.cwd(), val.key))) return new Error('SSL key file does not exist');
+      return val;
+    }
+    return new Error('SSL must be a boolean false, or an object with cert and key');
+  },
+  logFile: (val) => (!val || typeof val === 'string' && val.length > 0) ? val : new Error('Log file must be a non-empty string'),
+  context: async (val) => {
+    // import a list of modules, and return an object with their exports
+    if (!val) return []; // allow empty
+    val = [].concat(val); // ensure array
+    for (const mod of val) {
+      console.log(`Importing context module: ${mod}`);
+      if (typeof mod !== 'string' || mod.length === 0 || !fs.existsSync(path.resolve(process.cwd(), mod))) {
+        return new Error(`Each context module must be a valid module path. Invalid: ${mod}`);
+      }
+      // import module
+    }
+    return val;
+  },
+}
+/**
+ * Register a handler for a config option
+ * The handler is called with the config value, and should return the processed value
+ * or an Error object if the value is invalid
+ * 
+ * @param {string} key 
+ * @param {Function} handler 
+ */
+export function registerConfigHandler(key, handler = val=>val) {
+  console.log(`Registering config handler for ${key}`);
+  handlers[key] = handler;
+}
+
+export async function processConfig(config, warn) {
+  const ret = {};
+  for (const key in config) {
+    if (handlers[key]) {
+      const result = await handlers[key](config[key]);
+      if (result instanceof Error) {
+        console.error(`Invalid config option "${key}": ${result.message}`);
+        process.exit(1);
+      } else {
+        if (result !== undefined) config[key] = result;
+      }
+    } else if (warn) {
+      console.warn(`Unknown config option: ${key}`);
+    }
+    ret[key] = config[key];
+  }
+  return config;
+}

package/default.config.yaml

@@ -0,0 +1,7 @@
+port: 3000
+ssl: false
+host: localhost
+logLevel: info
+views: []
+static: []
+context: []

package/index.js

@@ -0,0 +1,88 @@
+import express, { json, urlencoded } from 'express';
+import  serve_static from 'serve-static';
+import { resolve } from 'path';
+import cookieParser from 'cookie-parser';
+import logger from 'morgan';
+import noxt from 'noxt-js-middleware';
+import { readFileSync } from 'fs';
+import { createServer } from 'https';
+import reloadServer from './reload_server.js';
+import { processConfig } from './config.js';
+export { registerConfigHandler } from './config.js';
+export { registerPageExportHandler } from 'noxt-js-middleware';
+
+/**
+ * Starts a Noxt server based on a fully resolved config object.
+ * @param {Object} config - Configuration object
+ * @param {number} config.port - Port to listen on
+ * @param {string|string[]} config.views - Path(s) to JSX components
+ * @param {Object} config.context - Context object to inject into components
+ * @param {string} [config.staticDir] - Optional static files directory
+ * @param {Object|boolean} [config.ssl] - false or { cert, key, ca }
+ * @param {string} [config.layout] - Default layout component name
+ * @returns {Promise<{app: express.Application, server: import('http').Server|import('https').Server}>}
+ */
+export async function startServer (config) {
+  // Load context
+  const context = {};
+  config = await processConfig(config, false);
+  for (const mod of [].concat(config.context).flat(Infinity).filter(Boolean)) {
+    Object.assign(context, await import(resolve(mod)));
+  }
+  config = context.config = await processConfig(config,true);
+  console.log('Final config:', config);
+  await context.init?.(context);
+  
+  const app = express();
+
+  // Basic middleware
+  app.use(logger('dev'));
+  app.use(json());
+  app.use(urlencoded({ extended: false }));
+  app.use(cookieParser());
+
+  // Reload server for development
+  if (process.env.NODE_ENV !== 'production') {
+    app.use(reloadServer);
+  }
+
+  // Serve static files if provided
+  for (const dir of [].concat(config.static).flat(Infinity).filter(Boolean)) {
+    app.use(serve_static(resolve(dir)));
+  }
+
+
+
+  // Mount the Noxt router
+  const router = await noxt({
+    directory: config.views,
+    context: context,
+    layout: config.layout,
+  });
+  app.use(router);
+
+  // Default error handler
+  app.use((err, req, res, next) => {
+    res.status(err.status || 500);
+    res.send(err.message || 'Internal Server Error');
+  });
+
+  let server;
+  if (config.ssl && config.ssl !== false) {
+    const sslOptions = {
+      key: readFileSync(resolve(config.ssl.key)),
+      cert: readFileSync(resolve(config.ssl.cert)),
+    };
+    if (config.ssl.ca) sslOptions.ca = readFileSync(resolve(config.ssl.ca));
+    server = createServer(sslOptions, app);
+    server.listen(config.port, () => {
+      console.log(`Noxt HTTPS server running on https://localhost:${config.port}`);
+    });
+  } else {
+    server = app.listen(config.port, () => {
+      console.log(`Noxt HTTP server running on http://localhost:${config.port}`);
+    });
+  }
+
+  return { app, server };
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "noxt-server",
+  "version": "0.1.0",
+  "description": "Server for noxt-js-middleware with CLI and config support",
+  "type": "module",
+  "main": "index.js",
+  "bin": {
+    "noxt-server": "./bin/noxt-server"
+  },
+  "repository": "https://github.com/zocky/noxt-js",
+  "scripts": {
+    "test": "echo \"No tests yet\" && exit 0"
+  },
+  "keywords": [
+    "express",
+    "jsx",
+    "noxt",
+    "server",
+    "ssr",
+    "async",
+    "cli"
+  ],
+  "author": "Zoran Obradović [https://github.com/zocky]",
+  "license": "GPL-3.0-or-later",
+  "peerDependencies": {
+    "cookie-parser": "^1.4.6",
+    "express": "^5.0.0",
+    "js-yaml": "^4.1.0",
+    "minimist": "^1.2.8",
+    "morgan": "^1.10.0",
+    "noxt-js-middleware": "^1.0.0"
+  },
+  "devDependencies": {
+    "cookie-parser": "^1.4.6",
+    "express": "^5.0.0",
+    "js-yaml": "^4.1.0",
+    "minimist": "^1.2.8",
+    "morgan": "^1.10.0",
+    "noxt-js-middleware": "file:../noxt-js-middleware"
+  },
+  
+  "engines": {
+    "node": ">=18"
+  }
+}

package/reload_client.js

@@ -0,0 +1,15 @@
+const eventSource = new EventSource('/_events');
+let reload = false;
+eventSource.addEventListener('connected', () => {
+  if (reload) {
+    console.log('%c Reloading... ','color: #ffd; background-color: #080');
+    window.location.reload();
+  } else {
+    console.log('%c Connected ', 'color: #ffd; background-color: #080' );
+  }
+
+});
+eventSource.addEventListener('reload', () => {
+    console.log('%c Restarting... ','color: #ffd; background-color: #080');
+  reload = true;
+});

package/reload_server.js

@@ -0,0 +1,43 @@
+import express from 'express';
+import fs from 'fs';
+import path from 'path';
+const __dirname = path.dirname(new URL(import.meta.url).pathname);
+
+const router = express.Router();
+export default router;
+
+const clients = new Set();
+router.get('/_events', async (req, res) => {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache',
+    'Connection': 'keep-alive',
+    'content-encoding': 'none'
+  });
+  res.write('\nevent:connected\ndata:\n\n');
+  clients.add(res);
+  console.log('client connected');
+  res.on('close', () => {
+    console.log('client disconnected');
+    clients.delete(res);
+    res.end();
+  })
+});
+
+const reloadJs = fs.readFileSync(path.join(__dirname, 'reload_client.js'), 'utf8');
+router.get('/_reload.js', async (req, res) => {
+  res.set('Content-Type', 'text/javascript');
+  res.send(reloadJs);
+});
+
+
+process.on('SIGUSR2', async () => {
+  console.log('beforeExit');
+  const promises = Array.from(clients).map(async client => {
+    console.log('restarting client')
+    client.write('event: reload\ndata:\n\n');
+    return new Promise(resolve => client.end(resolve));
+  });
+  await Promise.all(promises);
+  process.exit(0);
+});