WebStorm templates for JSX-files

Action Creators

var Dispatcher = require('../dispatcher/AppDispatcher'),
    ActionTypes = require('../constants/ActionConstants').ActionTypes;

module.exports = {
  someAction: function (data) {    
    Dispatcher.dispatch({
      type: ActionTypes.SOME_ACTION_TYPE,
      data: data
    });
  }
};

FLUX Store.js

var dispatcher = require('../dispatcher/AppDispatcher');
var EventEmitter = require('events').EventEmitter;
var assign = require('object-assign');
var _ = require('lodash');

var ActionTypes = require('../constants/ActionConstants').ActionTypes;
var CHANGE_EVENT = 'change';

var _currentData = null;

var ${NAME} = assign({}, EventEmitter.prototype, {

  init: function (data) {
    _currentData = data;
  },

  emitChange: function () {
    this.emit(CHANGE_EVENT);
  },

  /**
   * @param {function} callback
   */
  addChangeListener: function (callback) {
    this.on(CHANGE_EVENT, callback);
  },

  /**
   * @param {function} callback
   */
  removeChangeListener: function (callback) {
    this.removeListener(CHANGE_EVENT, callback);
  }

});


${NAME}.dispatchToken = dispatcher.register(function (action) {
  switch (action.type) {
    case ActionTypes.RECEIVE_DATA: //Example action
      ${NAME}.init(action.data); //Example action
      ${NAME}.emitChange();
      break;
    default:
    //do nothing
  }
});

module.exports = ${NAME};

JSX Component.jsx

/**
 * @jsx React.DOM
 */
var React = require('react');

var ${NAME} = React.createClass({
  render: function () {
    return (
      <span>Not yet implemented</span>
      );
    }
 });
 
 module.exports = ${NAME};

JSX Stateful Component.jsx

/**
 * @jsx React.DOM
 */
var React = require('react');
var ${STORE_NAME} = require('../stores/${STORE_NAME}');


var getStateFromStore = function () {
  return {
    someState: ${STORE_NAME}.getSomeState(),
  };
};

var ${NAME} = React.createClass({
  getInitialState: function () {
    return getStateFromStore();
  },

  componentDidMount: function () {
    ${STORE_NAME}.addChangeListener(this._onChange);
  },

  componentWillUnmount: function () {
    ${STORE_NAME}.removeChangeListener(this._onChange);
  },

  render: function () {
    return (<div>Not yet implemented</div>);
  },

  _onChange: function () {
    var newState = getStateFromStore();
    if (this.isMounted()) {
      this.setState(newState);
    }
  }

});

module.exports = ${NAME};

Mongoose CRUD Controller.js

var _ = require('lodash');
var ${NAME} = require('mongoose').model('${NAME}');
var internalError = require('../errors.controller').handleInternalError;

exports.list = function (req, res) {
  ${NAME}.find({}, function (err, ${variable_name}s) {
    if (err) {
      return internalError(res, err);
    }
    res.json(${variable_name}s);
  });
};

exports.load = function(req, res, next, id) {
  ${NAME}.findOne({ _id: id }, function(err, ${variable_name}) {
    if (err) return internalError(res, err);
    req.${variable_name} = ${variable_name};
    next();
  });
};

exports.create = function (req, res){
  var ${variable_name} = req.body;

  ${NAME}.create(${variable_name}, function(err, created${NAME}){
    if (err) {
      return internalError;
    }
    res.status(201).json(created${NAME});
  });
};

exports.retrieve = function(req, res){
  res.json(req.${variable_name});
};

exports.update = function(req, res) {
  var updated${NAME} = req.body;
  var ${variable_name} = _.extend(req.${variable_name}, updated${NAME});
  ${variable_name}.save(function(err, updated${NAME}) {
    if (err) {
      return internalError(res, err);
    }
    res.status(200).json(updated${NAME});
  });
};

exports.delete = function(req, res) {
  var ${variable_name} = req.${variable_name};
  ${variable_name}.remove(function(err) {
    if (err) {
      return internalError(res, err);
    }
    res.status(200).json({
      message: 'Deleted ${variable_name}',
      id: ${variable_name}.id
    });
  });
};

module.exports = exports;

Mongoose CRUD Route.js

var express = require('express');
var router = express.Router();

var ${NAME} = require('../../controllers/${NAME}.controller');

router.param('id', ${NAME}.load);

router.route('/')
    .post(${NAME}.create)
    .get(${NAME}.list);

router.route('/:id')
    .get(${NAME}.retrieve)
    .put(${NAME}.update)
    .delete(${NAME}.delete);


module.exports = router;

Mongoose Schema.js

var mongoose = require('mongoose');

var validationRegExExample = /^[^ ]+$/;

var ${NAME} = new mongoose.Schema({
  name: {
    type: String,
    trim: true,
    label: 'Navn',
    helpText: 'Det fulle navnet på systemet'
  },
  displayName: {
    type: String,
    trim: true,
    match: [/^[A-Z]/, 'Visningsnavnet må starte med stor bokstav'],
    required: true,
    maxlength: 25,
    label: 'Visningsnavn',
    helpText: 'Navnet slik det skal vises i brukergrensesnittet'
  },
  href: {
    type: String,
    trim: true,
    match: [ noSpaceRegEx, 'Adressen kan ikke inneholde mellomrom'],
    label: 'System-URL',
    helpText: 'Stien du vil skal vises i adresselinjen, la stå blank for automatisk generering'
  }
});

${NAME}.set('toJSON', {
  getters: true,
  virtuals: true
});


module.exports = ${NAME};