How to use

isPlainObject

function

in

LoDashStatic

/*
 * Helper to get the applications environment variables
 */
const getPlatformVariables = app => {
 const strippedVars = _.omit(_.get(app, 'variables', {}), ['env']);

 // Loop through and try to build things out
 const vars = {};
 _.forEach(strippedVars, (value, key) => {
  if (_.isPlainObject(value)) {
   // @NOTE sorry to my CS teacher for these names
   _.forEach(value, (value2, key2) => {
    vars[`${key}:${key2}`] = value2;
   });
  } else {
   vars[key] = value;
  }
 });

 // Merge in needed local overrides and encode
 return encode(_.merge({}, vars, overrides));
}

is_field_default_value_valid(modelSchema, fieldName) {
  if (_.isPlainObject(modelSchema.fields[fieldName]) && modelSchema.fields[fieldName].default) {
   if (_.isPlainObject(modelSchema.fields[fieldName].default)
     && !(modelSchema.fields[fieldName].default.$db_function)) {
    return ['map', 'list', 'set', 'frozen'].includes(modelSchema.fields[fieldName].type);
   }
   return true;
  }
  return true;
 }

var buildQueryRelations = function buildQueryRelations(fieldNameLocal, relationValueLocal) {
  var dbVal = parser.get_db_value_expression(schema, fieldNameLocal, relationValueLocal);
  if (_.isPlainObject(dbVal) && dbVal.query_segment) {
   queryRelations.push(util.format(whereTemplate, fieldNameLocal, operator, dbVal.query_segment));
   queryParams.push(dbVal.parameter);
  } else {
   queryRelations.push(util.format(whereTemplate, fieldNameLocal, operator, dbVal));
  }
 }

fieldValue.map(function (v) {
   var dbVal = parser.get_db_value_expression(schema, fieldName, v);

   if (_.isPlainObject(dbVal) && dbVal.query_segment) return dbVal.parameter;
   return dbVal;
  })

_makeType(factoryType, body, ...args) {
    if (_.isPlainObject(body)) {
      body = this.parser._resolveStringTypes(body);
    }
    else if (_.isString(body)) {
      body = this.parser._resolveStringType(body);
    }
    return { type: new factoryType(body, ...args), body };
  }

get_field_type(modelSchema, fieldName) {
  const fieldObject = modelSchema.fields[fieldName];

  if (typeof fieldObject === 'string') {
   return fieldObject;
  }
  if (_.isPlainObject(fieldObject)) {
   return fieldObject.type;
  }
  throw (new Error(`Type of field "${fieldName}" not defined properly`));
 }

parse(def) {
    if (_.isPlainObject(def)) {
      return this._parseObject(def);
    }
    if (_.isString(def)) {
      return this._parseString(def);
    }
    assert(false, 'Argument is not a function definition.');
  }

hooks.filter(function(value) {
    if (_.isPlainObject(value) && value.name === name) {
      return false;
    }
    return true;
  })

build(query) {
    if (!_.isPlainObject(query)) {
      throw new Error(`Query must always be an Object.`);
    }

    this._initBuilder();

    return {
      sql: this._queryUnknown(query, null, '; '),
      values: this.currentValues()
    }
  }

var configOrPlugins = function(opts) {
 if (!_.isPlainObject(opts)) {
  return;
 }

 _.forIn(opts, function(value, key) {
  if (key === 'plugins') {
   plugins(value);
  } else {
   config(key, value);
  }
 });
}

function addDependencyOnDeployment (state, deploymentName) {
  var findBasePathMapping = function (child) {
    return _.isPlainObject(child) && child.Type === 'AWS::ApiGateway::BasePathMapping';
  };
  var basePathMapping = pickFromTree(state, findBasePathMapping)[0];
  basePathMapping.DependsOn = [deploymentName];
}

is_field_default_value_valid(modelSchema, fieldName) {
  if (_.isPlainObject(modelSchema.fields[fieldName]) && modelSchema.fields[fieldName].default) {
   if (_.isPlainObject(modelSchema.fields[fieldName].default) && !modelSchema.fields[fieldName].default.$db_function) {
    return ['map', 'list', 'set', 'frozen'].includes(modelSchema.fields[fieldName].type);
   }
   return true;
  }
  return true;
 }

function getDeploymentName (state) {
  var findDeployment = function (child) {
    return _.isPlainObject(child) && child.Type === ('AWS::ApiGateway::Deployment');
  };
  var getName = function (child, key) {
    return key;
  };
  return pickFromTree(state, findDeployment, getName)[0];
}

parse(def, typeHint) {
    if (_.isPlainObject(def)) {
      return this._parseObject(def, typeHint);
    }
    if (_.isString(def)) {
      return this._parseString(def, typeHint);
    }
    assert(false, 'Argument is not a ref type definition.');
  }

get_field_type(modelSchema, fieldName) {
  var fieldObject = modelSchema.fields[fieldName];

  if (typeof fieldObject === 'string') {
   return fieldObject;
  }
  if (_.isPlainObject(fieldObject)) {
   return fieldObject.type;
  }
  throw new Error(`Type of field "${fieldName}" not defined properly`);
 }