Merge pull request #37 from Prefinem/parse

Transform types 'post' and 'pre'

README.md

@@ -138,22 +138,27 @@ Forces the value to be required. Is ignored if default value is set
 
 Requires the value that is passed in to be the correct datatype instead of coerced
 
-### datatypes.transform(transformFunction)
+### datatypes.transform(transformFunction, type = 'post')
 
 Takes a validated value, and transforms it according to the transform function
 
+#### Types
+
+-   `post` - happens after validation
+-   `pre` - happens before validation
+
 ```js
 const { createModel } = require('nativemodels');
 const { string } = require('nativiemodels/datatypes');
 
 const schema = {
 	name: string().transform((value) => value.toUpperCase()),
+	id: int().transform((value) => parseInt(value), 'pre'),
 };
 const model = createModel(schema);
-const user = model({ name: 'john' });
+const user = model({ name: 'john', id: '1' });
 
-console.log(user.name);
-// => 'JOHN'
+// => { name: 'JOHN', id: 1 }
 ```
 
 ### datatypes.from(fromKeys, options)

src/createModel.js

@@ -7,10 +7,12 @@ const recaseKeys = require('./lib/recaseKeys');
 const requireAllKeys = require('./lib/requireAllKeys');
 const requiredCheck = require('./lib/requiredCheck');
 const stripUndefinedKeys = require('./lib/stripUndefinedKeys');
+const transformRecord = require('./lib/transformRecord');
 
 const buildRecord = (schema, record, options) => {
 	const mappedRecord = mapRecord(schema, record, options.caseSensitive);
-	const stripedRecord = options.stripUndefined ? stripUndefinedKeys(schema, mappedRecord) : mappedRecord;
+	const transformedRecord = transformRecord(schema, mappedRecord);
+	const stripedRecord = options.stripUndefined ? stripUndefinedKeys(schema, transformedRecord) : transformedRecord;
 	const casedRecord = options.caseSensitive ? stripedRecord : recaseKeys(schema, stripedRecord);
 	const defaultedRecord = defaultRecord(schema, casedRecord);
 

src/datatypes/base.js

@@ -40,8 +40,9 @@ const chainable = {
 
 		return this;
 	},
-	transform(fn) {
-		this.transformFn = fn;
+	transform(fn, type = 'post') {
+		this.transforms = this.transforms || {};
+		this.transforms[type] = fn;
 
 		return this;
 	},

src/lib/parseValue.js

@@ -1,6 +1,7 @@
 /* eslint-disable max-params */
 const invalidTypeCheck = require('./checks/invalidType');
 const { isNull } = require('./checks/types');
+const transformValue = require('./transformValue');
 
 const checks = {
 	required: require('./checks/required'),
@@ -27,7 +28,7 @@ const parseValue = (type, key, value, allowNulls) => {
 
 	const parsedValue = type.parse(key, value);
 
-	return type.transformFn ? type.transformFn(parsedValue) : parsedValue;
+	return transformValue(type, parsedValue, 'post');
 };
 
 module.exports = parseValue;

src/lib/transformRecord.js

@@ -0,0 +1,12 @@
+const transformValue = require('./transformValue');
+
+const transformRecord = (schema, record) =>
+	Object.keys(record).reduce(
+		(result, key) => ({
+			...result,
+			[key]: schema[key] ? transformValue(schema[key], record[key], 'pre') : record[key],
+		}),
+		{},
+	);
+
+module.exports = transformRecord;

src/lib/transformValue.js

@@ -0,0 +1,4 @@
+const transformValue = (type, value, key) =>
+	type.transforms && type.transforms[key] ? type.transforms[key](value) : value;
+
+module.exports = transformValue;

tests/transform.test.js

@@ -0,0 +1,23 @@
+const {
+	createModel,
+	customtypes: { email },
+	datatypes: { string },
+} = require('./../src');
+
+test('transform - pre', async () => {
+	const schema = {
+		foo: email().transform((value) => (value === '' ? undefined : value), 'pre'),
+	};
+	const model = createModel(schema);
+
+	await expect(model({ foo: '' })).toEqual({});
+});
+
+test('transform - post', async () => {
+	const schema = {
+		foo: string().transform((value) => (value === '' ? 'bar' : value), 'post'),
+	};
+	const model = createModel(schema);
+
+	await expect(model({ foo: '' })).toEqual({ foo: 'bar' });
+});