noxt-server 0.1.4 → 0.1.6

package/bin/noxt-server

@@ -1,65 +1,4 @@
 #!/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);
-});
+console.warn('Deprecated. Use noxt-cli instead.');
+process.exit(1);

package/default.config.yaml

@@ -2,6 +2,7 @@ port: 3000
 ssl: false
 host: localhost
 logLevel: info
+recipe: app/main
 views: []
 static: []
 context: []

package/dev-ui/DevIndex.jsx

@@ -0,0 +1,17 @@
+export const route = '/';
+
+export default function DevIndex({ }, { noxt, DevModule }) {
+  const { modules, components } = noxt;
+  return (
+    <div>
+      <h1>Dev UI</h1>
+      <ul class="noxt list">
+        {Object.keys(modules).map((name) => (
+          <div class="nost item">
+            {name}: <DevModule.Link name={name} text={name} />
+          </div>
+        ))}
+      </ul>
+    </div>
+  );
+}

package/dev-ui/DevModule.jsx

@@ -0,0 +1,87 @@
+import yaml from 'js-yaml';
+
+
+export const route = '/module/:name';
+export const params = {
+  module: ({ name }, { noxt }) => noxt.modules[name],
+  Template: ({ name }, { noxt }) => noxt.components[name]
+};
+
+export default async function DevModule({ name, Template }, { query, req, res }) {
+  if (!Template) return <p>No component named “{name}”.</p>;
+  return (
+    <div>
+      <h1>Dev UI - {name}</h1>
+      {await Template.renderWithRequest(query, req, res, query = {})}
+      <Node node={await Template.evaluateWithRequest(query, req, res, query = {})} />
+    </div>
+  );
+}
+
+function Node({ node }) {
+  if (!node) return null;
+  if (typeof node === 'string' || typeof node === 'number') return node;
+
+  if (Array.isArray(node)) {
+    return (
+      <div>
+        {node.map((n) => (
+          <Node node={n} />
+        ))}
+      </div>
+    );
+  }
+  if (typeof node === 'boolean') return node;
+  if (typeof node === 'object') {
+    if (node.html) return <pre>{node.html.slice(0, 100)}</pre>
+  }
+
+  const { type, props: { children, ...props } = {} } = node;
+  let kind = 'tag';
+
+  if (type?.isNoxtFragment) {
+    return (
+      <noxt-node type="fragment">
+        {children && <noxt-children><Node node={children} /></noxt-children>}
+      </noxt-node>
+    )
+  }
+  let name = type;
+
+  if (type?.isNoxtComponent) {
+    kind = 'component';
+    name = type.noxtName;
+  } else if (typeof type === 'function') {
+    kind = 'function';
+    name = type.constructor.name + ' ' + (type.name || 'anon');
+  } else {
+    name = type;
+  }
+  return (
+    <noxt-node type={kind}>
+      <noxt-name>{name}</noxt-name>
+      <noxt-props>
+        {Object.entries(props).map(([k, v]) => {
+          const value = safeStringify(v);
+          const text = value.length > 30 ? <details ><summary>{value.slice(0, 27) + '...'}</summary><pre>{yaml.dump(v)}</pre></details> : value;
+          return <noxt-prop>
+            <noxt-key>{k}</noxt-key>
+            <noxt-value>{text}</noxt-value>
+          </noxt-prop>
+        })}
+      </noxt-props>
+      {children && <noxt-children><Node node={children} /></noxt-children>}
+    </noxt-node>
+  );
+}
+
+function safeStringify(value, space = 0) {
+  return JSON.stringify(value, (k, v) => {
+    if (v == null) return v; // use null, drop undefined
+    const t = typeof v;
+    if (t === 'boolean' || t === 'string' || t === 'number') return v;
+    if (Array.isArray(v)) return v;
+    if (t === 'object' && (v.constructor === Object || v.constructor === null)) return v;
+    return '[' + t + ' ' + v.constructor.name + ']';
+  }, space);
+}

package/noxt-server.js

@@ -0,0 +1,32 @@
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import MLM from 'mlm-core';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+export async function startServer({ config, recipe }) {
+ 
+  const mlmInstance = MLM({
+    import:
+      p => import(p),
+    resolveModule:
+      name => name.startsWith('app/')
+        ? `${process.cwd()}/units/${name.slice(4)}.js`
+        : `${__dirname}/units/${name}.js`
+  });
+  try {
+    const report = await mlmInstance.analyze(recipe ?? 'noxt-dev');
+    if (!report.success) {
+      console.log(report.order.join(', '));
+      process.exit(1);
+    }
+    
+    await mlmInstance.install(recipe ?? 'noxt-dev');
+    await mlmInstance.start(config);
+  } catch (e) {
+    console.log(await mlmInstance.analyze(recipe ?? 'noxt-dev'));
+    console.error(e);
+    process.exit(1);
+  }
+}

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "noxt-server",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "description": "Server for noxt-js-middleware with CLI and config support",
   "type": "module",
-  "main": "index.js",
+  "main": "noxt-server.js",
   "bin": {
     "noxt-server": "./bin/noxt-server"
   },
@@ -22,21 +22,18 @@
   ],
   "author": "Zoran Obradović [https://github.com/zocky]",
   "license": "GPL-3.0-or-later",
-  "peerDependencies": {
-    "cookie-parser": "^1.4.6",
+  "dependencies": {
+    "noxt-js-middleware": "^1.0.5",
+    "mlm-core": "^1.0.5",
     "express": "^5.0.0",
+    "cookie-parser": "^1.4.6",
     "js-yaml": "^4.1.0",
     "minimist": "^1.2.8",
-    "morgan": "^1.10.0",
-    "noxt-js-middleware": ">=1.0.3"
+    "node-fetch-cache": "^5.0.2"
   },
   "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": "^1.0.3"
+    "noxt-js-middleware": "../noxt-js-middleware",
+    "mlm-core": "../mlm-core"
   },
   "engines": {
     "node": ">=18"

package/units/config.js

@@ -0,0 +1,89 @@
+export const info = {
+  name: 'config',
+  version: '1.0.0',
+  description: 'Config ',
+  requires: ['utils','services'],
+}
+
+const config_is = {};
+const config_defaults = {};
+const config_defs = {}
+
+function merge_deep(target, ...sources) {
+  if (!sources.length) return target;
+  
+  const source = sources.shift();
+  
+  if (is_plain(target) && is_plain(source)) {
+    for (const key in source) {
+      if (source.hasOwnProperty(key)) {
+        // If target doesn't have this key, simply assign
+        if (!target.hasOwnProperty(key)) {
+          target[key] = source[key];
+        } 
+        // If both target and source have this key and both are plain objects, recurse
+        else if (is_plain(target[key]) && is_plain(source[key])) {
+          merge_deep(target[key], source[key]);
+        }
+        // If target has a non-plain object value, ignore (don't overwrite or try to merge into it)
+        // else: do nothing (keep target's existing value)
+      }
+    }
+  }
+  
+  return merge_deep(target, ...sources);
+}
+
+function is_plain(obj) {
+  return obj !== null && 
+         typeof obj === 'object' && 
+         (obj.constructor === Object || obj.constructor === null);
+}
+
+export default mlm => ({
+  'define.config': () => ({}),
+  'register.config': (defs, unit) => {
+    for (const key in defs) {
+      const def = defs[key];
+      mlm.assert.not(key in config_defs, 'Duplicate config key ' + key);
+      mlm.assert.is({
+        is: 'any|none',
+        default: 'any|none'
+      }, def, `config.${key}`);
+
+      if ('default' in def) {
+        config_defaults[key] = mlm.utils.eval(def.default);
+      }
+      config_defs[key] = {
+        is: def.is,
+        default: def.default,
+        unit: unit
+      };
+    }
+  },
+  'utils.merge_deep': merge_deep,
+  'services.config': () => new class ConfigService {
+    process(config) {
+      const merged = merge_deep({}, config_defaults, config);
+      const ret = {};
+      for (const key in config_defs) {
+        const { is: type } = config_defs[key];
+        if (key in merged) {
+          mlm.assert.is(type, merged[key], `config.${key}`);
+          ret[key] = merged[key];
+        }
+      }
+      return ret;
+    }
+    get_defs() {
+      return {
+        config_defs,
+        config_is,
+        config_defaults
+      };
+    }
+  },
+  onStart(config) {
+    Object.assign(mlm.config, mlm.services.config.process(config));
+  }
+})

package/units/env.js

@@ -0,0 +1,14 @@
+export const info = {
+  name: 'env',
+  version: '1.0.0',
+  description: 'Environment',
+}
+/*
+export default mlm => ({
+  'define.DEV': () => process.env.NODE_ENV !== 'production',
+  'define.PROD': () => process.env.NODE_ENV === 'production',
+  'onBeforeLoad': () => {
+    //process.env.NODE_ENV ||= 'development'
+  }
+})
+  */

package/units/express.js

@@ -0,0 +1,65 @@
+export const info = {
+  name: 'express',
+  description: 'Sets up an Express server',
+  requires: ['plugin'],
+  npm: {
+    'express': '^5.0.0',
+    'cookie-parser': '^1.4.6'
+  },
+}
+
+let app;
+const middlewareNames = new Set();
+const middlewares = [];
+export default mlm => ({
+  'define.express': { get: () => app },
+  'register.middleware': (conf, unit) => {
+    for (const key in conf) {
+      mlm.assert.not(key in middlewareNames, 'Duplicate middleware ' + key);
+      middlewareNames.add(key);
+      let c = conf[key];
+      if (mlm.is.function(c)) {
+        c = { create: c };
+      }
+      mlm.assert.is({
+        path: 'string|none',
+        create: 'function'
+      }, c, 'middleware');
+      mlm.assert.is.function(c.create, 'middleware');
+      middlewares.push({ ...c, unit: unit.name });
+    }
+  },
+  'config.port': {
+    is: v => Number.isInteger(v) && v > 0 && v < 65536,
+    default: 3000
+  },
+  'config.host': {
+    is: 'string',
+    default: 'localhost'
+  },
+  'middleware.json': async (app) => {
+    const { default: express } = await mlm.import('express');
+    return express.json();
+  },
+  'middleware.urlencoded': async (app) => {
+    const { default: express } = await mlm.import('express');
+    return express.urlencoded({ extended: true });
+  },
+  async onStart() {
+    const { default: express } = await mlm.import('express');
+    app = express();
+    app.use((req, res, next) => {
+      mlm.log(req.method, req.url);
+      next();
+    })
+    for (const middleware of middlewares) {
+      const mw = await middleware.create(app);
+      if (middleware.path) {
+        app.use(middleware.path, mw);
+      } else {
+        app.use(mw);
+      }
+    }
+    app.listen(mlm.config.port, mlm.config.host);
+  },
+})

package/units/fetch-cache-fs.js

@@ -0,0 +1,54 @@
+export const info = {
+  name: 'fetch-cache-fs',
+  version: '1.0.0',
+  description: 'Cached fetch with filesystem cache',
+  requires: ['noxt-plugin'],
+  provides: ['#fetch'],
+  npm: {
+    'node-fetch-cache': '^1.0.0',
+  },
+}
+
+let fetchCache = null;
+
+export default mlm => ({
+  'config.fetch': {
+    is: {
+      cacheDir: 'string',
+      ttl: 'integer|none',
+      enabled: 'boolean',
+      retry: 'positiveInteger',
+      timeout: 'positiveInteger'
+    },
+    default: {
+      enabled: true,
+      cacheDir: '.cache/fetch-cache',
+      ttl: 60 * 60 * 1000,
+      retry: 2,
+      timeout: 5000
+    },
+  },
+  'pageContext.fetch': ({ ctx }) => globalFetch.bind(null, ctx),
+  'serverContext.fetch': () => globalFetch,
+  'onStart': async () => {
+    const { default: nodeFetchCache, FileSystemCache } = await mlm.import('node-fetch-cache');
+    const cfg = mlm.config.fetch;
+    fetchCache = nodeFetchCache.create({
+      cache: cfg.enabled ? new FileSystemCache({ cacheDirectory: cfg.cacheDir }) : undefined,
+      ttl: cfg.ttl,
+      retry: cfg.retry,
+      timeout: cfg.timeout
+    });
+  }
+});
+
+async function globalFetch(ctx, url, options = {}) {
+  let res = await fetchCache(url, options);
+  if (ctx.req.headers.pragma === 'no-cache' && !res.isCacheMiss) {
+    console.log('reload', url);
+    res.ejectFromCache();
+    res = await fetch(url, options);
+  }
+  if (!res.ok) throw new Error(res.statusText);
+  return res;
+}

package/units/fetch-cache.js

@@ -0,0 +1,48 @@
+export const info = {
+  name: 'fetch-cache',
+  version: '1.0.0',
+  requires: ['noxt-plugin'],
+  provides: ['#fetch'],
+  description: 'Cached fetch',
+  npm: {
+    'node-fetch-cache': '^1.0.0',
+  },
+}
+
+let fetchCache = null;
+
+export default mlm => ({
+  'config.fetch': {
+    is: {
+      ttl: 'integer|none',
+      retry: 'positiveInteger|none',
+      timeout: 'positiveInteger|none'
+    },
+    default: {
+      ttl: 60 * 60 * 1000,
+      retry: 2,
+      timeout: 5000
+    }
+  },
+
+  'pageContext.fetch': (props, ctx) => globalFetch.bind(null, ctx),
+  'serverContext.fetch': () => globalFetch,
+
+  async onStart() {
+    const { default: nodeFetchCache } = await mlm.import('node-fetch-cache');
+    const cfg = mlm.config.fetch;
+    fetchCache = await nodeFetchCache.create({
+      cache: undefined,
+      ttl: cfg.ttl,
+      retry: cfg.retry,
+      timeout: cfg.timeout
+    });
+  }
+});
+
+async function globalFetch(ctx, url, options = {}) {
+  if (ctx.req.headers.pragma === 'no-cache') options.cache = 'no-cache';
+  const res = await fetchCache(url, options);
+  if (!res.ok) throw new Error(res.statusText);
+  return res;
+}

package/units/fetch-node.js

@@ -0,0 +1,34 @@
+export const info = {
+  name: 'fetch-node',
+  version: '1.0.0',
+  description: 'Native fetch',
+  requires: ['noxt-plugin'],
+  provides: ['#fetch'],
+}
+
+export default mlm => ({
+  name: 'fetch-node',
+  requires: ['noxt-plugin'],
+  provides: ['#fetch'],
+  description: 'Native fetch',
+  'config.fetch': {
+    is: {
+      ttl: 'integer|none',
+      retry: 'positiveInteger|none',
+      timeout: 'positiveInteger|none'
+    },
+    default: {
+      ttl: 60 * 60 * 1000,
+      retry: 2,
+      timeout: 5000
+    }
+  },
+
+  'serverContext.fetch': () => fetchOrThrow,
+});
+
+async function fetchOrThrow(ctx, url, options = {}) {
+  const res = await fetch(url, options);
+  if (!res.ok) throw new Error(res.statusText);
+  return res;
+}

package/units/fetch.js

@@ -0,0 +1,27 @@
+export const info = {
+  version: '1.0.0',
+  description: 'Preload props from urls',
+  requires: ['noxt-plugin','#fetch'],
+}
+
+export default mlm => ({
+  'componentExports.fetch': async ({exported, props, ctx}) => {
+    for (const id in exported) {
+      let url = await mlm.utils.eval(exported[id], props, ctx);
+      mlm.log('fetching', id, url);
+      try {
+        const now = performance.now();
+        const res = await ctx.fetch(url);
+        mlm.log('fetched', id, url, (performance.now() - now).toFixed(3) +'ms');
+        props[id] = await res.json();
+        //mlm.log('fetched', url, JSON.stringify(props[id]).length);
+      } catch (e) {
+        if (process.env.NODE_ENV !== 'production') {
+          mlm.throw(new Error('error fetching ' + url + ': ' + e));
+        }
+        mlm.error('fetch', url, e);
+        props[id] = null;
+      }
+    }
+  },
+})

package/units/hooks.js

@@ -0,0 +1,27 @@
+export const info = {
+  name: 'hooks',
+  version: '1.0.0',
+  description: 'Hooks',
+  requires: ['utils','services']
+}
+const hooks = {}
+const hook_handlers = {}
+
+export default mlm => {
+  return ({
+    'define.hooks': () => mlm.utils.readOnly(hooks, 'hooks'),
+    'register.hooks': mlm.utils.collector(hooks, {
+      is: 'function',
+      mode: 'object',
+      map: (fn, key) => (...args) => {
+        for (const handler of hook_handlers[key] ?? []) {
+          fn(handler, ...args);
+        }
+      }
+    }),
+    'register.on': mlm.utils.collector(hook_handlers, {
+      is: 'function',
+      mode: 'array'
+    })
+  })
+}

package/units/logger.js

@@ -0,0 +1,15 @@
+export const info = {
+  name: 'logger',
+  version: '1.0.0',
+  description: 'Minimal logger',
+  requires: ['express'],
+}
+
+export default mlm => ({
+  'middleware.logger': async (app) => {
+     return (req, res, next) => {
+        console.log(req.method, req.url);
+        next();
+     }
+  },
+})

package/units/noxt-dev.js

@@ -0,0 +1,13 @@
+export const info = {
+  name: 'noxt-dev',
+  description: 'Noxt Dev server',
+  requires: [
+    'express',
+    'logger',
+    'static',
+    'noxt-router-dev',
+    'reload',
+    'fetch-cache-fs',
+    'fetch',
+  ],
+}

package/units/noxt-plugin.js

@@ -0,0 +1,125 @@
+export const info = {
+  name: 'noxt-plugin',
+  description: 'Noxt Plugin',
+  requires: ['express','#noxt-router'],
+}
+
+const pageContextHooks = {};
+const serverContextHooks = {};
+const componentExportsHooks = {};
+const registerPageHooks = {};
+const registerComponentHooks = {};
+
+export default mlm => {
+
+  const collector = (coll, desc) => (conf, unit) => {
+    for (const key in conf) {
+      const fn = conf[key];
+      mlm.assert.is.function(fn, desc);
+      mlm.assert.not(key in coll, 'Duplicate ' + desc + ' ' + key);
+      coll[key] = ({ fn, unit: unit.name });
+    }
+  }
+
+  const runner = (
+    coll, each = (_, fn, ...args) => fn(...args)
+  ) => async (...args) => {
+    for (const key in coll) {
+      const { fn } = coll[key];
+      await each(key, fn, ...args);
+    }
+  }
+
+  const arrayCollector = (coll, desc) => (conf, unit) => {
+    for (const key in conf) {
+      const fn = conf[key];
+      mlm.assert.is.function(fn, desc);
+      coll[key] ??= [];
+      coll[key].push({ fn, unit: unit.name });
+    }
+  }
+
+  const arrayRunner = (
+    coll, each = (_, fn, ...args) => fn(...args)
+  ) => async (...args) => {
+    for (const key in coll) {
+      const handlers = coll[key];
+      for (const handler of handlers) {
+        await each(key, handler.fn, ...args);
+      }
+    }
+  }
+  const globalServerContext = {};
+  return ({
+    'register.pageContext': arrayCollector(pageContextHooks, 'page context handler'),
+    'register.serverContext': arrayCollector(serverContextHooks, 'server context handler'),
+    'register.componentExports': arrayCollector(componentExportsHooks, 'page export handler'),
+    'register.registerPage': collector(registerPageHooks, 'register page handler'),
+    'register.registerComponent': collector(registerComponentHooks, 'register component handler'),
+    'define.noxt_context': {
+      get: () => globalServerContext,
+      enumerable: true
+    },
+    'serverContext.utils': () => mlm.utils,
+    'serverContext.DEV': () => mlm.DEV,
+    'serverContext.PROD': () => mlm.PROD,
+    onStart: async () => {
+      mlm.services.noxt.noxt_context({ ctx: globalServerContext });
+      //mlm.log('ctx', mlm.serverContext);
+    },
+    'services.noxt': () => new class PluginService {
+      noxt_context = arrayRunner(serverContextHooks,
+        async (key, fn, { ctx }) => ctx[key] = await fn({ ctx })
+      );
+
+      noxt_hooks = {
+        beforeRequest: [
+          ({ ctx }) => {
+            Object.assign(ctx, mlm.noxt_context);
+          },
+          arrayRunner(pageContextHooks,
+            async (key, fn, args) => {
+              args.ctx[key] = await fn(args)
+            }
+          ),
+        ],
+        beforeRender: arrayRunner(componentExportsHooks,
+          async (key, fn, { module, props, ctx }) => {
+            //mlm.log('beforeRender', unit, key, Object.keys(props));
+            if (!(key in module)) return;
+            const exported = module[key];
+            await fn({ exported, props, ctx, module })
+            //mlm.log('beforeRender', key, Object.keys(props));
+          }
+        ),
+        registerPage: runner(registerPageHooks,
+          async (key, fn, { module, component }) => {
+            await fn({ module, component })
+          }
+        ),
+        registerComponent: runner(registerComponentHooks,
+          async (key, fn, { module, component }) => {
+            await fn({ module, component })
+          }
+        )
+      }
+
+      report() {
+        return {
+          pageContext: pageContextHooks,
+          serverContext: serverContextHooks,
+          componentExports: componentExportsHooks,
+          registerPage: registerPageHooks,
+          registerComponent: registerComponentHooks
+        }
+      }
+    },
+    'registerPage.Link'({ component, module }) {
+      const As = module.Link ?? 'a';
+      component.Link = ({ text, children, attrs, ...props }, ctx) => {
+        const href = component.getRoutePath(props, ctx);
+        return { type: As, props: { ...attrs, href, children: text ?? children }  };
+      }
+    }
+  })
+}

package/units/noxt-router-dev.js

@@ -0,0 +1,32 @@
+export const info = {
+  name: 'noxt-router-dev',
+  description: 'Sets up a Noxt Router',
+  requires: ['plugin'],
+  provides: ['#noxt-router'],
+  npm: {
+    'noxt-js-middleware': '^1.0.4'
+  },
+}
+
+export default mlm => ({
+  'config.views': {
+    is: ['string'],
+    default: ['views']
+  },
+  'middleware.noxt': async () => {
+    const { default: noxt } = await mlm.import('noxt-js-middleware');
+    const noxtRouter = await noxt({
+      context: mlm.noxt_context,
+      views: mlm.config.views,
+      hooks: mlm.services.noxt.noxt_hooks
+    })
+    const devRouter = await noxt({
+      context: mlm.noxt_context,
+      views: mlm.config.views,
+      hooks: mlm.services.noxt.noxt_hooks,
+      noxt: noxtRouter
+    })
+    noxtRouter.use('/dev', devRouter)
+    return noxtRouter
+  }
+})

package/units/noxt-router.js

@@ -0,0 +1,25 @@
+export const info = {
+  name: 'noxt-router',
+  description: 'Sets up a Noxt Router',
+  requires: ['plugin'],
+  provides: ['#noxt-router'],
+  npm: {
+    'noxt-js-middleware': '^1.0.4'
+  },
+}
+
+export default mlm => ({
+  'config.views': {
+    is: ['string'],
+    default: ['views']
+  },
+  'middleware.noxt': async (app) => {
+    const { default: noxt } = await mlm.import('noxt-js-middleware');
+    const noxtRouter = await noxt({
+      context: mlm.noxt_context,
+      views: mlm.config.views,
+      hooks: mlm.services.noxt.noxt_hooks
+    })
+    return noxtRouter
+  },
+})

package/units/noxt.js

@@ -0,0 +1,13 @@
+export const info = {
+  name: 'noxt',
+  version: '1.0.0',
+  description: 'Noxt server',
+  requires: [
+    'express', 
+    'logger',
+    'static', 
+    'noxt-router',
+    'fetch-cache-fs', 
+    'fetch',
+  ],
+}

package/units/plugin.js

@@ -0,0 +1,6 @@
+export const info = {
+  name: 'plugin',
+  version: '1.0.0',
+  description: 'Base',
+  requires: ['utils','services','hooks','config']
+}

package/units/reload.js

@@ -0,0 +1,76 @@
+export const info = {
+  name: 'reload',
+  description: 'Hot reload middleware',
+  requires: ['noxt-plugin'],
+  npm: {
+    'express': '^5.0.0',
+  },
+}
+
+const clients = new Set();
+export default mlm => ({
+  'pageContext.reload': ({ ctx }) => ctx.slot('script', 'noxt-reload', '/_reload.js'),
+  'middleware.reload': async () => {
+    const { default: express } = await mlm.import('express');
+    const router = express.Router();
+    router.get('/_reload.js', (req, res) => {
+      res.set('Content-Type', 'text/javascript');
+      res.send(reloadJs);
+    });
+
+    router.get('/_events', (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);
+      res.on('close', () => {
+        clients.delete(res);
+        res.end();
+      })
+      req.on('error', () => clients.delete(res));
+      res.on('error', () => clients.delete(res));
+    });
+
+    return router
+  },
+  onStart() {
+    process.on('SIGUSR2', handleSignal)
+  },
+  onStop() {
+    process.removeListener('SIGUSR2', handleSignal)
+  }
+})
+
+async function handleSignal() {
+  const promises = Array.from(clients).map(async client => {
+    client.write('event: reload\ndata:\n\n');
+    return new Promise(resolve => client.end(resolve));
+  });
+  await Promise.all(promises);
+  process.exit(0);
+};
+
+const reloadJs = `
+  const eventSource = new EventSource('/_events');
+let reload = false;
+eventSource.addEventListener('connected', () => {
+  if (reload) {
+    console.log('%c NOXT ','color: #ffd; background-color: #080', 'Reloading...' );
+    window.location.reload();
+  } else {
+    console.log('%c NOXT ', 'color: #ffd; background-color: #080', 'Connected.' );
+  }
+
+});
+eventSource.addEventListener('reload', () => {
+  console.log('%c NOXT ','color: #ffd; background-color: #080', 'Restarting...' );
+  reload = true;
+});
+window.addEventListener('beforeunload', () => {
+  eventSource.close();
+});
+`

package/units/services.js

@@ -0,0 +1,21 @@
+export const info = {
+  name: 'services',
+  version: '1.0.0',
+  description: 'Services',
+  requires: ['utils']
+}
+
+const services = {}
+
+export default mlm => ({
+  'define.services': () => mlm.utils.readOnly(services, 'services'),
+  'register.services': mlm.utils.collector(services, {
+    is: 'function',
+    mode: 'object',
+    map: (fn, key) => {
+      const service = fn(mlm)
+      mlm.assert.is.object(service, 'service');
+      return service
+    }
+  }),
+})

package/units/static.js

@@ -0,0 +1,21 @@
+export const info = {
+  name: 'static',
+  description: 'Static middleware',
+  requires: ['express'],
+  npm: {
+    'serve-static': '^1.15.0'
+  },
+}
+
+export default mlm => ({
+  'config.static': {
+    is: 'string',
+    default: 'public'
+  },
+  'middleware.static': async (app) => {
+     const { default: serve_static } = await mlm.import('serve-static');
+     const { resolve } = await mlm.import('path');
+     const dir = mlm.config.static;
+     return serve_static(resolve(dir));
+  },
+})

package/units/utils.js

@@ -0,0 +1,78 @@
+export const info = {
+  name: 'utils',
+  version: '1.0.0',
+  description: 'Utils',
+  //requires: ['env']
+}
+export default mlm => {
+
+  const utils = {};
+  utils.eval = (fn,...args) => typeof fn === 'function' ? fn(...args) : fn;
+  utils.readOnly = (obj, { label = 'object' } = {}) => new Proxy(obj, {
+    get: (t, k) => t[k],
+    set: (t, k, v) => { mlm.throw(label + ' is read-only'); }
+  });
+  utils.collector = (target, { 
+    map, is, filter, 
+    label = 'object', 
+    mode = 'object', 
+    override = false 
+  } = {}) => {
+    const modes = {
+      array: () => source => {
+        for (let value of source) {
+          if (filter && !filter(value)) continue;
+          if (is) mlm.assert.is(is, value, label);
+          if (map) value = map(value);
+          target.push(value);
+        }
+      },
+      object: () => source => {
+        for (const key in source) {
+          if (!override && key in target) {
+            mlm.throw('Duplicate key' + key + ' in ' + label);
+          }
+          let value = source[key];
+          if (filter && !filter(value, key)) continue;
+          if (is) mlm.assert.is( is,value, label + '.' + key);
+          if (map) value = map(value, key);
+          target[key] = value;
+        }
+      },
+      arrays: () => source => {
+        for (const key in source) {
+          let values = [source[key]].flat(Infinity);
+          target[key] ??= [];
+          for (let value of values) {
+            if (filter && !filter(value, key)) continue;
+            if (is) mlm.assert.is(is, value, label + '.' + key);
+            if (map) value = map(value, key);
+            target[key].push(value);
+          }
+        }
+      },
+      directory: () => source => {
+        for (const key in source) {
+          let values = source[key];
+          target[key] ??= {};
+          for (const id in values) {
+            if (!override && id in target[key]) {
+              mlm.throw('Duplicate key' + id + ' in ' + label + '.' + key);
+            }
+            let value = values[id];
+            if (filter && !filter(value, key)) continue;
+            if (is) mlm.assert.is(is, value, label + '.' + key);
+            if (map) value = map(value, key);
+            target[key][id] = value;
+          }
+        }
+      }
+    }
+    mlm.assert(mode in modes, 'Unknown mode ' + mode);
+    return modes[mode]();
+  }
+  return ({
+    'define.utils': () => utils.readOnly(utils, 'utils'),
+    'register.utils': utils.collector(utils, { is: 'function', mode: 'object' }),
+  })
+}

package/config.js

@@ -1,82 +0,0 @@
-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) {
-      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/index.js

@@ -1,89 +0,0 @@
-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)) {
-    console.log(`Importing context module: ${mod}`);
-    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/reload_client.js

@@ -1,15 +0,0 @@
-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

@@ -1,43 +0,0 @@
-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);
-});