@cilix/lightjs 0.0.1

package/index.js

@@ -0,0 +1,364 @@
+/*
+ * Copyright 2023 Matthew Levenstein
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining
+ * a copy of this software and associated documentation files (the “Software”),
+ * to deal in the Software without restriction, including without limitation
+ * the rights to use, copy, modify, merge, publish, distribute, sublicense,
+ * and/or sell copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
+ * INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+ * PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+ * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+ * USE OR OTHER DEALINGS IN THE SOFTWARE.
+*/
+const fs = require('fs');
+const path = require('path');
+const qs = require('querystring');
+const url = require('url');
+const mimedb = require('mime-db');
+const esbuild = require('esbuild');
+const core = require('./core.js');
+
+const Light = {};
+const ssrCache = {};
+const mimeTypes = {};
+
+const getPathInfo = (p, base) => {
+  const full = base ? path.resolve(base, p) : path.resolve(process.cwd(), p);
+  const parent = path.dirname(full);
+  const file = path.basename(full);
+  return { full, parent, file };
+};
+
+const addParentPaths = (code, p) => {
+  const len = code.length;
+  let out = '';
+  for (let i = 0; i < len; i++) {
+    if (code.slice(i, i+10) === 'require(".') {
+      let f = '';
+      i += 9;
+      while (code[i] !== '"') f += code[i++];
+      out += `require("${path.resolve(p, f)}"`;
+    } else {
+      out += code[i];
+    }
+  }
+  return out;
+};
+
+const esbuild_to_light_error = (e, chunk) => {
+  let row = e.location.line - 1;
+  let col = e.location.column;
+  let pos;
+
+  for (pos = 0; pos < chunk.code.length; pos++) {
+    if (chunk.code[pos] === '\n') row--;
+    if (row == 0) {
+      if (col > 0) col--;
+      else break;
+    }
+  }
+
+  return {
+    origin: 'light',
+    msg: e.text,
+    pos: chunk.pos + 3 + pos + 1,
+    file: chunk.file
+  };
+};
+
+Light.compile = async (name, opts) => {
+  if (name && typeof name === 'object') {
+    opts = name;
+  }
+  if (!opts) opts = {};
+  if (typeof name === 'string') {
+    opts.input = name;
+  }
+  const pathInfo = getPathInfo(opts.input);
+  const parentDir = pathInfo.parent;
+  const light = core({
+    jsTransform: async (chunk) => {
+      try {
+        const opts = { format: 'cjs', loader: 'ts' };
+        const result = await esbuild.transform(chunk.code, opts);
+        return addParentPaths(result.code, chunk.parent_dir);
+      } catch (e) {
+        e.origin = 'esbuild';
+        e.chunk = chunk;
+        throw e;
+      }
+    },
+    jsPostProcess: async (js) => {
+      const result = await esbuild.build({
+        stdin: {
+          contents: js,
+          resolveDir: parentDir
+        },
+        bundle: true,
+        minify: opts.minify,
+        write: false
+      });
+      return result.outputFiles[0].text;
+    }
+  });
+  try {
+    let html;
+    if (opts.cache) {
+      const cacheDir = opts.cacheDir || parentDir;
+      const cachePath = path.resolve(cacheDir, pathInfo.file + '.json');
+      if (ssrCache[cachePath]) {
+        html = light.renderToHTML(ssrCache[cachePath], opts.data, opts.flush);
+      /*
+      } else if (fs.existsSync(cachePath)) {
+        const cache = fs.readFileSync(cachePath, 'utf-8');
+        html = await light.renderToHTML(cache, opts.data);
+      */
+      } else {
+        const cache = await light.renderToCache(opts.input, opts.actions);
+        // fs.writeFileSync(cachePath, cache);
+        ssrCache[cachePath] = cache;
+        html = light.renderToHTML(cache, opts.data, opts.flush);
+      }
+    } else {
+      html = await light.render(opts.input, opts.data, opts.flush, opts.actions);
+    }
+    if (!opts.output) {
+      return html;
+    } else {
+      fs.writeFileSync(opts.output, html);
+    }
+  } catch (e) {
+    let msg;
+    if (e.origin === 'esbuild') {
+      if (e.chunk) {
+        e = esbuild_to_light_error(e.errors[0], e.chunk);
+      }
+    }
+    if (e.origin === 'light') {
+      msg = `<pre>${light.printError(e)}</pre>`;
+    } else {
+      console.log(e);
+      msg = `<pre>${e.message}</pre>`;
+    }
+    if (!opts.output) return msg;
+    else {
+      fs.writeFileSync(opts.output, msg);
+    }
+  }
+};
+
+const serveStaticFile = (p, res) => {
+  let ext = path.extname(p);
+  if (!ext)
+    return false;
+  ext = ext.slice(1);
+  try {
+    if (p.indexOf('..') !== -1) {
+      res.statusCode = 403;
+      res.end();
+      return true;
+    }
+    const data = fs.readFileSync(p);
+    const mime = (mimeTypes[ext] || { source: 'text/plain' }).source;
+    res.writeHead(200, { 'Content-type': `${mime}` });
+    res.end(data);
+    return true;
+  } catch (e) {
+    return false;
+  }
+};
+
+const parseBody = (req, max) => {
+  return new Promise((resolve, reject) => {
+    let buf = '';
+    let data;
+    req.on('data', (chunk) => {
+      if (buf.length > max) {
+        reject('Maximum body size exceeeded');
+      } else {
+        buf += chunk;
+      }
+    });
+    req.on('end', () => {
+      if (buf.length === 0) {
+        resolve({});
+        return;
+      }
+      try {
+        data = JSON.parse(buf);
+      } catch (e) {
+        try {
+          data = qs.parse(buf);
+        } catch (e) {
+          reject('Invalid request body format');
+        }
+      }
+      resolve(data);
+    })
+    req.on('error', (e) => {
+      reject(e);
+    });
+  });
+};
+
+const parseQuery = (p) => {
+  const purl = url.parse(p);
+  if (purl.query) {
+    return qs.parse(purl.query);
+  }
+  return {};
+};
+
+function matchRoute (istr, mstr) {
+  if (mstr === '*') return {};
+  const p0 = istr.split('/').filter(p => p);
+  const p1 = mstr.split('/').filter(p => p);
+  const out = {};
+  if (p0.length > p1.length && p1.length > 0) {
+    const last = p1[p1.length - 1];
+    if (last[last.length - 1] !== '*') {
+      return null;
+    }
+  } else if (p0.length !== p1.length) return null;
+  for (let i = 0; i < p1.length; i++) {
+    const p = p1[i];
+    if (p[0] !== ':') {
+      if (p !== p0[i]) return null;
+      else continue;
+    }
+    if (i === p1.length - 1 && p[p.length - 1] === '*') {
+      out[p.slice(1, -1)] = p0[i];
+      for (let j = i + 1; j < p0.length; j++) {
+        out[p.slice(1, -1)] += `/${p0[j]}`;
+      }
+    } else {
+      out[p.slice(1)] = p0[i];
+    }
+  }
+  return out;
+}
+
+function handleAction (req, res, actions) {
+  if (req.method === 'POST') {
+    if (req.body.type === 'LIGHT_SERVER_FUNCTION') {
+      const name = req.body.name;
+      const args = req.body.args;
+      if (actions[name]) {
+        actions[name].apply(undefined, args).then((data) => {
+          res.writeHead(200, { 'Content-type': 'application/json; charset=utf-8' });
+          if (!data) data = null;
+          res.end(JSON.stringify(data));
+        }).catch((e) => {
+          console.error(e);
+          res.writeHead(500, { 'Content-type': 'application/json; charset=utf-8' });
+          res.end(JSON.stringify({ message: `Server error when calling ${name}` }));
+        });
+      } else {
+        res.writeHead(500, { 'Content-type': 'application/json; charset=utf-8' });
+        res.end(JSON.stringify({ message: `${name} is not defined on the server` }));
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
+Light.router = function (opts) {
+  if (!opts) opts = {};
+  const routes = opts.routes || {};
+  const cache = opts.cache || false;
+  const minify = opts.minify || false;
+  const actions = opts.actions || {};
+  const publicDir = opts.publicDir;
+  for (let type in mimedb) {
+    if (mimedb[type].extensions) {
+      for (let ext of mimedb[type].extensions) {
+        mimeTypes[ext] = type;
+      }
+    }
+  }
+  return async function (req, res, next) {
+    const url = req.url;
+    if (publicDir && serveStaticFile(path.join(publicDir, url), res)) {
+      return;
+    }
+    const query = parseQuery(url);
+    req.query = query;
+    try {
+      req.body = await parseBody(req, 1024 * 1024); // 1MB limit
+    } catch (e) {
+      res.writeHead(400, { 'Content-type': 'application/json; charset=utf-8' });
+      res.end(JSON.stringify({ error: e.message }));
+      return;
+    }
+    if (handleAction(req, res, actions)) {
+      return;
+    }
+    let matchedRoute = null;
+    let routeParams = {};
+    let routeConfig = null;
+    for (const [pattern, config] of Object.entries(routes)) {
+      const params = matchRoute(url, pattern);
+      if (params !== null) {
+        matchedRoute = pattern;
+        routeParams = params;
+        routeConfig = config;
+        break;
+      }
+    }
+    if (!matchedRoute) {
+      if (next) {
+        next();
+      } else {
+        res.writeHead(404, { 'Content-type': 'text/html; charset=utf-8' });
+        res.end('<h1>404 - Not Found</h1>');
+        return;
+      }
+    }
+    req.params = routeParams;
+    try {
+      let html;
+      if (typeof routeConfig === 'string') {
+        html = await Light.compile({
+          input: routeConfig,
+          cache: cache,
+          minify: minify,
+          actions: Object.keys(actions)
+        });
+      } else if (typeof routeConfig === 'object') {
+        const compileOpts = {
+          input: routeConfig.input,
+          flush: routeConfig.stream ? res.write.bind(res) : undefined,
+          cache: cache,
+          minify: minify,
+          actions: Object.keys(actions)
+        };
+        if (routeConfig.data) {
+          if (typeof routeConfig.data === 'function') {
+            compileOpts.data = await routeConfig.data(req, routeParams);
+          } else {
+            compileOpts.data = routeConfig.data;
+          }
+        }
+        html = await Light.compile(compileOpts);
+      }
+      res.writeHead(200, { 'Content-type': 'text/html; charset=utf-8' });
+      res.end(html);
+    } catch (e) {
+      console.error('Route error:', e);
+      res.writeHead(500, { 'Content-type': 'text/html; charset=utf-8' });
+      res.end('<h1>500 - Internal Server Error</h1>');
+    }
+  };
+};
+
+module.exports = Light;
+

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@cilix/lightjs",
+  "version": "0.0.1",
+  "description": "A new kind of JavaScript framework",
+  "main": "index.js",
+  "scripts": {
+    "dev": "node cli dev -r *=test.light"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mllev/lightjs.git"
+  },
+  "author": "Matthew Levenstein",
+  "license": "MIT",
+  "bin": {
+    "lightjs": "./cli.js"
+  },
+  "bugs": {
+    "url": "https://github.com/mllev/lightjs/issues"
+  },
+  "homepage": "https://github.com/mllev/lightjs#readme",
+  "dependencies": {
+    "esbuild": "^0.25.0",
+    "mime-db": "^1.54.0"
+  }
+}