@makano/rew 1.4.1 → 1.4.2

package/lib/rew/functions/import.js

@@ -117,6 +117,7 @@ module.exports.imp = function (runPath, context) {
 			const pkg = getPackage(filename)(context, options);
 			exports = pkg._onImport ? pkg._onImport() : pkg;
 			if(options.useDefaultForPackages) exports = { default: exports };
+			// console.log(exports, options.useDefaultForPackages);
 		} else if (foundCache) {
 		} else if (type == REW_FILE_TYPE.TYPE || type == "coffee") {
 			exports = exec({});

package/lib/rew/modules/compiler.js

@@ -497,6 +497,7 @@ function compileRewStuff(content, options) {
 			straceLog('==> WARN: SLOWS DOWN COMPILATION');
 			let ind = i + n + 2;
 			let isAs = false;
+			let usedDefault = false;
 
 			let defaultName;
 			if (nextToken.type === 'STRING') {
@@ -514,7 +515,7 @@ function compileRewStuff(content, options) {
 					if(next?.token?.value == 'as'){
 						const ebraceOpen = gnextToken(next.token.ti, 1, tokens);
 						const ebraceClose = fnextToken(ebraceOpen.ti, tokens, 'OTHER', ')');
-						const exportsTokens = tokens.slice(ebraceOpen.ti+1, ebraceClose.ti);
+						const exportsTokens = tokens.slice(ebraceOpen.ti+1, ebraceClose?.ti);
 						exports = mapTokensToStrings(exportsTokens.filter(token => token.type !== 'WHITESPACE'));
 						lastindex = ebraceClose.ti;
 					} else lastindex = closingBraceToken.ti;
@@ -573,10 +574,12 @@ function compileRewStuff(content, options) {
 						if(useImp(nameToken, options)) updateAliases(aliases);
 						result += `{ default: ${defaultName}, ${exports} } ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken?.value || ''}`;
 						i = closingBraceToken.ti + 4;
+						usedDefault = true;
 					}
 				} else {
 					if(useImp(nameToken || {}, options)) updateAliases(aliases);
 					result += `{ default: ${defaultName} } ${options.type == 'coffee' ? '=' : ':='} inc ${nameToken?.value || ''}`;
+					usedDefault = true;
 					i = ind + 2;
 				}
 			}
@@ -590,14 +593,14 @@ function compileRewStuff(content, options) {
 				if(assertionToken.token.type == 'OTHER' && assertionToken.token.value == '{'){
 					hooks.push({
 						index: assertionToken.token.ti,
-						value: ' useDefaultForPackages: '+(isAs?'false':'true')+', '
+						value: ' useDefaultForPackages: '+(isAs?'false':usedDefault.toString())+', '
 					})
 				} else {
-					result += 'useDefaultForPackages: '+(isAs?'false':'true')+', '
+					result += 'useDefaultForPackages: '+(isAs?'false':usedDefault.toString())+', '
 				}
 				i += 3;
 			} else {
-				result += ", { useDefaultForPackages: "+(isAs?'false':'true')+" }"
+				result += ", { useDefaultForPackages: "+(isAs?'false':usedDefault.toString())+" }"
 			}
 
 			continue;
@@ -789,7 +792,7 @@ module.exports.compileFile = function (filepath, options = {}) {
 		f.content = from_qrew(readFileSync(f.path), options.package || findAppInfo(filepath)?.config.manifest.package || path.basename(filepath).split('.').slice(0, -1).join('.')).toString();
 		options.type = f.content.split('\n')[0]?.match(/"initFile (.+)"/)?.[1]?.split('.').pop();
 		straceLog('QREW_DECODE() as', options.type, 'for CURRENTFILE');
-	} 
+	}
 
 	let compiled_code =  cpl(f, { ...options });
 

package/lib/rew/modules/context.js

@@ -39,7 +39,10 @@ module.exports.prepareContext = function (
     app: findAppInfo(filepath),
     ...fsLib(filepath),
     ...reval(filepath),
-    __using__: {}
+    __using__: {},
+    get _(){
+      return void 0;
+    }
   };
   if (options.useContext) {
     context = {

package/lib/rew/pkgs/serve.app.js

@@ -0,0 +1,402 @@
+const { typex } = require("../const/default");
+const emitter = require("../functions/emitter");
+const path = require('path');
+
+module.exports = (context) => {
+  const svr = context.imp('serve');
+
+  let appOptions = {};
+
+  const mkRouter = (options = {}) => svr.prototype.router({ type: 'auto', ...appOptions, ...options });
+
+  class Events {
+    target = emitter();
+    on(...args){
+      this.target.on(...args);
+      return this;
+    }
+    off(...args){
+      this.target.off(...args);
+      return this;
+    }
+    emit(...args){
+      this.target.emit(...args);
+      return this;
+    }
+  }
+
+  const Context = (name, inherit = []) => {
+    const ctxC = class Context {
+
+      constructor(item){
+        this[name] = item;
+      }
+
+      on(evt, cb){
+        this[name].on(evt, cb);
+        return this;
+      }
+      
+      off(evt, cb){
+        this[name].off(evt, cb);
+        return this;
+      }
+      
+      emit(evt, ...data){
+        this[name].emit(evt, ...data);
+        return this;
+      }
+    };
+
+    inherit?.forEach(fname => {
+      ctxC.prototype[fname] = function(...args){
+        this[name][fname](...args);
+        return this;
+      }
+    });
+
+    return ctxC;
+  }
+
+  class AppContext extends Context('app', ['start', 'redirect']) {
+    inject(item){
+      this.app.inject(item);
+      return this;
+    }
+
+    module(...items){
+      return this.inject(...items);
+    }
+  }
+
+  class ServeApp extends Events {
+    #injectables = [];
+    server;
+    router;
+
+    constructor(options){
+      super();
+      appOptions = options;
+      this.router = mkRouter(options);
+      this.server = svr.prototype.create({
+        fetch: this.router.fetch
+      });
+    }
+
+    /** @param {Injectable[]} injectables */
+    inject(...injectables){
+      injectables.filter(i => i instanceof Injectable)
+      .forEach(injectable => {
+        this.#injectables.push(injectable);
+        injectable.emit('activate', this);
+        this.emit('activate', this);
+      });
+      return this;
+    }
+
+    redirect(at = '*', router){
+      this.router.all(at, typeof router == 'function' ? router : router.fetch);
+      return this;
+    }
+
+    new(options = {}){
+      return (cb) => new context.Usage('', () => {
+        const app = new ServeApp(options);
+        const appContext = new AppContext(app);
+        cb.call(appContext);
+        return app;
+      });
+    }
+
+    raw(){
+      return context.using(this.new(() => {}));
+    }
+
+    #setup(){
+      this.#injectables
+      .filter(injectable => injectable instanceof SModule)
+      .forEach(module => {
+        /** @type {SController[]} */
+        const controllers = module.getControllers();
+        controllers.forEach(controller => {
+          // console.log(path.join('/', controller.root, '*'), controller);
+          this.redirect(path.join('/', controller.root, '*'), controller.router);
+        })
+      });
+    }
+
+    start(port){
+      this.#setup();
+      this.server.port(port).listen;
+      this.emit('start', port);
+      return this;
+    }
+  }
+
+  class Injectable extends Events {
+    #injected = [];
+    forEachInjectable(cb, event, ...injectables){
+      injectables.filter(i => i instanceof Injectable)
+      .forEach(injectable => {
+        cb(injectable);
+        injectable.emit(event, this);
+        this.emit(event, this);
+      });
+      return this;
+    }
+    inject(...injectables){
+      return this.forEachInjectable(
+        (injectable) => this.#injected.push(injectable),
+        'activate',
+        ...injectables
+      );
+    }
+  }
+
+
+  class SModuleContext extends Context('module') {
+
+    provider(...provider){
+      this.module.addProvider(...provider);
+      return this;
+    }
+
+    controller(...controller){
+      this.module.addController(...controller);
+      return this;
+    }
+  }
+
+  class SModule extends Injectable {
+    #providers = [];
+    #controllers = [];
+    #app = {};
+
+    constructor(){
+      super();
+      this.on('activate', (app) => {
+        this.#app = app;
+        this.#controllers.concat(
+          this.#providers
+        ).forEach(injectable => injectable.emit('activate:app', app));
+      });
+    }
+
+    addProvider(...providers){
+      return this.forEachInjectable(
+        (injectable) => this.#providers.push(injectable),
+        'activate',
+        ...providers
+      );
+    }
+
+    hasProvider(provider){
+      return this.#providers.find(p => p == provider);
+    }
+
+    addController(...controllers){
+      return this.forEachInjectable(
+        (injectable) => this.#controllers.push(injectable),
+        'activate',
+        ...controllers
+      );
+    }
+
+    getControllers(){
+      return this.#controllers;
+    }
+
+    new(cb){
+      return new context.Usage('', () => {
+        const module = new SModule();
+        const moduleContext = new SModuleContext(module);
+        cb.call(moduleContext);
+        return module;
+      });
+    }
+  }
+
+  class SServiceContext extends Context('service') {
+    function(name){
+      return (cb) => {
+        this[name] = (...args) => cb.call(this, ...args);
+        this.service[name] = this[name];
+        return this[name];
+      }
+    }
+  }
+  class SProvider {
+    constructor(name, injectable){
+      this.name = name;
+      this.injectable = injectable;
+    }
+  }
+  class SService extends Injectable {
+    new(cb){
+      return new context.Usage('', () => {
+        const service = new SService();
+        const serviceContext = new SServiceContext(service);
+        cb.call(serviceContext);
+        return service;
+      });
+    }
+
+    as(name){
+      return new SProvider(name, this);
+    }
+  }
+
+  const ggreq = (that, method, _path, middleWare) => (cb) => {
+    cb.parent = that;
+    that.controller.register(method, _path, cb, middleWare);
+    return cb;
+  }
+  const mkReq = (usage) => (req, ctx) => usage.call(req, req, ctx);
+  class SControllerContext extends Context('controller') {
+
+    middleWares = [];
+
+    getMiddleWares(md){
+      return (...args) => {
+        this.middleWares.forEach(middleWare => {
+          mkReq(middleWare)(...args);
+        });
+        if(md){
+          mkReq(md)(...args);
+        }
+      }
+    }
+
+    withCookies(){
+      return svr.prototype.withCookies;
+    }
+    withContent(){
+      return svr.prototype.withContent;
+    }
+
+    get(_path, middleWare){
+      return ggreq(this, 'get', _path, this.getMiddleWares(middleWare));
+    } 
+    post(_path, middleWare){
+      return ggreq(this, 'post', _path, this.getMiddleWares(middleWare));
+    } 
+    delete(_path, middleWare){
+      return ggreq(this, 'delete', _path, this.getMiddleWares(middleWare));
+    } 
+    patch(_path, middleWare){
+      return ggreq(this, 'patch', _path, this.getMiddleWares(middleWare));
+    } 
+    put(_path, middleWare){
+      return ggreq(this, 'put', _path, this.getMiddleWares(middleWare));
+    }
+    all(_path, middleWare){
+      return ggreq(this, 'all', _path, this.getMiddleWares(middleWare));
+    }
+
+    use(usage){
+      this.controller.router.all('*', mkReq(usage));
+      return this;
+    }
+
+    useEach(usage){
+      this.middleWares.push(usage);
+      return this;
+    }
+
+    usem(...middleWares){
+      return function(...args){
+        middleWares.forEach(middleWare => middleWare.call(this, ...args));
+      }
+    }
+
+    normal(cb){
+      return function(){
+        return cb(this.request, this);
+      }
+    }
+  }
+
+  function mkBody(req){
+    const type = req.headers.get('content-type');
+    if(type == 'application/json'){
+      return req.data.json();
+    } else {
+      try {
+        return req.data.json();
+      } catch(e){
+        return req.data.text();
+      }
+    }
+  }
+
+  class SController extends Injectable {
+
+    constructor(root){
+      super();
+      this.root = root;
+      this.router = mkRouter({ base: path.join('/', root) });
+    }
+
+    mkCallback(cb){
+      return async (req, ctx) => {
+        let context = {...{
+          request: req,
+          body: mkBody(req)
+        },...ctx, ...(cb.parent || {}), ...{
+          text: svr.prototype.text,
+          html: svr.prototype.html,
+          status: svr.prototype.status,
+          json: svr.prototype.json,
+          error: svr.prototype.error
+        }};
+        return await cb.call(context, ...Object.keys(context).map(i => context[i]));
+      }
+    }
+
+    register(method, url, cb, middleWare){
+      this.router[method](url || '/', middleWare || this.mkCallback(cb), middleWare ? this.mkCallback(cb) : undefined);
+      return this;
+    }
+
+    new(root = '/'){
+      const controller = new SController(root || '/');
+      const controllerContext = new SControllerContext(controller);
+      const cb = (cb) => new context.Usage('', () => {
+        cb.call(controllerContext);
+        return controller;
+      });
+      cb.with = (...args) => {
+        controller.on('activate', (parentModule) => {
+          args
+          .filter(arg => arg instanceof SProvider)
+          .filter(arg => parentModule.hasProvider(arg.injectable))
+          .forEach(e => {
+            controllerContext[e.name] = e.injectable;
+          });
+        });
+        return cb;
+      }
+      return cb;
+    }
+  }
+
+  class SControllerMiddleware extends Injectable {
+    constructor(root, router){
+      super();
+      this.root = root;
+      this.router = router;
+    }
+  }
+
+  function createSControllerMiddleware(root = '') {
+    return (cb) => new SControllerMiddleware(root, cb);
+  }
+
+  return {
+    ServeApp,
+    SModule,
+    SService,
+    SController,
+    SControllerMiddleware: createSControllerMiddleware
+  };
+}

package/lib/rew/pkgs/serve.js

@@ -30,6 +30,35 @@ module.exports = (context) => {
     return new Request(url, options);
   }
 
+  function getBody(req){
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+
+      req.on('data', chunk => {
+        chunks.push(chunk);
+      });
+
+      req.on('end', () => {
+        let buffer = chunks.length ? Buffer.concat(chunks) : null;
+        resolve(buffer ? {
+          text(){
+            return buffer.toString();
+          },
+          json(){
+            return JSON.parse(buffer.toString());
+          },
+          buffer(){
+            return buffer;
+          }
+        } : null);
+      });
+
+      req.on('error', (err) => {
+        reject(err);
+      });
+    });
+  }
+
   class Server {
     _server = {};
     routers = {};
@@ -47,12 +76,18 @@ module.exports = (context) => {
     async handleRequest(req, res){ 
       try {
         let response = new Response();
+        const context = {};
         const request = mkReq(req);
+
+        context.getRealRequest = () => req;
+
+        request.data = await getBody(req);
+
         if(this.options.fetch == 'router'){
           if(!Object.keys(this.options.routers).length) throw new Error('No fetch function nor routers found');
-          response = await this.options.routers[Object.keys(this.options.routers)[0]].fetch(request);
+          response = await this.options.routers[Object.keys(this.options.routers)[0]].fetch(request, context).catch((e) => this.catch(e));
         } else {
-          response = await this.options.fetch(request);
+          response = await this.options.fetch(request, context).catch((e) => this.catch(e));
         }
 
         if(!response){
@@ -60,6 +95,10 @@ module.exports = (context) => {
           return;
         }
 
+        if(typeof response == 'string'){
+          response = new Response(response);
+        }
+
         response.headers.forEach((value, name) => {
           res.setHeader(name, value);
         });
@@ -97,6 +136,23 @@ module.exports = (context) => {
       return this;
     }
 
+    _onError = (e) => {
+      console.error(e);
+      return json({
+        error: true,
+        exception: e.name,
+        message: e.message
+      });
+    };
+    onError(fn){
+      this._onError = fn;
+      return this;
+    }
+
+    catch(e){
+      return this._onError(e);
+    }
+
     port(port){
       this.listen = port;
       return this;
@@ -190,7 +246,6 @@ module.exports = (context) => {
       const routeParts = pathname.split('/').filter(Boolean);
       let routePath = root;
 
-
       Object.keys(params).forEach(key => delete params[key]);
     
       for (const part of routeParts) {
@@ -294,6 +349,7 @@ module.exports = (context) => {
     return async (req) => {
       const url = new URL(req.url);
       const pathname = basePath ? url.pathname.replace(new RegExp('^'+basePath), '') : url.pathname;
+
       const file = lookUp(pathname);
       cleanCache();
   
@@ -324,6 +380,8 @@ module.exports = (context) => {
       if(type == 'default') router = SvrRouter.new(IttyRouter, {...options}, { id });
       if(type == 'auto') router = SvrRouter.new(AutoRouter, {...options}, { id });
       if(type == 'normal') router = SvrRouter.new(Router, {...options}, { id });
+      
+      router.auto = true;
 
       return router;
     }

package/lib/rew/pkgs/web.js

@@ -241,8 +241,8 @@ function renderToString(element, js = false) {
   }
   delete eltJSON.parent;
   delete eltJSON._target;
-
-  return js ? js === 'raw' ? eltJSON : JSON.stringify(eltJSON) : element instanceof TextNode ? `${type.text}` : `<${type.element}${propsString}>${selfClosingElements.has(type.element) ? '' : childrenHTML}${selfClosingElements.has(type.element) ? '' : `</${type.element}>`}`;
+  
+  return js ? (js === 'raw' ? eltJSON : JSON.stringify(eltJSON)) : element instanceof TextNode ? `${type.text}` : `<${type.element}${propsString}>${selfClosingElements.has(type.element) ? '' : childrenHTML}${selfClosingElements.has(type.element) ? '' : `</${type.element}>`}`;
 }
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@makano/rew",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "A simple coffescript runtime and app manager",
   "main": "main.js",
   "directories": {
@@ -50,5 +50,8 @@
     "vite": "^5.2.13",
     "vm": "^0.1.0",
     "yargs": "^17.7.2"
+  },
+  "devDependencies": {
+    "@danielx/civet": "^0.7.23"
   }
 }