/* * 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`); }