booleanTransformer, bigTransformer and using transformers in the constructor

Author: allie-wake-up

cli.js

@@ -47,8 +47,13 @@ nconf.argv(yargs.options({
         alias: 'm',
         describe: 'Model class name.  Will default to converting snake case table name to PascalCase'
     },
+    big: {
+        describe: 'Use Big with a tranformer for the type for decimal instead of string',
+        boolean: true,
+        default: undefined
+    },
     moment: {
-        describe: 'Use Date | Moment for the type for dates instead of just Date',
+        describe: 'Use Moment with a transformer for the type for dates instead of Date',
         boolean: true,
         default: undefined
     },

constants.js

@@ -1,4 +1,5 @@
 module.exports = {
+    boolTypes: ['tinyint'],
     numberTypes: ['int', 'tinyint', 'smallint', 'mediumint', 'bigint', 'float', 'double', 'real'],
     dateTypes: ['datetime', 'time', 'timestamp', 'date', 'year'],
     forbiddenExportCols: ['password'],

index.d.ts

@@ -0,0 +1,25 @@
+import { Big } from 'big.js';
+import { Moment } from 'moment';
+
+type GenPartial<T> = {
+    [P in keyof T]?: T[P] extends Moment ? Moment | string :
+        T[P] extends Date ? Date | string :
+        T[P] extends boolean ? boolean | 0 | 1 :
+        T[P] extends Big ? Big | string :
+        T[P];
+}
+
+declare const bigTransformer {
+    from: (value: string | number) => Big;
+    to: (value: Big) => string;
+}
+
+declare const booleanTransformer {
+    from: (value: boolean | 0 | 1) => boolean;
+    to: (value: boolean) => 0 | 1;
+}
+
+declare const momentTransformer {
+    from: (value: Date | string) => Moment;
+    to: (value: Moment) => string;
+}

index.js

@@ -16,6 +16,20 @@ const bigTransformer = {
     }
 };
 
+const booleanTransformer = {
+    from: function(value) {
+        if (typeof value !== 'undefined' && value !== null) {
+            return value ? true : false;
+        }
+        return value;
+    },
+    to: function(value) {
+        if (value) {
+            return value ? 1 : 0;
+        }
+    }
+};
+
 const momentTransformer = {
     // called on value when fetching from database
     from: function(value) {
@@ -35,5 +49,6 @@ const momentTransformer = {
 
 module.exports = {
     bigTransformer,
+    booleanTransformer,
     momentTransformer
 };

package.json

@@ -3,6 +3,7 @@
   "version": "0.8.0",
   "description": "Generate typeorm models from your database tables",
   "main": "index.js",
+  "types": "index.d.ts",
   "bin": {
     "typeormgen": "cli.js",
     "typeg": "cli.js"

write-foot.js

@@ -0,0 +1,42 @@
+const { boolTypes, dateTypes } = require('./constants');
+
+module.exports = function(info, tab, conf) {
+    let content = `${tab}constructor(props?: GenPartial<${conf.get('model')}>) {
+${tab}${tab}super(props);
+`;
+
+    let transformers = '';
+    Object.keys(info).forEach(name => {
+        const col = info[name];
+        if (boolTypes.indexOf(col.type) > -1 && col.length === 1) {
+            transformers += `${tab.repeat(3)}this.${name} = booleanTransformer.from(props.${name});
+`;
+        } else if (dateTypes.indexOf(col.type) > -1) {
+            if (conf.get('moment')) {
+                transformers += `${tab.repeat(3)}this.${name} = momentTransformer.from(props.${name});
+`;
+            } else {
+                transformers += `${tab.repeat(3)}if (props.${name}) {
+${tab.repeat(3)}this.${name} = new Date(props.${name});
+${tab.repeat(2)}}
+`;
+            }
+        } else if (conf.get('big') && col.type === 'decimal') {
+            transformers += `${tab.repeat(3)}this.${name} = bigTransformer.from(props.${name});
+`;
+        }
+    });
+
+    if (transformers !== '') {
+        content += `
+${tab.repeat(2)}if (props) {
+${transformers}${tab.repeat(2)}}
+`;
+    }
+
+    content += `${tab}}
+}
+`;
+
+    return content;
+};

write-head.js

@@ -1,11 +1,37 @@
-module.exports = function(table, name, columns, baseInfo, hasDate, rules) {
+const { boolTypes, dateTypes } = require('./constants');
+
+module.exports = function(info, columns, baseInfo, conf) {
+    const hasBool = Object.keys(info).find(col => {
+        return (boolTypes.indexOf(info[col].type) > -1 && info[col].length === 1);
+    });
+
+    let hasDate = false;
+    if (conf.get('moment')) {
+        hasDate = Object.keys(info).find(col => {
+            return dateTypes.indexOf(info[col].type) > -1;
+        });
+    }
+
+    let hasDecimal = false;
+    if (conf.get('big')) {
+        hasDecimal = Object.keys(info).find(col => {
+            return info[col].type === 'decimal';
+        });
+    }
+
     let content = '';
-    if (rules) {
+    if (hasDecimal) {
+        content += `import { Big } from 'big.js'
+`;
+    }
+
+
+    if (conf.get('rules')) {
         content += `import * as joi from 'joi';
 `;
     }
 
-    if (hasDate) {
+    if (conf.get('moment') && hasDate) {
         content += `import { Moment } from 'moment';
 `;
     }
@@ -31,20 +57,49 @@ module.exports = function(table, name, columns, baseInfo, hasDate, rules) {
 `;
 
 
+    content += 'import { GenPartial';
+    if (hasDecimal || hasBool || hasDate) {
+        content += ', ';
+    } else {
+        content += ' ';
+    }
+
+    if (hasDecimal) {
+        content += 'bigTransformer';
+
+        if (hasBool || hasDate) {
+            content += ', ';
+        } else {
+            content += ' ';
+        }
+    }
+
+    if (hasBool) {
+        content += 'booleanTransformer';
+
+        if (hasDate) {
+            content += ', ';
+        } else {
+            content += ' ';
+        }
+    }
+
     if (hasDate) {
-        content += `import { momentTransformer } from 'typeormgen';
-`;
+        content += `momentTransformer `;
     }
 
+    content += `} from 'typeormgen';
+`;
+
     if (baseInfo) {
         content += `
 import ${baseInfo.name} from '${baseInfo.path}';
 `;
     }
 
     content += `
-@Entity('${table}')
-export default class ${name} `;
+@Entity('${conf.get('table')}')
+export default class ${conf.get('model')} `;
 
     if (baseInfo) {
         content += `extends ${baseInfo.name} `;
@@ -54,4 +109,4 @@ export default class ${name} `;
 `;
 
     return content;
-}
+};

write-model.js

@@ -1,6 +1,7 @@
 const fs = require('fs-extra');
-const { numberTypes, dateTypes } = require('./constants');
+const { boolTypes, numberTypes, dateTypes } = require('./constants');
 const readBase = require('./read-base');
+const writeFoot = require('./write-foot');
 const writeHead = require('./write-head');
 const writeRules = require('./write-rules');
 const writeTojson = require('./write-tojson');
@@ -11,11 +12,7 @@ function hasColumn(column, info) {
 
 module.exports = function(info, nconf) {
     const base = nconf.get('base');
-    const model = nconf.get('model');
-    const moment = nconf.get('moment');
     const out = nconf.get('out');
-    const rules = nconf.get('rules');
-    const table = nconf.get('table');
     const tabs = nconf.get('tabs');
     const tabSize = nconf.get('tabSize');
     const columns = {
@@ -34,14 +31,10 @@ module.exports = function(info, nconf) {
         baseInfo = readBase(base, out);
     }
 
-    let hasDate = false;
-    if (moment) {
-        hasDate = Object.keys(info).find(col => dateTypes.indexOf(info[col].type) > -1);
-    }
-    let content = writeHead(table, model, columns, baseInfo, hasDate, rules);
+    let content = writeHead(info, columns, baseInfo, nconf);
 
     Object.keys(info).forEach(col => {
-        content += writeColumn(col, info[col], tab, columns, moment);
+        content += writeColumn(col, info[col], tab, columns, nconf);
     });
 
     if (nconf.get('rules')) {
@@ -52,24 +45,29 @@ module.exports = function(info, nconf) {
         content += writeTojson(info, tab);
     }
 
-    content += writeFoot(model, tab);
+    content += writeFoot(info, tab, nconf);
 
     return fs.outputFileSync(out, content);
 };
 
-function writeColumn(col, info, tab, columns, moment) {
+function writeColumn(col, info, tab, columns, conf) {
     let options = `'${info.type}'`;
 
     let type = 'string';
-    if (numberTypes.indexOf(info.type) > -1) {
+    if (boolTypes.indexOf(info.type) > -1 && info.length === 1) {
+        type = 'boolean';
+        options = `{ type: '${info.type}', transformer: booleanTransformer }`;
+    } else if (numberTypes.indexOf(info.type) > -1) {
         type = 'number';
     } else if (dateTypes.indexOf(info.type) > -1) {
-        if (moment) {
+        if (conf.get('moment')) {
             type = 'Moment';
             options = `{ type: '${info.type}', transformer: momentTransformer }`;
         } else {
             type = 'Date';
         }
+    } else if (conf.get('big') && info.type === 'decimal') {
+        type = 'Big';
     }
 
     let decorator = '@Column';
@@ -94,11 +92,3 @@ ${tab}${col}: ${type};
 
 `;
 }
-
-function writeFoot(model, tab) {
-    return `${tab}constructor(props?: Partial<${model}>) {
-${tab}${tab}super(props);
-${tab}}
-}
-`;
-}

write-rules.js

@@ -1,4 +1,4 @@
-const { numberTypes, dateTypes } = require('./constants');
+const { boolTypes, numberTypes, dateTypes } = require('./constants');
 
 module.exports = function(info, tab) {
     let content = `${tab}static rules() {
@@ -20,7 +20,9 @@ ${tab}}
 
 function getJoiRule(info) {
     let rule;
-    if (numberTypes.indexOf(info.type) > -1) {
+    if (boolTypes.indexOf(info.type) > -1 && info.length === 1) {
+        rule = 'joi.boolean()';
+    } else if (numberTypes.indexOf(info.type) > -1) {
         rule = 'joi.number()';
         if (info.type.indexOf('int') > -1) {
             rule += '.integer()';

zedconfig.json

@@ -5,8 +5,7 @@
         "tabSize": 4,
         "trimWhitespaceOnSave": true,
         "gotoExclude": [
-            "/node_modules",
-            "/node_modules/*"
+            "/node_modules/**"
         ]
     }
 }