@incdevco/framework/user/index.js

node.js lambda framework

var Promise = require('bluebird');
var Utilities = require('../utilities');

var defaultDefaults = {
  role: 'Guest',
  settings: {
    address: {},
    email_address: {},
    integrations: {},
    phone_number: {}
  },
  status: 'Active'
};

var defaultKeys = [
  'address',
  'email_address',
  'first_name',
  'full_name',
  'last_name',
  'name',
  'name_prefix',
  'name_pronunciation',
  'name_suffix',
  'phone_number',
  'photo_url',
  'settings'
];

var notAllowedKeys = [
  'cpii',
  'id',
  'last_updated',
  'role',
  'status'
];

module.exports.createAuthenticatedUser = function (request, config) {
  
  var ddb = config.ddb;
  
  var defaults = Utilities.merge(defaultDefaults, config.defaults);
  
  var body = Utilities.copy(request.body);
  
  var keys = config.keys || defaultKeys;
    
  var tableName = config.tableName;
  
  var user = {};

  Object.keys(defaults).forEach(function (key) {
    
    if (notAllowedKeys.indexOf(key) >= 0) {
      
      return;
      
    }
    
    user[key] = defaults[key];
    
  });
  
  keys.forEach(function(key) {
    
    if (notAllowedKeys.indexOf(key) >= 0) {
      
      return;
      
    }
    
    user[key] = body[key];
    
  });
  
  user.cpii = this.createAuthenticatedUserCpii(request);
  user.created_epoch = Utilities.getCurrentEpoch();
  user.role = 'Guest';
  
  Utilities.setLastUpdatedFromRequest(request, user);
    
  return Promise.try(function () {
    
    if (!ddb) {
      
      throw new Error('config.ddb is required');
      
    }
    
    if (!tableName) {
      
      throw new Error('config.tableName is required');
      
    }
    
    if (!request.cognito) {
      
      throw new Error('no authentcated user (request.cognito)');
      
    }
    
    function attempt() {
      
      user.id = Utilities.randomNumberInclusive(1000000000, 9999999999)
        .toString();
      
      return ddb.put({
        ConditionExpression: 'attribute_not_exists(#id)' 
          + ' OR attribute_not_exists(#cpii)',
        ExpressionAttributeNames: {
          '#cpii': 'cpii',
          '#id': 'id'
        },
        Item: user,
        TableName: tableName
      })
      .catch(function (exception) {
        
        if (Utilities.ddbIsConditionalException(exception)) {
          
          return Promise.delay(250)
          .then(function () {
            
            return attempt();
            
          });
          
        }
        
        throw exception;
        
      });
      
    }
    
    return attempt();
    
  })
  .then(function () {
    
    return user;
    
  });
  
};

module.exports.createAuthenticatedUserCpii = function (event) {
  
  var cpii = '';
  
  if (event.cognito) {
    
    cpii += event.cognito.identityId;
    
    cpii += ':';
    
    cpii += event.cognito.identityPoolId;
    
  }
  
  return cpii;
  
};

module.exports.getAuthenticatedUser = function (request, config) {
  
  var cpii = this.createAuthenticatedUserCpii(request);
  
  var ddb = config.ddb;
  
  var tableName = config.tableName;
  
  return Promise.try(function () {
    
    if (!ddb) {
      
      throw new Error('config.ddb is required');
      
    }
    
    if (!tableName) {
      
      throw new Error('config.tableName is required');
      
    }
    
    if (!request.cognito) {
      
      throw new Error('No Authenticated User (request.cognito)');
      
    }
    
    return ddb.query({
      ConsistentRead: false,
      ExpressionAttributeNames: {
        '#cpii': 'cpii'
      },
      ExpressionAttributeValues: {
        ':cpii': cpii
      },
      IndexName: 'cpii',
      KeyConditionExpression: '#cpii = :cpii',
      TableName: tableName
    });
    
  })
  .then(function (result) {
    
    var user;
    
    if (result.Items.length) {
      
      user = result.Items[0];
      
      console.log('user', JSON.stringify(user, null, 2));
      
      return user;
      
    } else {
      
      return null;
      
    }
    
  });
  
};

module.exports.updateAuthenticatedUser = function (request, config) {
  
  var cpii = this.createAuthenticatedUserCpii(request);
  
  var ddb = config.ddb;
  
  var keys = config.keys || defaultKeys;
  
  var user = Utilities.copy(request.body);
    
  var tableName = config.tableName;

  var expressionAttributeNames = {
    '#cpii': 'cpii',
    '#last_updated': 'last_updated'
  };
  
  var expressionAttributeValues = {
    ':cpii': cpii,
    ':last_updated': user.last_updated,
    ':submitted_epoch': request.body.last_updated.epoch
  };
  
  var updateExpression = 'SET #last_updated = :last_updated';
  
  keys.forEach(function (key) {
    
    if (notAllowedKeys.indexOf(key) >= 0) {
      
      return;
      
    }
    
    expressionAttributeNames['#' + key] = key;
    
    expressionAttributeValues[':' + key] = user[key] || null;
    
    updateExpression += ', #' + key + ' = :' + key;
    
  });
  
  Utilities.setLastUpdatedFromRequest(request, user);
  
  return Promise.try(function () {
    
    if (!ddb) {
      
      throw new Error('config.ddb is required');
      
    }
    
    if (!tableName) {
      
      throw new Error('config.tableName is required');
      
    }
    
    if (!request.cognito) {
      
      throw new Error('no authentcated user (request.cognito)');
      
    }
    
    return ddb.update({
      ConditionExpression: '#cpii = :cpii'
        + ' AND #last_updated.epoch = :submitted_epoch',
      ExpressionAttributeNames: expressionAttributeNames,
      ExpressionAttributeValues: expressionAttributeValues,
      Key: {
        id: user.id
      },
      TableName: tableName,
      UpdateExpression: updateExpression
    });
    
  })
  .then(function () {
    
    return user;
    
  });
  
};