Reorganized parsers and transforms.

Ben Hanna · Ben Hanna · commit 46ccbbe0de37 · 2017-06-20T11:50:28.000Z
diff --git a/handler.js b/handler.js
@@ -1,116 +1,108 @@
 const _ = require('lodash');
+const qs = require('./parsers/qs');
+const transforms = require('./transforms');
 
-class Handler {
+class ModelHandler {
     constructor(Model) {
         this.Model = Model;
     }
     
-    async create(req, res, next) {
-        try {
-            const row = await this.Model.create(req.body);
-            res.send(row);
-        } catch (error) {
-            next(error);
-        }
+    create() {
+        return [
+            transforms.raw,
+            async create(req, res, next) => {
+                try {
+                    const row = await this.Model.create(req.body);
+                    res.send(res.transform(row));
+                } catch (error) {
+                    next(error);
+                }
+            }
+        ];
     }
     
-    async get(req, res, next) {
-        try {
-            const row = await this.findOne(req.params);
-            res.send(row);
-        } catch (error) {
-            next(error);
-        }
+    get() {
+        return [
+            transforms.raw,
+            async (req, res, next) => {
+                try {
+                    const row = await this.findOne(req.params);
+                    res.send(res.transform(row));
+                } catch (error) {
+                    next(error);
+                }
+            }
+        ];
     }
     
-    async destroy(req, res, next) {
-        try {
-            const row = await this.findOne(req.params);
-            await row.destroy();
-            res.sendStatus(204);
-        } catch (error) {
-            next(error);
-        }
+    query () {
+        return [
+            transforms.raw,
+            async (req, res, next) => {
+                try {
+                    const { rows, start, end, count } = await this.findAndCountAll(req.query);
+                    
+                    res.set('Content-Range', `${start}-${end}/${count}`);
+                    
+                    if (count > end) {
+                        res.status(206);
+                    } else {
+                        res.status(200);
+                    }
+                    
+                    res.send(res.transform(rows));
+                } catch (error) {
+                    next(error);   
+                }
+            }
+        ];
     }
     
-    async update(req, res, next) {
-        try {
-            const row = await this.findOne(req, res, next);
-            const updated = await row.updateAttributes(req.body);
-            res.send(updated);
-        } catch (error) {
-            next(error);
-        }
+    remove() {
+        return [
+            async (req, res, next) => {
+                try {
+                    const row = await this.findOne(req.params);
+                    await row.destroy();
+                    res.sendStatus(204);
+                } catch (error) {
+                    next(error);
+                }
+            }
+        ];
     }
     
-    async query(req, res, next) {
-        try {
-            const { rows, start, end, count } = await this.findAndCountAll(req.query);
-            
-            res.set('Content-Range', `${start}-${end}/${count}`);
-            
-            if (count > end) {
-                res.status(206);
-            } else {
-                res.status(200);
+    update() {
+        return [
+            transforms.raw,
+            async (req, res, next) => {
+                try {
+                    const row = await this.findOne(req, res, next);
+                    const updated = await row.updateAttributes(req.body);
+                    res.send(updated);
+                } catch (error) {
+                    next(error);
+                }
             }
-            
-            res.send(rows);
-        } catch (error) {
-            next(error);   
-        }
+        ];
     }
     
-    async findOne(params, options = { where: {} }) {
-        options.where = _.merge(this.filter(params), options.where);
+    async findOne(params, options) {
+        options = _.merge(qs(params, this.Model), options);
         
-        const row = await this.Model.findOne(options);
-        
-        return row;
+        return await this.Model.findOne(options);
     }
     
-    async findAndCountAll(params, options = { where: {} }) {
-        const { fields, limit = 50, offset = 0, sort, ...filters } = params;
-        
-        options.where = _.merge(this.filter(filters), options.where);
-        
-        if (fields) {
-            options.attributes = fields.split(','); 
-        }
-        
-        if (sort) {
-            const keys = sort.split(',');
-            
-            options.order = keys.map((key) => {
-                if (key.indexOf('-') === 0) {
-                    return [key.substr(1), 'DESC'];
-                } else {
-                    return [key, 'ASC'];
-                }
-            });
-        }
+    async findAndCountAll(params, options) {
+        options = _.merge(qs(params, this.Model), options);
         
         const { count, rows } = await this.Model.findAndCountAll(options);
         
-        const start = offset;
-        const end = Math.max(count, offset + limit);
+        const start = options.offset;
+        const end = Math.min(count, options.offset + options.limit);
         
         return { rows, start, end, count };
     }
-    
-    filter(params, filters = {}) {
-        const { rawAttributes } = this.Model;
-        
-        _.forOwn(params, (value, key) => {
-            if (rawAttributes.hasOwnProperty(key)) {
-                try {
-                    filters[key] = JSON.parse(value);
-                } catch (error) {
-                    filters[key] = value.split(',');
-                }
-            }
-        });
-        
-        return filters;
-    }
-}
+}
+
+module.exports = ModelHandler;
diff --git a/parsers/qs.js b/parsers/qs.js
@@ -1,75 +1,76 @@
-var _ = require('lodash');
+const _ = require('lodash');
 
-module.exports = {
-    distinct: distinct,
-    fields: fields,
-    filters: filters,
-    limit: limit,
-    offset: offset,
-    sort: sort
-}
-
-function distinct(value) {
-    return value ? true : null;
-}
+module.exports = parse;
 
-function fields(options) {
-    var fields = null;
+function parse(params, { rawAttributes }) {
+    const options = {
+        where: {}    
+    };
     
-    if (options) {
-        fields = options.split(',');
-    }
-
-    return fields;
-}
+    const keywords = [
+        'fields',
+        'group',
+        'limit',
+        'offset',
+        'sort'
+    ];
     
-function filters(options) {
-    var filters = null;
+    options.attributes = parseString(params.fields);
+    options.group = parseString(params.group);
+    options.limit = parseInteger(params.limit);
+    options.offset = parseInteger(params.offset);
+    options.order = parseSort(params.sort);
     
-    if (!_.isEmpty(options)) {
-        filters = {};
-        _.forOwn(options, function (value, key) {
-            try {
-                filters[key] = JSON.parse(value);
-            } catch (err) {
-                filters[key] = value.split(',');
+    _(params)
+        .omit(keywords)
+        .forOwn((value, key) => {
+            if (rawAttributes.hasOwnProperty(key)) {
+                options.where[key] = parseJson(value);
             }
         });
+    
+    return options;
+};
+
+function parseString(value) {
+    if (value) {
+        value = value.split(',');
     }
     
-    return filters;
+    return value;
 }
 
-function limit(value) {
-    value = parseInt(value);
+function parseJson(value) {
+    try {
+        value = JSON.parse(value);
+    } catch (error) {
+        value = parseString(value);
+    }
     
-    if (!value || value < 0) {
-        value = 0;
-    }    
     return value;
 }
 
-function offset(value) {
+function parseInteger(value) {
     value = parseInt(value);
     
     if (!value || value < 0) {
         value = 0;
     }
+    
     return value;
 }
 
-function sort(options) {
-    var properties,
-        sort = null;
+function parseSort(value) {
+    let sort = null;
         
-    if (options) {
-        properties = options.split(',');
+    if (value) {
+        const keys = parseString(value);
         
-        sort = _.map(properties, function (x) {
-            if (x.indexOf('-') === 0) {
-                return [x.substr(1), 'DESC'];
+        sort = _.map(keys, (key) => {
+            if (key.indexOf('-') === 0) {
+                return [key.substr(1), 'DESC'];
             } else {
-                return [x, 'ASC'];
+                return [key, 'ASC'];
             }
         });
     }
diff --git a/transforms/distinct.js b/transforms/distinct.js
diff --git a/transforms/index.js b/transforms/index.js
@@ -0,0 +1,17 @@
+const _ = require('lodash');
+
+module.exports = {
+    raw
+};
+
+function raw(req, res, next) {
+    if (!_.isFunction(res.transform)) {
+        res.transform = transform;
+    }
+    
+    next();
+    
+    function transform(data) {
+        return data;
+    }
+}
diff --git a/transforms/raw.js b/transforms/raw.js
@@ -1,4 +1,4 @@
-var _ = require('lodash');
+const _ = require('lodash');
 
 module.exports = transform;
 

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-var _ = require('lodash');`
	`1`	`+const _ = require('lodash');`
`2`	`2`
`3`	`3`	`module.exports = transform;`
`4`	`4`