binhend 1.5.16 → 2.0.0

package/src/csd/controller.js

@@ -0,0 +1,93 @@
+const { trycatch, HttpError } = require('../api');
+const { isEmptyObject, isString } = require('../utils/typeOf');
+const { OK, CREATED, BAD_REQUEST } = require('../utils/httpCodes').HttpCodes;
+
+const
+ERROR_MISSING_ID = 'Missing required parameter: id',
+ERROR_EMPTY_QUERY = 'Query should not be empty (null or no key-value)';
+
+function Controller(service) {
+    function parseID(request) {
+        let id = request.params?.id || request.query?.id || request.body?.id;
+        if (!isString(id)) throw new HttpError(BAD_REQUEST, ERROR_MISSING_ID);
+        return id;
+    }
+
+    function parseQuery(request) {
+        let query = isEmptyObject(request.query) ? request.params : request.query;
+        query = isEmptyObject(query) ? request.body : query;
+        if (isEmptyObject(query)) throw new HttpError(BAD_REQUEST, ERROR_EMPTY_QUERY);
+        return query;
+    }
+
+    async function process(method, args, httpCode, response) {
+        let result = await service[method].apply(service, args);
+        response.status(httpCode).json(result);
+    }
+
+    /** CREATE */
+
+    this.create = trycatch(async (request, response) => {
+        let data = request.body;
+        await process('create', [data], CREATED, response);
+    });
+
+    this.upsert = trycatch(async (request, response) => {
+        let query = parseQuery(request), data = request.body;
+        await process('upsert', [query, data], OK, response);
+    });
+
+    /** READ */
+
+    this.getAll = trycatch(async (request, response) => {
+        await process('getAll', [], OK, response);
+    });
+
+    this.getByID = trycatch(async (request, response) => {
+        let id = parseID(request);
+        await process('getByID', [id], OK, response);
+    });
+
+    this.getByQuery = trycatch(async (request, response) => {
+        let query = parseQuery(request);
+        await process('getByQuery', [query], OK, response);
+    });
+
+    /** UPDATE */
+
+    this.updateAll = trycatch(async (request, response) => {
+        let data = request.body;
+        await process('updateAll', [data], OK, response);
+    });
+
+    this.updateByID = trycatch(async (request, response) => {
+        let id = parseID(request);
+        let data = request.body;
+        await process('updateByID', [id, data], OK, response);
+    });
+
+    this.updateByQuery = trycatch(async (request, response) => {
+        let query = parseQuery(request), data = request.body;
+        await process('updateByQuery', [query, data], OK, response);
+    });
+
+    /** DELETE */
+
+    this.deleteAll = trycatch(async (request, response) => {
+        await process('deleteAll', [], OK, response);
+    });
+
+    this.deleteByID = trycatch(async (request, response) => {
+        let id = parseID(request);
+        await process('deleteByID', [id], OK, response);
+    });
+
+    this.deleteByQuery = trycatch(async (request, response) => {
+        let query = parseQuery(request);
+        await process('deleteByQuery', [query], OK, response);
+    });
+}
+
+module.exports = (service) => {
+    return new Controller(service);
+};

package/src/csd/dao.js

@@ -0,0 +1,17 @@
+
+const initService = require('./service');
+
+function DAO(instance) {
+    var service = initService({});
+
+    for (var key in service) {
+        if (!instance.hasOwnProperty(key) || typeof instance[key] !== 'function') {
+            throw new Error(`CSD: Missing function implementation for "${key}()"`);
+        }
+        this[key] = instance[key];
+    }
+}
+
+module.exports = (instance) => {
+    return new DAO(instance);
+};

package/src/csd/index.js

@@ -0,0 +1,15 @@
+
+const initController = require('./controller');
+const initService = require('./service');
+const initDao = require('./dao');
+
+function createCSD(instance) {
+    var dao = initDao(instance);
+    var service = initService(dao);
+    var controller = initController(service);
+    return { controller, service, dao };
+};
+
+module.exports = (DatabaseDriverAdapter) => {
+    return (input) => createCSD(new DatabaseDriverAdapter(input));
+};

package/src/csd/service.js

@@ -0,0 +1,58 @@
+
+function Service(dao) {
+    /** CREATE */
+    
+    this.create = async (data) => {
+        return await dao.create(data);
+    };
+
+    this.upsert = async (query, data) => {
+        return await dao.upsert(query, data);
+    };
+
+    /** READ */
+
+    this.getAll = async () => {
+        return await dao.getAll();
+    };
+
+    this.getByID = async (id) => {
+        return await dao.getByID(id);
+    };
+
+    this.getByQuery = async (query) => {
+        return await dao.getByQuery(query);
+    };
+
+    /** UPDATE */
+
+    this.updateAll = async (data) => {
+        return await dao.updateAll(data);
+    };
+
+    this.updateByID = async (id, data) => {
+        return await dao.updateByID(id, data);
+    };
+
+    this.updateByQuery = async (query, data) => {
+        return await dao.updateByQuery(query, data);
+    };
+
+    /** DELETE */
+
+    this.deleteAll = async () => {
+        return await dao.deleteAll();
+    };
+
+    this.deleteByID = async (id) => {
+        return await dao.deleteByID(id);
+    };
+
+    this.deleteByQuery = async (query) => {
+        return await dao.deleteByQuery(query);
+    };
+}
+
+module.exports = (dao) => {
+    return new Service(dao);
+};

package/src/middleware/parseBasicAuthToken.js

@@ -0,0 +1,11 @@
+const { isString } = require('../utils/typeOf');
+
+module.exports = (request, response, next) => {
+    var authString = request.headers['authorization'];
+
+    if (isString(authString) && authString.startsWith('Bearer ')) {
+        request.token = authString.split('Bearer ')[1];
+    }
+
+    next();
+};

package/src/server.js

@@ -1,53 +1,7 @@
-
 const express = require('express');
-const { defaultCORS } = require('./cors');
-
-function Server(options) {
-    const server = express();
-    const PORT = options.port || 1300;
-    const WEB_DIRECTORY = options.web;
-    const CORS = options.cors;
-
-    // Handle error of ExpressJS: URIError: Failed to decode param
-    // Error happens when add wrong '%' (e.i. invalid encoded URI component) into the request URL
-    server.use(function(req, res, next) {
-        try {
-            decodeURIComponent(req.path);
-            next();
-        }
-        catch(e) {
-            res.redirect('/');
-        }
-    });
-
-    if (CORS instanceof Function) {
-        server.use(CORS);
-    }
-    else if (CORS === true) {
-        server.use(defaultCORS);
-    }
-
-    if (WEB_DIRECTORY) {
-        server.use(express.static(WEB_DIRECTORY));
-    }
-    
-    if (options.api instanceof Function) {
-        server.use(options.api);
-    }
-
-    if (WEB_DIRECTORY) {
-        server.get('/*', (req, res) => res.sendFile('index.html', { root: WEB_DIRECTORY }));
-    }
-
-    server.listen(PORT, function() {
-        console.log(`[BINHEND][SERVER] Server is listening on http://localhost:${PORT}/`);
-
-        if (options.callback instanceof Function) {
-            options.callback(server, options.configs);
-        }
-    });
 
-    return server;
-}
+const server = express();
 
-module.exports = { Server };
+module.exports = {
+    server
+};

package/src/utils/bromise.js

@@ -0,0 +1,20 @@
+
+function Bromise() {
+    var resolve, reject, promise = new Promise((res, rej) => (resolve = res) && (reject = rej));
+
+    return {
+        promise,
+        resolve: (value) => {
+            resolve(value);
+            return promise;
+        },
+        reject: (error) => {
+            reject(error);
+            return promise;
+        }
+    };
+}
+
+module.exports = {
+    Bromise
+};

package/src/utils/httpCodes.js

@@ -0,0 +1,69 @@
+const HttpCodes = {
+    CONTINUE: 100,
+    SWITCHING_PROTOCOLS: 101,
+    PROCESSING: 102,
+    EARLY_HINTS: 103,
+    OK: 200,
+    CREATED: 201,
+    ACCEPTED: 202,
+    NON_AUTHORITATIVE_INFORMATION: 203,
+    NO_CONTENT: 204,
+    RESET_CONTENT: 205,
+    PARTIAL_CONTENT: 206,
+    MULTI_STATUS: 207,
+    ALREADY_REPORTED: 208,
+    IM_USED: 226,
+    MULTIPLE_CHOICES: 300,
+    MOVED_PERMANENTLY: 301,
+    FOUND: 302,
+    SEE_OTHER: 303,
+    NOT_MODIFIED: 304,
+    USE_PROXY: 305,
+    TEMPORARY_REDIRECT: 307,
+    PERMANENT_REDIRECT: 308,
+    BAD_REQUEST: 400,
+    UNAUTHORIZED: 401,
+    PAYMENT_REQUIRED: 402,
+    FORBIDDEN: 403,
+    NOT_FOUND: 404,
+    METHOD_NOT_ALLOWED: 405,
+    NOT_ACCEPTABLE: 406,
+    PROXY_AUTHENTICATION_REQUIRED: 407,
+    REQUEST_TIMEOUT: 408,
+    CONFLICT: 409,
+    GONE: 410,
+    LENGTH_REQUIRED: 411,
+    PRECONDITION_FAILED: 412,
+    PAYLOAD_TOO_LARGE: 413,
+    URI_TOO_LONG: 414,
+    UNSUPPORTED_MEDIA_TYPE: 415,
+    RANGE_NOT_SATISFIABLE: 416,
+    EXPECTATION_FAILED: 417,
+    IM_A_TEAPOT: 418,
+    MISDIRECTED_REQUEST: 421,
+    UNPROCESSABLE_ENTITY: 422,
+    LOCKED: 423,
+    FAILED_DEPENDENCY: 424,
+    TOO_EARLY: 425,
+    UPGRADE_REQUIRED: 426,
+    PRECONDITION_REQUIRED: 428,
+    TOO_MANY_REQUESTS: 429,
+    REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
+    UNAVAILABLE_FOR_LEGAL_REASONS: 451,
+    INTERNAL_SERVER_ERROR: 500,
+    NOT_IMPLEMENTED: 501,
+    BAD_GATEWAY: 502,
+    SERVICE_UNAVAILABLE: 503,
+    GATEWAY_TIMEOUT: 504,
+    HTTP_VERSION_NOT_SUPPORTED: 505,
+    VARIANT_ALSO_NEGOTIATES: 506,
+    INSUFFICIENT_STORAGE: 507,
+    LOOP_DETECTED: 508,
+    BANDWIDTH_LIMIT_EXCEEDED: 509,
+    NOT_EXTENDED: 510,
+    NETWORK_AUTHENTICATION_REQUIRED: 511,
+};
+
+module.exports = {
+    HttpCodes
+};

package/src/utils/typeOf.js

@@ -0,0 +1,78 @@
+
+function typeOf(input) {
+    return Object.prototype.toString.call(input).slice(8, -1);
+}
+
+function isObject(input) {
+    return typeOf(input) === 'Object';
+}
+
+function isEmptyObject(input) {
+    return isObject(input) && Object.keys(input).length === 0;
+}
+
+function isArray(input) {
+    return Array.isArray(input);
+}
+
+function isEmptyArray(input) {
+    return isArray(input) && input.length === 0;
+}
+
+function isFunction(input) {
+    return typeof input === 'function';
+}
+
+function isString(input) {
+    return typeOf(input) === 'String';
+}
+
+function isEmptyString(input) {
+    return isString(input) && input.length === 0;
+}
+
+function isNumber(input) {
+    return typeOf(input) === 'Number';
+}
+
+function isBigInt(input) {
+    return typeof input === 'bigint';
+}
+
+function isSymbol(input) {
+    return typeof input === 'symbol';
+}
+
+function isBoolean(input) {
+    return typeOf(input) === 'Boolean';
+}
+
+function isNull(input) {
+    return input === null;
+}
+
+function isUndefined(input) {
+    return input === undefined;
+}
+
+function isNullOrUndefined(input) {
+    return isNull(input) || isUndefined(input);
+}
+
+module.exports = Object.assign(typeOf, {
+    typeOf,
+    isObject,
+    isEmptyObject,
+    isArray,
+    isEmptyArray,
+    isFunction,
+    isNull,
+    isUndefined,
+    isNullOrUndefined,
+    isBoolean,
+    isNumber,
+    isString,
+    isEmptyString,
+    isSymbol,
+    isBigInt
+});

package/src/{component.build.js → web/component.build.js}

@@ -31,6 +31,7 @@ function processEachFile({ source: sourceRootPath, web: outputRootPath, module:
             var component = require(file.path);
         }
         catch (error) {
+            if (path.parse(file.name).ext === '.js') console.error('[BINHEND][WEB-BUILD]', error);
             return cloneFileIfNew(fileSourcePath, fileOutputPath);
         }
 

package/src/{component.format.js → web/component.format.js}

@@ -5,6 +5,7 @@ const { scanNestedFiles, cloneFileIfNew, printError, makeFullDirPath, writeToFil
 
 const PREFIX_CODE =
 `var { context, tag, svg, script, require, css } = binh.context(module, require);
+var Binh = binh.Binh;
 binh.component(context, ui, service, style);
 var ui = null, service = null, style = null;\r\n\r\n`;
 

package/src/web/component.method.js

@@ -0,0 +1,141 @@
+
+const path = require('path');
+const { isString } = require('../utils/typeOf');
+const Component = require('./component');
+
+const binh = {};
+
+global.binh = binh;
+
+binh.context = function(module, defaultRequire) {
+    var context = { module, require: defaultRequire };
+
+    return {
+        context,
+        tag: tag.bind(context),
+        svg: svg.bind(context),
+        script: script.bind(context),
+        require: customRequire.bind(context),
+        css: css.bind(context)
+    };
+};
+
+function tagnames(tagNames) {
+    return typeof tagNames === 'string' ? tagNames.split(/\s+/) : [];
+}
+
+function tag(tagNames) {
+    var htmltags = this.component.htmltags;
+    htmltags.push.apply(htmltags, tagnames(tagNames));
+}
+
+function svg(tagNames) {
+    var svgtags = this.component.svgtags;
+    svgtags.push.apply(svgtags, tagnames(tagNames));
+}
+
+function script() {
+    var scripts = Array.from(arguments);
+    var links = this.component.links;
+    links.push.apply(links, scripts);
+}
+
+function customRequire(filePath) {
+    filePath = filePath.endsWith('.css') ? (filePath+'.js') : filePath;
+    return this.require(filePath);
+}
+
+function css() {
+    var csses = Array.from(arguments);
+    var appliedStyles = this.component.options.csses;
+    appliedStyles.push.apply(appliedStyles, csses);
+}
+
+binh.component = function(context, ui, service, style) {
+    var component = ui || service || style;
+    var type = ui && 'ui' || service && 'service' || style && 'style';
+
+    if (!(component instanceof Function)) return;
+
+    context.component = component;
+
+    var module = context.module;
+    module.exports = component;
+
+    component.module = module;
+    component.constructor = Component;
+    component.filename = module.filename;
+    component.type = type;
+
+    component.htmltags = [];
+    component.svgtags = [];
+    component.links = [];
+    component.options = { csses: [] };
+    component.vars = {};
+    component.varname = getVariableName(component.filename);
+    component.as = alias;
+    component.eachChild = loopComponentChildren;
+};
+
+binh.final = function(module) {
+    var component = module.exports;
+
+    component.eachChild && component.eachChild(childComponent => {
+        if (childComponent.alias) {
+            component.vars[childComponent.filename] = childComponent.alias;
+        }
+    });
+};
+
+function loopComponentChildren(callback) {
+    this.module.children.forEach(childModule => {
+        var childComponent = childModule.exports;
+        if (!(childComponent instanceof Function) || childComponent.constructor !== Component) return;
+        callback(childComponent);
+    });
+}
+
+binh.ui = function(module, component, htmltags, links) {
+    binh.component({ module }, component);
+    component.htmltags = htmltags;
+    component.links = links;
+    binh.final(module);
+};
+
+binh.service = function(module, component, links) {
+    binh.component({ module }, null, component, null);
+    component.links = links;
+    binh.final(module);
+};
+
+binh.style = function(module, component) {
+    binh.component({ module }, null, null, component);
+    binh.final(module);
+};
+
+binh.css = function(module, cssFilename) {
+    var cssFilePath = cssFilename && path.join(module.path, cssFilename) || module.filename.replace(/.js$/, '');
+    var content = fs.readFileSync(cssFilePath, { encoding: 'utf8', flag: 'r' });
+    content = UglifyCSS.processString(content);
+    var component = new Function(`return function style() { return ${JSON.stringify(content)}; };`)();
+    component.cssFilePath = cssFilePath;
+    binh.component({ module }, null, null, component);
+    binh.final(module);
+};
+
+binh.Binh = function() {}; // dummy Binh object for binhjs => build web not logging error of undefined
+
+function alias(name) {
+    if (!isString(name)) return this;
+    name = name.trim();
+    this.alias = name;
+    return this;
+}
+
+function getVariableName(filePath) {
+    return path.parse(filePath).name.replace(/-/g, '').replace(/\W.*/, '').trim();
+}
+
+module.exports = {
+    binh
+};

package/src/web/index.js

@@ -0,0 +1,46 @@
+
+const path = require('path');
+const { isEmptyString, isString } = require('../utils/typeOf');
+const ComponentFormat = require('./component.format');
+const ComponentBuild = require('./component.build');
+const { server } = require('../server');
+
+function WebBuilder(source, { output } = {}) {
+
+    if (isEmptyString(source)) throw new Error(`[BINHEND][WEB] Require source code location. Current: source: ${source}`);
+
+    source = path.resolve(source);
+    output = isString(output) ? output : 'build';
+
+    if (source === path.resolve(output)) throw new Error(`[BINHEND][WEB] Location of build output & source code should not be the same: ${source}`);
+
+    var module = path.resolve(output, 'module');
+    var web = path.resolve(output, 'web');
+    var external = path.resolve(web, 'NPM');
+
+    this.bundle = () => {
+        ComponentFormat.generate(source, module, () => ComponentBuild.bundle({ source, web, module }));
+    };
+
+    this.lazy = () => {
+        ComponentFormat.generate(source, module, () => ComponentBuild.lazyload({ source, web, module, external }));
+    };
+
+    this.path = () => {
+        return web;
+    };
+
+    this.minify = (flag = true) => {
+        Component.minification = flag;
+    };
+
+    setTimeout(() => {
+        server.use(express.static(web));
+        server.get('/*', (req, res) => res.sendFile('index.html', { root: web }));
+    });
+
+}
+
+module.exports = {
+    WebBuilder
+};