kempo-server 2.2.0 → 3.0.1

package/src/router.js

@@ -17,6 +17,7 @@ import {
   loggingMiddleware 
 } from './builtinMiddleware.js';
 import { onRescan } from './rescan.js';
+import { renderDir } from './templating/index.js';
 
 export default async (flags, log) => {
   log('Initializing router', 3);
@@ -25,8 +26,7 @@ export default async (flags, log) => {
   
   let config = defaultConfig;
   try {
-    // Use the provided config path or fallback to .config.json in rootPath
-    const configFileName = flags.config || '.config.json';
+    const configFileName = flags.config || '.config.js';
     const configPath = path.isAbsolute(configFileName) 
       ? configFileName 
       : path.join(rootPath, configFileName);
@@ -50,12 +50,19 @@ export default async (flags, log) => {
     }
     
     log(`Loading config from: ${configPath}`, 3);
-    const configContent = await readFile(configPath, 'utf8');
-    const userConfig = JSON.parse(configContent);
+    let userConfig;
+    if(configPath.endsWith('.js')){
+      const configUrl = pathToFileURL(configPath).href + `?t=${Date.now()}`;
+      const configModule = await import(configUrl);
+      userConfig = configModule.default;
+    } else {
+      const configContent = await readFile(configPath, 'utf8');
+      userConfig = JSON.parse(configContent);
+    }
+    if(!userConfig) throw new Error('Config file is empty or has no default export');
     config = {
       ...defaultConfig,
       ...userConfig,
-      // Deep merge nested objects
       allowedMimes: {
         ...defaultConfig.allowedMimes,
         ...(userConfig.allowedMimes || {})
@@ -71,16 +78,59 @@ export default async (flags, log) => {
       cache: {
         ...defaultConfig.cache,
         ...(userConfig.cache || {})
+      },
+      templating: {
+        ...defaultConfig.templating,
+        ...(userConfig.templating || {})
       }
     };
     log('User config loaded and merged with defaults', 3);
   } catch (e){
-    // Only fall back to default config for file reading/parsing errors
-    // Let validation errors propagate up
     if (e.message.includes('Config file must be within the server root directory')) {
       throw e;
     }
-    log('Using default config (no config file found)', 3);
+    // If .config.js failed, try .config.json fallback
+    const configFileName = flags.config || '.config.js';
+    if(configFileName.endsWith('.js')){
+      try {
+        const jsonFallback = configFileName.replace(/\.js$/, '.json');
+        const jsonPath = path.isAbsolute(jsonFallback) 
+          ? jsonFallback 
+          : path.join(rootPath, jsonFallback);
+        log(`Trying JSON fallback: ${jsonPath}`, 3);
+        const configContent = await readFile(jsonPath, 'utf8');
+        const userConfig = JSON.parse(configContent);
+        config = {
+          ...defaultConfig,
+          ...userConfig,
+          allowedMimes: {
+            ...defaultConfig.allowedMimes,
+            ...(userConfig.allowedMimes || {})
+          },
+          middleware: {
+            ...defaultConfig.middleware,
+            ...(userConfig.middleware || {})
+          },
+          customRoutes: {
+            ...defaultConfig.customRoutes,
+            ...(userConfig.customRoutes || {})
+          },
+          cache: {
+            ...defaultConfig.cache,
+            ...(userConfig.cache || {})
+          },
+          templating: {
+            ...defaultConfig.templating,
+            ...(userConfig.templating || {})
+          }
+        };
+        log('User config loaded from JSON fallback', 3);
+      } catch(e2){
+        log('Using default config (no config file found)', 3);
+      }
+    } else {
+      log('Using default config (no config file found)', 3);
+    }
   }
   
   /*
@@ -88,11 +138,18 @@ export default async (flags, log) => {
   */
   const dis = new Set(config.disallowedRegex);
   dis.add("^/\\..*");
-  dis.add("\\.config$");
+  dis.add("\\.config\\.js$");
+  dis.add("\\.config\\.json$");
   dis.add("\\.git/"); 
   config.disallowedRegex = [...dis];
   log(`Config loaded with ${config.disallowedRegex.length} disallowed patterns`, 3);
   
+  if(config.templating.preRender){
+    const {globals, state, maxFragmentDepth} = config.templating;
+    const count = await renderDir(rootPath, rootPath, globals, state, maxFragmentDepth);
+    log(`Pre-rendered ${count} page(s)`, 2);
+  }
+
   let files = await getFiles(rootPath, config, log);
   log(`Initial scan found ${files.length} files`, 2);
 
@@ -194,9 +251,11 @@ export default async (flags, log) => {
   
   // Helper function to match wildcard patterns
   const matchWildcardRoute = (requestPath, pattern) => {
+    // Normalize pattern to ensure leading slash
+    const normalizedPattern = pattern.startsWith('/') ? pattern : '/' + pattern;
     // Convert wildcard pattern to regex
     // IMPORTANT: Replace ** BEFORE * to avoid replacing both * in **
-    const regexPattern = pattern
+    const regexPattern = normalizedPattern
       .replace(/\*\*/g, '(.+)')     // Replace ** with capture group for multiple segments
       .replace(/\*/g, '([^/]+)');   // Replace * with capture group for single segment
     

package/src/serveFile.js

@@ -4,12 +4,39 @@ import { pathToFileURL } from 'url';
 import findFile from './findFile.js';
 import createRequestWrapper, { readRawBody, parseBody } from './requestWrapper.js';
 import createResponseWrapper from './responseWrapper.js';
+import { renderPage } from './templating/index.js';
+
+const trySSR = async (rootPath, requestPath, config, res, log) => {
+  const htmlPath = requestPath.endsWith('/') ? requestPath + 'index' : requestPath;
+  const pagePath = path.join(rootPath, htmlPath.replace(/\.html$/, '') + '.page.html');
+  try {
+    await stat(pagePath);
+    const {globals, state, maxFragmentDepth} = config.templating;
+    const html = await renderPage(pagePath, rootPath, globals, state, maxFragmentDepth);
+    res.writeHead(200, {'Content-Type': 'text/html; charset=utf-8'});
+    res.end(html);
+    log(`SSR rendered: ${pagePath}`, 2);
+    return true;
+  } catch(e){
+    log(`SSR error for ${requestPath}: ${e.message}`, 3);
+    return false;
+  }
+};
 
 export default async (files, rootPath, requestPath, method, config, req, res, log, moduleCache = null) => {
   log(`Attempting to serve: ${requestPath}`, 3);
+
+  if(config.templating?.ssr && config.templating?.ssrPriority){
+    if(await trySSR(rootPath, requestPath, config, res, log)) return true;
+  }
+
   const [file, params] = await findFile(files, rootPath, requestPath, method, log);
   
   if (!file) {
+    if(config.templating?.ssr){
+      if(await trySSR(rootPath, requestPath, config, res, log)) return true;
+      log(`SSR fallback not available for: ${requestPath}`, 3);
+    }
     log(`No file found for: ${requestPath}`, 3);
     return false; // Could not find file
   }

package/src/templating/index.js

@@ -0,0 +1,132 @@
+import { readFile, writeFile, mkdir, readdir } from 'fs/promises';
+import path from 'path';
+import {
+  extractAttrs,
+  extractContentBlocks,
+  replaceLocations,
+  resolveVars,
+  resolveIfs,
+  resolveForeach,
+  resolveFragmentTags
+} from './parse.js';
+import { readFileSync, statSync } from 'fs';
+
+/*
+  Synchronous File Lookup — walk up from startDir to rootDir
+*/
+const findFileUpSync = (filename, startDir, rootDir) => {
+  let dir = startDir;
+  const root = path.resolve(rootDir);
+  while(true){
+    const candidate = path.join(dir, filename);
+    try {
+      statSync(candidate);
+      return candidate;
+    } catch(e){ /* not found */ }
+    if(path.resolve(dir) === root) return null;
+    const parent = path.dirname(dir);
+    if(parent === dir) return null;
+    dir = parent;
+  }
+};
+
+const loadVersion = rootDir => {
+  try {
+    return JSON.parse(readFileSync(path.join(rootDir, 'package.json'), 'utf8')).version || '';
+  } catch(e){
+    return '';
+  }
+};
+
+/*
+  Render a Single Page
+*/
+const renderPage = async (pageFilePath, rootDir, globals = {}, state = {}, maxDepth = 10) => {
+  const pageContent = await readFile(pageFilePath, 'utf8');
+  const pageTagMatch = pageContent.match(/^[\s\S]*?<page\s([^>]*)>/);
+  if(!pageTagMatch) throw new Error(`Invalid page file: missing <page> root element in ${pageFilePath}`);
+  const pageAttrs = extractAttrs(pageTagMatch[1]);
+  const templateName = pageAttrs.template || 'default';
+  delete pageAttrs.template;
+
+  const contentBlocks = extractContentBlocks(pageContent);
+  const pageDir = path.dirname(pageFilePath);
+  const templateFile = findFileUpSync(`${templateName}.template.html`, pageDir, rootDir);
+  if(!templateFile) throw new Error(`Template not found: ${templateName}.template.html (searched from ${pageDir} to ${rootDir})`);
+
+  let templateHtml = readFileSync(templateFile, 'utf8');
+
+  const findFragmentFile = name => {
+    const filePath = findFileUpSync(name + '.fragment.html', pageDir, rootDir);
+    if(!filePath) return null;
+    return readFileSync(filePath, 'utf8');
+  };
+
+  templateHtml = resolveFragmentTags(templateHtml, findFragmentFile, 0, maxDepth);
+  templateHtml = replaceLocations(templateHtml, contentBlocks);
+
+  const rel = path.relative(rootDir, path.dirname(pageFilePath));
+  const depth = rel ? rel.split(path.sep).length : 0;
+  const now = new Date();
+
+  const vars = {
+    pathToRoot: depth > 0 ? '../'.repeat(depth) : './',
+    year: String(now.getFullYear()),
+    date: now.toISOString().slice(0, 10),
+    datetime: now.toISOString(),
+    timestamp: String(Date.now()),
+    version: loadVersion(rootDir),
+    env: process.env.NODE_ENV || '',
+    ...globals,
+    ...state,
+    ...pageAttrs
+  };
+
+  // Call function values in globals/state to resolve them
+  for(const [key, val] of Object.entries(vars)){
+    if(typeof val === 'function') vars[key] = val();
+  }
+
+  templateHtml = resolveIfs(templateHtml, vars);
+  templateHtml = resolveForeach(templateHtml, vars);
+  templateHtml = resolveVars(templateHtml, vars);
+
+  return templateHtml;
+};
+
+/*
+  Recursively Walk Directory for *.page.html
+*/
+const walkPages = async dir => {
+  const entries = await readdir(dir, {withFileTypes: true});
+  const results = [];
+  for(const entry of entries){
+    const full = path.join(dir, entry.name);
+    if(entry.isDirectory()){
+      results.push(...await walkPages(full));
+    } else if(entry.name.endsWith('.page.html')){
+      results.push(full);
+    }
+  }
+  return results;
+};
+
+/*
+  Render All Pages in a Directory
+*/
+const renderDir = async (inputDir, outputDir, globals = {}, state = {}, maxDepth = 10) => {
+  const pages = await walkPages(inputDir);
+  let count = 0;
+  for(const page of pages){
+    const rel = path.relative(inputDir, page);
+    const outRel = rel.replace(/\.page\.html$/, '.html');
+    const outPath = path.join(outputDir, outRel);
+    await mkdir(path.dirname(outPath), {recursive: true});
+    const html = await renderPage(page, inputDir, globals, state, maxDepth);
+    await writeFile(outPath, html, 'utf8');
+    count++;
+  }
+  return count;
+};
+
+export { renderPage, renderDir };

package/src/templating/parse.js

@@ -0,0 +1,285 @@
+/*
+  Attribute Extraction
+*/
+const extractAttrs = tagString => {
+  const attrs = {};
+  const re = /(\w[\w-]*)=(?:"([^"]*)"|'([^']*)')/g;
+  let match;
+  while((match = re.exec(tagString)) !== null){
+    attrs[match[1]] = match[2] ?? match[3];
+  }
+  return attrs;
+};
+
+/*
+  Content Block Extraction
+*/
+const extractContentBlocks = xml => {
+  const blocks = {};
+  const re = /<content(?:\s+location="([^"]*)")?\s*>([\s\S]*?)<\/content>/g;
+  let match;
+  while((match = re.exec(xml)) !== null){
+    const name = match[1] || 'default';
+    blocks[name] = (blocks[name] || '') + match[2];
+  }
+  return blocks;
+};
+
+/*
+  Location Replacement
+*/
+const replaceLocations = (html, contentMap) =>
+  html
+    .replace(/<location(?:\s+name="([^"]*)")?>([\s\S]*?)<\/location>/g, (_, name, fallback) =>
+      contentMap[name || 'default'] ?? fallback
+    )
+    .replace(/<location(?:\s+name="([^"]*)")?\s*\/>/g, (_, name) =>
+      contentMap[name || 'default'] ?? ''
+    );
+
+/*
+  Fragment Wrapper Stripping
+*/
+const stripFragmentWrapper = xml => {
+  const match = xml.match(/^\s*<fragment\b[^>]*>([\s\S]*)<\/fragment>\s*$/);
+  return match ? match[1] : xml;
+};
+
+/*
+  Dot-Path Resolution
+*/
+const resolvePath = (obj, dotPath) =>
+  dotPath.split('.').reduce((cur, key) => cur?.[key], obj);
+
+/*
+  Variable Resolution
+*/
+const resolveVars = (html, vars) =>
+  html.replace(/\{\{([^}]+)\}\}/g, (_, key) => {
+    const trimmed = key.trim();
+    const val = resolvePath(vars, trimmed);
+    if(typeof val === 'function') return val();
+    return val ?? '';
+  });
+
+/*
+  If-Block Resolution
+*/
+const resolveIfs = (html, vars) => {
+  const re = /<if\s+condition="([^"]+)">([\s\S]*?)<\/if>/g;
+  let result = html;
+  let prev;
+  do {
+    prev = result;
+    result = result.replace(re, (_, condition, inner) =>
+      evalCondition(condition, vars) ? inner : ''
+    );
+  } while(result !== prev);
+  return result;
+};
+
+/*
+  Foreach-Block Resolution
+*/
+const resolveForeach = (html, vars) => {
+  const re = /<foreach\s+in="([^"]+)"\s+as="([^"]+)">([\s\S]*?)<\/foreach>/g;
+  let result = html;
+  let prev;
+  do {
+    prev = result;
+    result = result.replace(re, (_, inAttr, asAttr, inner) => {
+      const arr = resolvePath(vars, inAttr.trim());
+      if(!Array.isArray(arr)) return '';
+      return arr.map(item => {
+        const scopedVars = {...vars, [asAttr]: item};
+        return resolveVars(inner, scopedVars);
+      }).join('');
+    });
+  } while(result !== prev);
+  return result;
+};
+
+/*
+  Fragment Tag Resolution
+*/
+const resolveFragmentTags = (html, findFragmentFile, depth, maxDepth) => {
+  if(depth > maxDepth) throw new Error(`Fragment depth exceeded maximum of ${maxDepth}`);
+  const re = /<fragment\s+name="([^"]+)"(?:\s*\/>|>([\s\S]*?)<\/fragment>)/g;
+  return html.replace(re, (_, name, fallback) => {
+    const content = findFragmentFile(name);
+    if(content === null) return fallback ?? '';
+    const stripped = stripFragmentWrapper(content);
+    return resolveFragmentTags(stripped, findFragmentFile, depth + 1, maxDepth);
+  });
+};
+
+/*
+  Condition Evaluator — Mini Expression Parser
+*/
+const TOKEN_TYPES = {
+  NUMBER: 'NUMBER',
+  STRING: 'STRING',
+  BOOLEAN: 'BOOLEAN',
+  IDENTIFIER: 'IDENTIFIER',
+  OPERATOR: 'OPERATOR',
+  NOT: 'NOT',
+  LPAREN: 'LPAREN',
+  RPAREN: 'RPAREN'
+};
+
+const tokenize = expr => {
+  const tokens = [];
+  let i = 0;
+  while(i < expr.length){
+    if(/\s/.test(expr[i])){
+      i++;
+      continue;
+    }
+    if(expr[i] === '('){
+      tokens.push({type: TOKEN_TYPES.LPAREN});
+      i++;
+      continue;
+    }
+    if(expr[i] === ')'){
+      tokens.push({type: TOKEN_TYPES.RPAREN});
+      i++;
+      continue;
+    }
+    if(expr[i] === '!' && expr[i + 1] !== '='){
+      tokens.push({type: TOKEN_TYPES.NOT});
+      i++;
+      continue;
+    }
+    const opMatch = expr.slice(i).match(/^(===|!==|>=|<=|&&|\|\||>|<)/);
+    if(opMatch){
+      tokens.push({type: TOKEN_TYPES.OPERATOR, value: opMatch[1]});
+      i += opMatch[1].length;
+      continue;
+    }
+    if(expr[i] === '"' || expr[i] === "'"){
+      const quote = expr[i];
+      let str = '';
+      i++;
+      while(i < expr.length && expr[i] !== quote){
+        str += expr[i];
+        i++;
+      }
+      if(i >= expr.length) throw new Error(`Unterminated string in condition: ${expr}`);
+      i++;
+      tokens.push({type: TOKEN_TYPES.STRING, value: str});
+      continue;
+    }
+    const numMatch = expr.slice(i).match(/^(\d+(\.\d+)?)/);
+    if(numMatch){
+      tokens.push({type: TOKEN_TYPES.NUMBER, value: Number(numMatch[1])});
+      i += numMatch[1].length;
+      continue;
+    }
+    const idMatch = expr.slice(i).match(/^([a-zA-Z_$][\w$.]*)/);
+    if(idMatch){
+      const id = idMatch[1];
+      if(id === 'true' || id === 'false'){
+        tokens.push({type: TOKEN_TYPES.BOOLEAN, value: id === 'true'});
+      } else {
+        tokens.push({type: TOKEN_TYPES.IDENTIFIER, value: id});
+      }
+      i += id.length;
+      continue;
+    }
+    throw new Error(`Unexpected character '${expr[i]}' in condition: ${expr}`);
+  }
+  return tokens;
+};
+
+const parse = (tokens, vars) => {
+  let pos = 0;
+
+  const peek = () => tokens[pos];
+  const advance = () => tokens[pos++];
+
+  const parsePrimary = () => {
+    const tok = peek();
+    if(!tok) throw new Error('Unexpected end of expression');
+    if(tok.type === TOKEN_TYPES.NOT){
+      advance();
+      return !parsePrimary();
+    }
+    if(tok.type === TOKEN_TYPES.LPAREN){
+      advance();
+      const val = parseOr();
+      if(!peek() || peek().type !== TOKEN_TYPES.RPAREN){
+        throw new Error('Missing closing parenthesis');
+      }
+      advance();
+      return val;
+    }
+    if(tok.type === TOKEN_TYPES.NUMBER || tok.type === TOKEN_TYPES.STRING || tok.type === TOKEN_TYPES.BOOLEAN){
+      advance();
+      return tok.value;
+    }
+    if(tok.type === TOKEN_TYPES.IDENTIFIER){
+      advance();
+      return resolvePath(vars, tok.value);
+    }
+    throw new Error(`Unexpected token: ${JSON.stringify(tok)}`);
+  };
+
+  const parseComparison = () => {
+    let left = parsePrimary();
+    while(peek() && peek().type === TOKEN_TYPES.OPERATOR && ['===', '!==', '>', '<', '>=', '<='].includes(peek().value)){
+      const op = advance().value;
+      const right = parsePrimary();
+      switch(op){
+        case '===': left = left === right; break;
+        case '!==': left = left !== right; break;
+        case '>': left = left > right; break;
+        case '<': left = left < right; break;
+        case '>=': left = left >= right; break;
+        case '<=': left = left <= right; break;
+      }
+    }
+    return left;
+  };
+
+  const parseAnd = () => {
+    let left = parseComparison();
+    while(peek() && peek().type === TOKEN_TYPES.OPERATOR && peek().value === '&&'){
+      advance();
+      const right = parseComparison();
+      left = left && right;
+    }
+    return left;
+  };
+
+  const parseOr = () => {
+    let left = parseAnd();
+    while(peek() && peek().type === TOKEN_TYPES.OPERATOR && peek().value === '||'){
+      advance();
+      const right = parseAnd();
+      left = left || right;
+    }
+    return left;
+  };
+
+  const result = parseOr();
+  if(pos < tokens.length) throw new Error(`Unexpected token after expression: ${JSON.stringify(tokens[pos])}`);
+  return result;
+};
+
+const evalCondition = (expression, vars) => {
+  const tokens = tokenize(expression);
+  return !!parse(tokens, vars);
+};
+
+export {
+  extractAttrs,
+  extractContentBlocks,
+  replaceLocations,
+  stripFragmentWrapper,
+  resolveVars,
+  resolveIfs,
+  resolveForeach,
+  resolveFragmentTags,
+  evalCondition,
+  resolvePath
+};

package/tests/cacheConfig.node-test.js

@@ -9,8 +9,8 @@ const createTempConfig = async (config) => {
   const tempDir = path.join(process.cwd(), 'tests', 'temp-config-test');
   await mkdir(tempDir, { recursive: true });
   
-  const configPath = path.join(tempDir, 'test.config.json');
-  await writeFile(configPath, JSON.stringify(config, null, 2));
+  const configPath = path.join(tempDir, 'test.config.js');
+  await writeFile(configPath, `export default ${JSON.stringify(config, null, 2)}`);
   
   return { tempDir, configPath };
 };