binhend 2.2.6 → 2.2.8

package/demo.js

@@ -1,103 +1,11 @@
 
-const { HttpCodes, ConfigLoader, WebBuilder, HttpError, validation, createCSD } = require('./index2');
+const { HttpCodes, ConfigLoader, HttpError, validation: must } = require('./index');
 const path = require('path');
 
-// var jsonPath = __dirname + '/jsconfig.json';
-// var cc = ConfigLoader.json(jsonPath);
-// console.log('cc', cc);
-
-// const config = {};
-// console.log('config', config);
-// const loader = new ConfigLoader(config);
-
-// loader.object({ foo: '1', koo: '2', hoo: '3' }, { filter: ['koo', 'hoo'] });
-
-// console.log('config', config);
-
-// console.log(path.resolve(__dirname, './app.secret'));
-
-function MongooseCSD(Model) {
-    /** CREATE */
-
-    this.create = async (data) => {
-        console.log('create', arguments);
-        // return await new Model(data).save();
-        return await Model.create(data);
-    };
-
-    this.upsert = async (query, data) => {
-        console.log('upsert', arguments);
-        return await Model.findOneAndUpdate(query, data, { new: true, upsert: true });
-    };
-
-    /** READ */
-
-    this.getAll = async () => {
-        console.log('getAll', arguments);
-        return await Model.find({});
-    };
-
-    this.getByID = async (id) => {
-        console.log('getByID', arguments);
-        return await Model.findById(id);
-    };
-
-    this.getByQuery = async (query) => {
-        console.log('getByQuery', arguments);
-        return await Model.find(query);
-    };
-
-    /** UPDATE */
-
-    this.updateAll = async (data) => {
-        console.log('updateAll', data);
-        return await Model.updateMany({}, data);
-    };
-
-    this.updateByID = async (id, data) => {
-        console.log('updateByID', arguments);
-        return await Model.findByIdAndUpdate(id, data, { new: true });
-    };
-
-    this.updateByQuery = async (query, data) => {
-        console.log('updateByQuery', arguments);
-        return await Model.updateMany(query, data);
-    };
-
-    /** DELETE */
-
-    this.deleteAll = async () => {
-        console.log('deleteAll', arguments);
-        return await Model.deleteMany({});
-    };
-
-    this.deleteByID = async (id) => {
-        console.log('deleteByID', arguments);
-        return await Model.findByIdAndDelete(id);
-    };
-
-    this.deleteByQuery = async (query) => {
-        console.log('deleteByQuery', arguments);
-        return await Model.deleteMany(query);
-    };
+function Testa(input) {
+    this.a = must.Function(input.a);
 }
 
-const createMongooseCSD = createCSD(MongooseCSD);
-
-const csd = createMongooseCSD({});
-
-csd.controller.create;
-csd.service.create;
-
-csd.dao;
-
-async function abc() {
-    return csd.service.create({ a: 1 });
-}
-
-
-
-(async function () {
-    var cc = await abc();
-})();
+var p = new Testa();
 
+p.a();

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "binhend",
-    "version": "2.2.6",
+    "version": "2.2.8",
     "description": "",
     "main": "index.js",
     "author": "Nguyen Duc Binh",
@@ -21,6 +21,10 @@
         "example-web2": "node example_web2"
     },
     "dependencies": {
+        "express": "^4.17.1",
+        "js-beautify": "^1.15.1",
+        "uglify-js": "^3.17.4",
+        "uglifycss": "^0.0.29"
     },
     "engines": {
         "node": ">=20.18.0",

package/packages/core/src/server.js

@@ -2,15 +2,15 @@
 const express = require('express');
 
 var server = express();
-var calledOnce = false;
+var isCalledOnce = false;
 
 function getServer() {
-    if (calledOnce) {
+    if (isCalledOnce) {
         server = server;
     }
     else {
         server = express();
-        calledOnce = true;
+        isCalledOnce = true;
     }
 
     return server;

package/packages/csd/src/adapter.val.js

@@ -0,0 +1,35 @@
+
+const { NotNullish, AsyncFunction } = require('@binhend/validation');
+
+function DatabaseDriverAdapter(input) {
+    const required = { required: true };
+
+    NotNullish(input);
+
+    for (var property in input) {
+        this[property] = input[property];
+    }
+
+    //___ CREATE ___//
+    this.create = AsyncFunction(input.create, required);
+    this.upsert = AsyncFunction(input.upsert, required);
+
+    //___ READ ___//
+    this.getAll = AsyncFunction(input.getAll, required);
+    this.getByID = AsyncFunction(input.getByID, required);
+    this.getByQuery = AsyncFunction(input.getByQuery, required);
+
+    //___ UPDATE ___//
+    this.updateAll = AsyncFunction(input.updateAll, required);
+    this.updateByID = AsyncFunction(input.updateByID, required);
+    this.updateByQuery = AsyncFunction(input.updateByQuery, required);
+
+    //___ DELETE ___//
+    this.deleteAll = AsyncFunction(input.deleteAll, required);
+    this.deleteByID = AsyncFunction(input.deleteByID, required);
+    this.deleteByQuery = AsyncFunction(input.deleteByQuery, required);
+
+    return this;
+}
+
+module.exports = DatabaseDriverAdapter;

package/packages/csd/src/controller.js

@@ -1,13 +1,11 @@
 
 const { isEmptyObject, isString } = require('@binhend/types');
-const { trycatch } = require('@binhend/middlewares');
 const { HttpError, HttpCodes } = require('@binhend/utils');
-
 const { OK, CREATED, BAD_REQUEST } = HttpCodes;
 
 const
-ERROR_MISSING_ID = 'Missing required parameter: id',
-ERROR_EMPTY_QUERY = 'Query should not be empty (null or no key-value)';
+    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) {
@@ -30,65 +28,65 @@ function Controller(service) {
 
     //___ CREATE ___//
 
-    this.create = trycatch(async (request, response) => {
+    this.create = async (request, response, next) => {
         let data = request.body;
         await process('create', [data], CREATED, response);
-    });
+    };
 
-    this.upsert = trycatch(async (request, response) => {
+    this.upsert = async (request, response, next) => {
         let query = parseQuery(request), data = request.body;
         await process('upsert', [query, data], OK, response);
-    });
+    };
 
     //___ READ ___//
 
-    this.getAll = trycatch(async (request, response) => {
+    this.getAll = async (request, response, next) => {
         await process('getAll', [], OK, response);
-    });
+    };
 
-    this.getByID = trycatch(async (request, response) => {
+    this.getByID = async (request, response, next) => {
         let id = parseID(request);
         await process('getByID', [id], OK, response);
-    });
+    };
 
-    this.getByQuery = trycatch(async (request, response) => {
+    this.getByQuery = async (request, response, next) => {
         let query = parseQuery(request);
         await process('getByQuery', [query], OK, response);
-    });
+    };
 
     //___ UPDATE ___//
 
-    this.updateAll = trycatch(async (request, response) => {
+    this.updateAll = async (request, response, next) => {
         let data = request.body;
         await process('updateAll', [data], OK, response);
-    });
+    };
 
-    this.updateByID = trycatch(async (request, response) => {
+    this.updateByID = async (request, response, next) => {
         let id = parseID(request);
         let data = request.body;
         await process('updateByID', [id, data], OK, response);
-    });
+    };
 
-    this.updateByQuery = trycatch(async (request, response) => {
+    this.updateByQuery = async (request, response, next) => {
         let query = parseQuery(request), data = request.body;
         await process('updateByQuery', [query, data], OK, response);
-    });
+    };
 
     //___ DELETE ___//
 
-    this.deleteAll = trycatch(async (request, response) => {
+    this.deleteAll = async (request, response, next) => {
         await process('deleteAll', [], OK, response);
-    });
+    };
 
-    this.deleteByID = trycatch(async (request, response) => {
+    this.deleteByID = async (request, response, next) => {
         let id = parseID(request);
         await process('deleteByID', [id], OK, response);
-    });
+    };
 
-    this.deleteByQuery = trycatch(async (request, response) => {
+    this.deleteByQuery = async (request, response, next) => {
         let query = parseQuery(request);
         await process('deleteByQuery', [query], OK, response);
-    });
+    };
 }
 
 module.exports = (service) => {

package/packages/csd/src/csd.js

@@ -1,12 +1,12 @@
 
-const initController = require('./controller');
-const initService = require('./service');
-const initDao = require('./dao');
+const createController = require('./controller');
+const createService = require('./service');
+const createDao = require('./dao');
 
-function createCSD(instance) {
-    var dao = initDao(instance);
-    var service = initService(dao);
-    var controller = initController(service);
+function createCSD(databaseDriverAdapter) {
+    var dao = createDao(databaseDriverAdapter);
+    var service = createService(dao);
+    var controller = createController(service);
     return { controller, service, dao };
 };
 

package/packages/csd/src/dao.js

@@ -1,31 +1,58 @@
 
-const must = require('@binhend/validation');
+const DatabaseDriverAdapter = require('./adapter.val');
 
-function DAO(implementedInstance = {}) {
-
-    const instance = implementedInstance,
-        required = { required: true };
+function DAO(databaseDriverAdapter) {
+    const database = new DatabaseDriverAdapter(databaseDriverAdapter);
 
     //___ CREATE ___//
-    this.create = must.Function(instance.create, required);
-    this.upsert = must.Function(instance.upsert, required);
+    this.create = async (data) => {
+        return await database.create(data);
+    };
+
+    this.upsert = async (query, data) => {
+        return await database.upsert(query, data);
+    };
 
     //___ READ ___//
-    this.getAll = must.Function(instance.getAll, required);
-    this.getByID = must.Function(instance.getByID, required);
-    this.getByQuery = must.Function(instance.getByQuery, required);
+    this.getAll = async () => {
+        return await database.getAll();
+    };
+
+    this.getByID = async (id) => {
+        return await database.getByID(id);
+    };
+
+    this.getByQuery = async (query) => {
+        return await database.getByQuery(query);
+    };
 
     //___ UPDATE ___//
-    this.updateAll = must.Function(instance.updateAll, required);
-    this.updateByID = must.Function(instance.updateByID, required);
-    this.updateByQuery = must.Function(instance.updateByQuery, required);
+    this.updateAll = async (data) => {
+        return await database.updateAll(data);
+    };
+
+    this.updateByID = async (id, data) => {
+        return await database.updateByID(id, data);
+    };
+
+    this.updateByQuery = async (query, data) => {
+        return await database.updateByQuery(query, data);
+    };
 
     //___ DELETE ___//
-    this.deleteAll = must.Function(instance.deleteAll, required);
-    this.deleteByID = must.Function(instance.deleteByID, required);
-    this.deleteByQuery = must.Function(instance.deleteByQuery, required);
+    this.deleteAll = async () => {
+        return await database.deleteAll();
+    };
+
+    this.deleteByID = async (id) => {
+        return await database.deleteByID(id);
+    };
+
+    this.deleteByQuery = async (query) => {
+        return await database.deleteByQuery(query);
+    };
 }
 
-module.exports = (implementedInstance) => {
-    return new DAO(implementedInstance);
+module.exports = (databaseDriverAdapter) => {
+    return new DAO(databaseDriverAdapter);
 };

package/packages/validation/src/typeValidation.js

@@ -130,6 +130,20 @@ function Function(input, options = {}) {
     return Validator(input, types.isFunction, { ...options, type: 'function' });
 }
 
+/**
+ * Validate an input being an async function
+ *
+ * @param {*} input - Input value needs to be validated.
+ * @param {Options} options - Additional options for validation.
+ * @returns {Function} - The validated input
+ * @throws {HttpError} - If validation fails
+ */
+function AsyncFunction(input, options = {}) {
+    return Validator(input, (input) => input instanceof AsyncFunctionConstructor, { ...options, type: 'async function' });
+}
+
+const AsyncFunctionConstructor = global.Object.getPrototypeOf(async function() {}).constructor;
+
 /**
  * Validate an input being a date
  *
@@ -260,6 +274,7 @@ module.exports = {
     Array,
     Object,
     Function,
+    AsyncFunction,
     Date,
     DateLike,
     Enum,