Is there any example code which shows database connection ?

[whatifif]

what will be the best practice to connect to database in this complex starter kit?

Is there any example code which shows database connection?

[koistya]

It might be a good idea to open a db connection before launching HTTP server. Here is an example: https://medium.com/@tarkus/how-to-open-database-connections-in-a-node-js-express-app-e14b2de5d1f8

[tearsofphoenix]

@whatifif Like this:

import mongoose from 'mongoose';
import auth from '../../lib/auth';
import config from '../../config';
const Admin = mongoose.model('Admin');

export default function login(req) {

  return new Promise((resolve, reject) => {
    // make async call to database
    var email = req.body.email;
    var password = req.body.password;
    console.log(req.body);
    if (email && password) {

      Admin.findOne({email: email}, function (error, doc) {

        if (doc) {
          if (doc.validPassword(password)) {
            doc.password = null;
            req.session.user = doc;

            resolve({
              code: config.code.success,
              user: doc,
              access_token: auth.genToken(doc.id)
            });
          } else {
            reject({
              code: -1,
              msg: 'wrong password！'
            });
          }
        } else {
          reject({
            code: -1,
            msg: 'email not exists!'
          });
        }
      });
    } else {
      reject({
        code: -1,
        msg: 'missing arguments!'
      });
    }
  });
}

[whatifif]

Thanks for kind answers.

For the case of widgets, _api/actions/widget/load_ seems a good place to fetch data from database like below:

//api/actions/widget/load.js

import mongoose from 'mongoose'

const WidgetSchema = new mongoose.Schema({
  id: {type: mongoose.Schema.ObjectId},
  color: { type: String},
  sprocketCount: {type: Number},
  owner: { type: String}
})

const WidgetModel = mongoose.model('Widget', WidgetSchema);

export default function load(req, params){
// params may be used at this stage to retrieve what you want exactly

    return new Promise((resolve, reject) => {
        WidgetModel.find({}).then(function(result){
            resolve(result);
          }, function(err){
            reject(err);
         })
     })
}

[whatifif]

For updating a widget, _api/actions/widget/update_ seems a good place to do this like below:

//api/actions/widget/update.js

//I put the WidgetModel in the same directory for the easy maintenance.
import { WidgetModel } from './resource/WidgetModel';

export default function update(req, params) {

  const widget = req.body;

  return new Promise((resolve, reject) => {
    // write to database
    WidgetModel.update({id: widget.id}, widget).then(function(result){
      resolve(widget);// This returns the updated widget instead of result
    }, function(err){
      reject(err);
    })
  });
}

[JoeGrasso]

If anyone is interested, here in my mongoose solution to the api:

In api/api.js:

const mongoUrl = "mongodb://127.0.0.1/_new_redux_universal";
mongoose.connect(mongoUrl, (err) => {
  if (err) {
    console.log('Please make sure MongoDb is up and running');
    throw error;
  }
});

In widget/load.js:

const initialWidgets = [
  {id: 1, color: 'Red', sprocketCount: 7, owner: 'John'},
  {id: 2, color: 'Taupe', sprocketCount: 1, owner: 'George'},
  {id: 3, color: 'Green', sprocketCount: 8, owner: 'Ringo'},
  {id: 4, color: 'Blue', sprocketCount: 2, owner: 'Paul'}
];

require('./model');
const Widget = require('mongoose').model('WidgetModel');

function seedWidgets() {
  let results = [];
  return new Promise((resolve, reject) => {
    Widget.find({}, (err, collection) => {
      if (collection.length === 0) {
        initialWidgets.map(widget => {
          Widget.create(widget);
          results.push(widget);
        });
      }
      if (err) reject(err);
      else resolve(results);
    })
  });
}

export default function load() {
  return new Promise((resolve, reject) => {
        resolve(getWidgets());
  });
}
export default function getWidgets() {
  return new Promise((resolve, reject) => {
    seedWidgets().then((result) => {
      Widget.find({}).then((result) => {
        resolve(result);
      })
    }).catch((err) => {
      reject(err);
    })
  });
}

In widget/update.js:

require('./model');
const Widget = require('mongoose').model('WidgetModel');

export default function update(req) {
  const currWidget = {
    id: req.body.id,
    color: req.body.color,
    sprocketCount: req.body.sprocketCount,
    owner: req.body.owner
  };
  return new Promise((resolve, reject) => {
    const widget = req.body;

    // write to database
    Widget.update({id: widget.id}, widget).then(function (result) {
      resolve(widget);// This returns the updated widget instead of result
    }, function (err) {
      console.log(err);
      reject(err);
    })
  })
}

api/model.js:

import mongoose from 'mongoose'

const WidgetSchema = new mongoose.Schema({
  id: { type: Number},
  color: { type: String},
  sprocketCount: {type: Number},
  owner: { type: String}
});

exports.WidgetModel = mongoose.model('WidgetModel', WidgetSchema, 'Widget');