Custom types

README.md

@@ -41,6 +41,42 @@ Fortune implements everything you need to get started with JSON API, with a few
 
 It does not come with any authentication or authorization, you should implement your own application-specific logic (see [keystore.js](//github.com/daliwali/fortune/blob/master/examples/keystore.js) for an example).
 
+#### Custom Types
+
+Custom type defines its own schema and hooks and might be injected to any resource's schema side by side to standard data types and incorporates its data hooks into the resources' ones.
+Usage example:
+
+```
+   app.customType("date-timezone", {
+     date: String,
+     timeZone: String
+   }).beforeWrite([{
+     name: 'datetz2db',
+     priority: -1,
+     init: function() {
+       return function(req, res) {
+         return DateTz.todb(this)
+       }
+     }
+   }]).afterRead([{
+     name: 'datetz4db',
+     priority: 1000,
+     init: function() {
+       return function(req, res) {
+         return DateTz.fromdb(this);
+       }
+     }
+   }]) 
+
+   app.resource("schedule", {
+   ...
+     arrival: 'date-timezone'
+   ...
+   })
+ ```
+
+ The datetz2db and datetz4db will be automatically attached to the parent resource hook chain.
+
 ## Guide & Documentation
 
 The full guide and API documentation are located at [fortunejs.com](http://fortunejs.com/).

lib/fortune.js

@@ -189,7 +189,7 @@ Fortune.prototype.resources = function(req){
   var _this = this;
 
   function filterHooks(hooks, time, type, resource, name){
-    var ary = hooks[time][type];
+    var ary = (hooks[time] || [])[type] || [];
     return _.reduce(_this._hookFilters, function(memo, filter){
       return filter(memo, name, time.replace('_', ''), type, resource)
     }, ary);
@@ -198,18 +198,19 @@ Fortune.prototype.resources = function(req){
   var resources = _.map(_this._resources, function(md, name){
     var schema = _.clone(md.schema);
 
-    _.each(schema, function(v,k){
-      var vIsFunction = _.isFunction(v),
-          typeFn = vIsFunction ? v : v.type;
-
-      if(typeFn){
-        typeFn = typeFn.toString();
-        typeFn = typeFn.substr('function '.length);
-        typeFn = typeFn.substr(0, typeFn.indexOf('('));
+    var jsonFriendify = function(schema) {
+      _.each(schema, function(v,k){
+        if(_.isFunction(v)){
+          schema[k] = v.name;
+        }
+        else if(_.isObject(v)) {
+          schema[k] = jsonFriendify(v);
+        }
+      });
+      return schema;
+    }
 
-        schema[k] = vIsFunction ? typeFn : _.extend({}, v, {type: typeFn});
-      }
-    });
+    schema = jsonFriendify(schema);
 
     var hooks = {
       beforeRead: _.map(filterHooks(md.hooks, '_before', 'read', {}, name), function(h){ return h.name}),
@@ -252,6 +253,14 @@ Fortune.prototype._exposeResourceDefinitions = function() {
   });
 };
 
+Fortune.prototype.customType = function(name, schema, options, schemaCallback) {
+  this._customTypes = this._customTypes || {}
+  this._customTypes[name] = _.extend({}, options, { name: name, schema: schema })
+  this._resource = name;
+
+  return this;
+}
+
 /**
  * Define a resource and setup routes simultaneously. A schema field may be either a native type, a plain object, or a string that refers to a related resource.
  *
@@ -303,6 +312,20 @@ Fortune.prototype.resource = function(name, schema, options, schemaCallback) {
     return this;
   }
 
+  var customTypes = {};
+  schema = _.mapValues(schema, function(value, key) {
+    if((typeof value).toLowerCase() === "string") {
+
+      // Verify there is a custom type with the name
+      var customType = _this._customTypes[value];
+      customTypes[key] = customType;
+
+      // Custom type has Mixed schema instead
+      return customType.schema;
+    }
+    return value;
+  });
+
   this._resources = this._resources || {};
   this._resources[name] = {
     actions: actionsObj,
@@ -316,8 +339,47 @@ Fortune.prototype.resource = function(name, schema, options, schemaCallback) {
     authMethods: authMethods,
     validation: validation
   };
+
   plugins.init(this, this._resources[name]);
+
   hooks.initGlobalHooks(_this._resources[name], _this.options);
+
+  var customHooks = _.flatten(_.map(_.keys(customTypes), function(key) {
+    // Modify a names of the hooks to include field name they applied to
+    _.each(customTypes[key].hooks, function(whenHooks, when) {
+      _.each(whenHooks, function(actionHooks, action) {
+        _.each(actionHooks, function(actionHook) {
+          if(actionHook.name) {
+            actionHook.name = [key, actionHook.name].join('-');
+          }
+          // Set highest priority
+          actionHook.priority = 1000;
+
+          // Bind the handler to particular data type
+          var handler = actionHook.fn
+          if(handler) {
+            actionHook.fn = function(req, res) {
+              if(this[key]) {
+                this[key] = handler.call(this[key], req, res);
+              }
+              return this;
+            }
+          }
+        });
+      });
+    })
+    return customTypes[key].hooks;
+  }));
+
+  function mergeArray(to, from) {
+    if(_.isArray(to) && _.isArray(from)) {
+      return (to || []).concat(from);
+    }
+  }
+
+  var mergedHooks = _.merge(_.merge.apply(this, customHooks, mergeArray) || {}, _this._resources[name].hooks, mergeArray);
+  _this._resources[name].hooks = mergedHooks;
+
   //Register updates in queryParser. Should be called here to make sure that all resources are registered
   _this._exposeResourceDefinitions();
   _this._querytree = querytree.init(this);
@@ -338,15 +400,15 @@ Fortune.prototype.resource = function(name, schema, options, schemaCallback) {
     function () {
     schema = _this._preprocessSchema(schema);
 
-    // Store a copy of the input.
-    _this._schema[name] = _.clone(schema);
     try {
+      // Store a copy of the input.
+      _this._schema[name] = _.clone(schema);
       schema = _this.adapter.schema(name, schema, options, schemaCallback);
 
       // Pass any upsertKeys to the schema
       schema.upsertKeys = upsertKeys || [];
 
-      _this._route(name, _this.adapter.model(name, schema,modelOptions), _this._resources, inflect, _this._querytree, _this._metadataProviders);
+      _this._route(name, _this.adapter.model(name, schema, modelOptions), _this._resources, inflect, _this._querytree, _this._metadataProviders);
       _this._resourceInitialized();
     } catch(error) {
       console.trace('There was an error loading the "' + name + '" resource. ' + error.stack || err);
@@ -436,7 +498,6 @@ function GlobalHook(time, type){
 }
 
 function Hook(time, type){
-
   return function(name, hooksArray, inlineConfig){
     var that = this;
     if (this.options.throwOnLegacyTransforms && (_.isFunction(name) || _.isFunction(hooksArray))){

lib/hooks.js

@@ -89,18 +89,23 @@ exports.addHook = function(name, hooks, stage, type, inlineConfig){
 
   name.split(' ').forEach(function(resourceName) {
     hooks = normalize(hooks);
-    var resource = _this._resources[resourceName];
-    if (!resource){
-      return console.warn('You are trying to attach a hook to %s, ' +
-        'that is not defined in this instance of fortune', resourceName);
+
+    var resource;
+    if (!_this._resources || !_this._resources[resourceName]) {
+      if(!_this._customTypes || !_this._customTypes[resourceName]) {
+        return console.warn('You are trying to attach a hook to %s, ' +
+          'that is not defined in this instance of fortune', resourceName);
+      }
+      else resource = _this._customTypes[resourceName];
     }
+    else resource = _this._resources[resourceName];
+
     resource.hooks = resource.hooks || {};
     resource.hooks[stage] = resource.hooks[stage] || {};
     resource.hooks[stage][type] = resource.hooks[stage][type] || [];
     _.each(hooks, function(hook){
       var hookOptions = getHookConfig(hook, resource, inlineConfig);
       var fn = hook.init(hookOptions, _this);
-      //fn._priority = hook.priority || 0;
       resource.hooks[stage][type].push(_.extend({
           _priority: hook.priority || 0,
           name: hook.name,

lib/route.js

@@ -175,7 +175,7 @@ function route(name, model, resources, inflect, querytree, metadataProviders) {
           instrumentor.createTracer( tracePrefix,  function(resolve, reject){
         //If no transforms found for this resource return without change
         var hooks = resources[model].hooks;
-        if (!hooks[time][type]) return resolve(resource);
+        if (!hooks[time] || !hooks[time][type]) return resolve(resource);
         resource = _.extend(resource, isNew);
         var transform = resource;
         _.each(filterHooks(hooks, time, type, resource, name), function(h){

test/app.js

@@ -19,7 +19,7 @@ var hooks = {};
         if (req.query['fail' + type]) {
           console.log('Failing hook',type);
           _.defer(function() {
-            res.send(321);
+            res.sendStatus(321);
           });
           if (req.query['fail' + type] === 'boolean')
             return false;
@@ -66,14 +66,32 @@ module.exports = function(options, port, ioPort) {
     }
   }]);
 
-
   app.beforeAll(hooks.beforeAll)
     .beforeAllRead(hooks.beforeAllRead)
     .beforeAllWrite(hooks.beforeAllWrite)
     .afterAll(hooks.afterAll)
     .afterAllRead(hooks.afterAllRead)
     .afterAllWrite(hooks.afterAllWrite)
-
+    .customType("location", {
+      lat: Number,
+      lon: Number
+    })
+    .beforeWrite([{
+      name: 'todb',
+      init: function() {
+        return function(req, res){
+          return this;
+        }
+      }
+    }])
+    .afterRead([{
+      name: 'fromdb',
+      init: function(){
+        return function(req, res){
+          return this;
+        }
+      }
+    }])
     .resource('person', {
       name: String,
       official: String,
@@ -97,6 +115,7 @@ module.exports = function(options, port, ioPort) {
         nestedField1: String,
         nestedField2: Number
       }],
+      location: 'location',
       upsertTest : String,
       _tenantId: String
     }, {
@@ -195,7 +214,7 @@ module.exports = function(options, port, ioPort) {
 
     .before('person pet', function(req, res){
       if (this.email === '[email protected]'){
-        res.send(321);
+        res.sendStatus(321);
         return false;
       }
       return this;