@openfn/language-mysql 1.1.2 → 1.3.0

package/node_modules/json-sql/lib/dialects/base/index.js

@@ -1,353 +0,0 @@
-'use strict';
-
-var _ = require('underscore');
-var ValuesStore = require('../../utils/valuesStore');
-var objectUtils = require('../../utils/object');
-
-var templatesInit = require('./templates');
-var blocksInit = require('./blocks');
-var operatorsInit = require('./operators');
-var modifiersInit = require('./modifiers');
-
-var blockRegExp = /\{([a-z0-9]+)\}(.|$)/ig;
-
-var Dialect = module.exports = function(builder) {
-	this.builder = builder;
-
-	this.templates = new ValuesStore();
-	this.blocks = new ValuesStore();
-	this.operators = {
-		comparison: new ValuesStore(),
-		logical: new ValuesStore(),
-		fetching: new ValuesStore(),
-		state: new ValuesStore()
-	};
-	this.modifiers = new ValuesStore();
-
-	// init templates
-	templatesInit(this);
-
-	// init blocks
-	blocksInit(this);
-
-	// init operators
-	operatorsInit(this);
-
-	// init modifiers
-	modifiersInit(this);
-
-	this.identifierPartsRegexp = new RegExp(
-		'(\\' + this.config.identifierPrefix + '[^\\' + this.config.identifierSuffix + ']*\\' +
-			this.config.identifierSuffix + '|[^\\.]+)', 'g'
-	);
-	this.wrappedIdentifierPartRegexp = new RegExp(
-		'^\\' + this.config.identifierPrefix + '.*\\' + this.config.identifierSuffix + '$'
-	);
-};
-
-Dialect.prototype.config = {
-	identifierPrefix: '"',
-	identifierSuffix: '"'
-};
-
-Dialect.prototype._wrapIdentifier = function(name) {
-	if (this.builder.options.wrappedIdentifiers) {
-		var self = this;
-		var nameParts = name.match(this.identifierPartsRegexp);
-
-		return _(nameParts).map(function(namePart) {
-			if (namePart !== '*' && !self.wrappedIdentifierPartRegexp.test(namePart)) {
-				namePart = self.config.identifierPrefix + namePart + self.config.identifierSuffix;
-			}
-
-			return namePart;
-		}).join('.');
-	}
-
-	return name;
-};
-
-Dialect.prototype.buildLogicalOperator = function(params) {
-	var self = this;
-
-	var operator = params.operator;
-	var value = params.value;
-
-	if (objectUtils.isSimpleValue(value)) {
-		value = _.object([params.defaultFetchingOperator], [value]);
-	}
-
-	if (_.isEmpty(value)) return '';
-
-	var result;
-
-	if (_.isArray(value)) {
-		// if value is array: [{a: 1}, {b: 2}] process each item as logical operator
-		result = _(value).map(function(item) {
-			return self.buildOperator({
-				context: 'logical',
-				contextOperator: operator,
-				operator: '$and',
-				value: item,
-				states: [],
-				defaultFetchingOperator: params.defaultFetchingOperator
-			});
-		});
-	} else {
-		result = _(value).map(function(item, field) {
-			// if field name is not a operator convert it to {$field: {name: 'a', $eq: 'b'}}
-			if (field[0] !== '$') {
-				if (objectUtils.isSimpleValue(item) || _.isArray(item)) {
-					item = {$eq: item};
-				}
-				item = _.defaults({name: field}, item);
-				field = '$field';
-			}
-
-			return self.buildOperator({
-				context: 'logical',
-				contextOperator: operator,
-				operator: field,
-				value: item,
-				states: [],
-				defaultFetchingOperator: params.defaultFetchingOperator
-			});
-		});
-	}
-
-	return this.operators.logical.get(operator).fn(_.compact(result));
-};
-
-Dialect.prototype.buildComparisonOperator = function(params) {
-	var self = this;
-
-	var operator = params.operator;
-
-	_(params.states).each(function(state) {
-		operator = self.operators.state.get(state).getOperator(operator);
-	});
-
-	var operatorParams = this.operators.comparison.get(operator);
-
-	var value = this.buildEndFetchingOperator({
-		context: 'comparison',
-		contextOperator: operator,
-		value: params.value,
-		states: params.states,
-		defaultFetchingOperator: operatorParams.defaultFetchingOperator ||
-			params.defaultFetchingOperator
-	});
-
-	return operatorParams.fn(params.field, value);
-};
-
-Dialect.prototype.buildFetchingOperator = function(params) {
-	var operator = params.operator;
-	var value = params.value;
-
-	var field = this.operators.fetching.get(operator).fn(value, params.end);
-
-	var result;
-	if (params.end || objectUtils.isSimpleValue(value)) {
-		result = field;
-	} else {
-		result = this.buildOperatorsGroup({
-			context: 'fetching',
-			contextOperator: operator,
-			operator: '$and',
-			field: field,
-			value: value,
-			states: params.states,
-			defaultFetchingOperator: params.defaultFetchingOperator
-		});
-	}
-
-	return result;
-};
-
-Dialect.prototype.buildEndFetchingOperator = function(params) {
-	var self = this;
-
-	var value = params.value;
-	var operator;
-
-	if (objectUtils.isObjectObject(value)) {
-		// get first query operator
-		operator = _(value).findKey(function(item, operator) {
-			return operator[0] === '$' && self.operators.fetching.has(operator);
-		});
-
-		if (operator) {
-			value = value[operator];
-		}
-	}
-
-	return this.buildOperator(_.extend({}, params, {
-		operator: operator || params.defaultFetchingOperator,
-		value: value,
-		end: true
-	}));
-};
-
-Dialect.prototype.buildStateOperator = function(params) {
-	return this.buildOperatorsGroup(_.extend({}, params, {
-		context: 'state',
-		contextOperator: params.operator,
-		operator: '$and',
-		states: params.states.concat(params.operator)
-	}));
-};
-
-Dialect.prototype.buildOperatorsGroup = function(params) {
-	var self = this;
-
-	var value = params.value;
-
-	var result;
-	if (objectUtils.isObjectObject(value)) {
-		result = this.operators.logical.get(params.operator).fn(
-			_(value)
-				.chain()
-				.map(function(item, operator) {
-					if (operator[0] !== '$') return '';
-
-					if (self.operators.fetching.has(operator)) {
-						// convert {a: {$field: 'b'}} to {a: {$eq: {$field: 'b'}}}
-						item = _.object([operator], [item]);
-						operator = '$eq';
-					}
-
-					return self.buildOperator(_.extend({}, params, {
-						operator: operator,
-						value: item
-					}));
-				})
-				.compact()
-				.value()
-		);
-
-		if (!result) result = params.field;
-	} else {
-		result = this.buildEndFetchingOperator(params);
-	}
-
-	return result;
-};
-
-Dialect.prototype.buildOperator = function(params) {
-	var isContextValid = function(expectedContexts, context) {
-		return _.contains(expectedContexts, context);
-	};
-
-	var context = params.context;
-	var operator = params.operator;
-
-	var result;
-
-	var contexts = _(this.operators).mapObject(function(operatorsGroup) {
-		return operatorsGroup.has(operator);
-	});
-
-	if (!_(contexts).some()) {
-		throw new Error('Unknown operator "' + operator + '"');
-	}
-
-	if (contexts.logical && isContextValid(['null', 'logical'], context)) {
-		result = this.buildLogicalOperator(params);
-	} else if (contexts.fetching && isContextValid(['logical', 'comparison'], context)) {
-		result = this.buildFetchingOperator(params);
-	} else if (contexts.comparison && isContextValid(['fetching', 'state'], context)) {
-		result = this.buildComparisonOperator(params);
-	} else if (contexts.state && isContextValid(['fetching', 'state'], context)) {
-		result = this.buildStateOperator(params);
-	} else {
-		var errMessage = 'Unexpected operator "' + operator + '" at ' +
-			(context === 'null' ? 'null ' : '') + 'context';
-
-		if (params.contextOperator) {
-			errMessage += ' of operator "' + params.contextOperator + '"';
-		}
-
-		throw new Error(errMessage);
-	}
-
-	return result;
-};
-
-Dialect.prototype.buildCondition = function(params) {
-	return this.buildOperator({
-		context: 'null',
-		operator: '$and',
-		value: params.value,
-		states: [],
-		defaultFetchingOperator: params.defaultFetchingOperator
-	});
-};
-
-Dialect.prototype.buildModifier = function(params) {
-	var self = this;
-
-	return _(params.modifier)
-		.chain()
-		.map(function(values, field) {
-			var modifier;
-
-			if (field[0] === '$') {
-				modifier = field;
-			} else {
-				modifier = '$set';
-				values = _.object([field], [values]);
-			}
-
-			var modifierFn = self.modifiers.get(modifier);
-
-			if (!modifierFn) {
-				throw new Error('Unknown modifier "' + modifier + '"');
-			}
-
-			return _(values).map(function(value, field) {
-				field = self._wrapIdentifier(field);
-				value = self.buildBlock('term', {term: value, type: 'value'});
-
-				return modifierFn(field, value);
-			});
-		})
-		.flatten()
-		.compact()
-		.value()
-		.join(', ');
-};
-
-Dialect.prototype.buildBlock = function(block, params) {
-	var blockFn = this.blocks.get(block);
-
-	if (!blockFn) {
-		throw new Error('Unknown block "' + block + '"');
-	}
-
-	return blockFn(params);
-};
-
-Dialect.prototype.buildTemplate = function(type, params) {
-	var self = this;
-
-	var template = this.templates.get(type);
-	if (!template) {
-		throw new Error('Unknown template type "' + type + '"');
-	}
-
-	params = _.defaults({}, params, template.defaults);
-
-	if (template.validate) {
-		template.validate(type, params);
-	}
-
-	return template.pattern.replace(blockRegExp, function(fullMatch, block, space) {
-		if (_.isUndefined(params[block])) {
-			return '';
-		} else {
-			if (self.blocks.has(type + ':' + block)) block = type + ':' + block;
-			return self.buildBlock(block, params) + space;
-		}
-	}).trim();
-};

package/node_modules/json-sql/lib/dialects/base/modifiers.js

@@ -1,27 +0,0 @@
-'use strict';
-
-module.exports = function(dialect) {
-	dialect.modifiers.add('$set', function(field, value) {
-		return [field, '=', value].join(' ');
-	});
-
-	dialect.modifiers.add('$inc', function(field, value) {
-		return [field, '=', field, '+', value].join(' ');
-	});
-
-	dialect.modifiers.add('$dec', function(field, value) {
-		return [field, '=', field, '-', value].join(' ');
-	});
-
-	dialect.modifiers.add('$mul', function(field, value) {
-		return [field, '=', field, '*', value].join(' ');
-	});
-
-	dialect.modifiers.add('$div', function(field, value) {
-		return [field, '=', field, '/', value].join(' ');
-	});
-
-	dialect.modifiers.add('$default', function(field) {
-		return [field, '=', 'default'].join(' ');
-	});
-};

package/node_modules/json-sql/lib/dialects/base/operators/comparison.js

@@ -1,245 +0,0 @@
-'use strict';
-
-var buildComparisonOperator = function(field, operator, value) {
-	return [field, operator, value].join(' ');
-};
-
-var buildBooleanOperator = function(field, operator, value) {
-	return buildComparisonOperator(field, 'is' + (value ? '' : ' not'), operator);
-};
-
-module.exports = function(dialect) {
-	dialect.operators.comparison.add('$eq', {
-		inversedOperator: '$ne',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, '=', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$ne', {
-		inversedOperator: '$eq',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, '!=', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$gt', {
-		inversedOperator: '$lte',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, '>', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$lt', {
-		inversedOperator: '$gte',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, '<', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$gte', {
-		inversedOperator: '$lt',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, '>=', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$lte', {
-		inversedOperator: '$gt',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, '<=', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$is', {
-		inversedOperator: '$isNot',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'is', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$isNot', {
-		inversedOperator: '$is',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'is not', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$isDistinct', {
-		inversedOperator: '$isNotDistinct',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'is distinct from', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$isNotDistinct', {
-		inversedOperator: '$isDistinct',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'is not distinct from', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$like', {
-		inversedOperator: '$nlike',
-		defaultFetchingOperator: '$value',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'like', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$nlike', {
-		inversedOperator: '$like',
-		defaultFetchingOperator: '$value',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'not like', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$similarTo', {
-		inversedOperator: '$nsimilarTo',
-		defaultFetchingOperator: '$value',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'similar to', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$nsimilarTo', {
-		inversedOperator: '$similarTo',
-		defaultFetchingOperator: '$value',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'not similar to', value);
-		}
-	});
-
-
-	dialect.operators.comparison.add('$match', {
-		inversedOperator: '$nmatch',
-		defaultFetchingOperator: '$value',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, '~', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$nmatch', {
-		inversedOperator: '$match',
-		defaultFetchingOperator: '$value',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, '!~', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$imatch', {
-		inversedOperator: '$nimatch',
-		defaultFetchingOperator: '$value',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, '~*', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$nimatch', {
-		inversedOperator: '$imatch',
-		defaultFetchingOperator: '$value',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, '!~*', value);
-		}
-	});
-
-
-	dialect.operators.comparison.add('$null', {
-		inversedOperator: '$nnull',
-		defaultFetchingOperator: '$boolean',
-		fn: function(field, value) {
-			return buildBooleanOperator(field, 'null', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$nnull', {
-		inversedOperator: '$null',
-		defaultFetchingOperator: '$boolean',
-		fn: function(field, value) {
-			return buildBooleanOperator(field, 'null', !value);
-		}
-	});
-
-	dialect.operators.comparison.add('$true', {
-		inversedOperator: '$ntrue',
-		defaultFetchingOperator: '$boolean',
-		fn: function(field, value) {
-			return buildBooleanOperator(field, 'true', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$ntrue', {
-		inversedOperator: '$true',
-		defaultFetchingOperator: '$boolean',
-		fn: function(field, value) {
-			return buildBooleanOperator(field, 'true', !value);
-		}
-	});
-
-	dialect.operators.comparison.add('$false', {
-		inversedOperator: '$nfalse',
-		defaultFetchingOperator: '$boolean',
-		fn: function(field, value) {
-			return buildBooleanOperator(field, 'false', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$nfalse', {
-		inversedOperator: '$false',
-		defaultFetchingOperator: '$boolean',
-		fn: function(field, value) {
-			return buildBooleanOperator(field, 'false', !value);
-		}
-	});
-
-	dialect.operators.comparison.add('$unknown', {
-		inversedOperator: '$nunknown',
-		defaultFetchingOperator: '$boolean',
-		fn: function(field, value) {
-			return buildBooleanOperator(field, 'unknown', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$nunknown', {
-		inversedOperator: '$unknown',
-		defaultFetchingOperator: '$boolean',
-		fn: function(field, value) {
-			return buildBooleanOperator(field, 'unknown', !value);
-		}
-	});
-
-
-	dialect.operators.comparison.add('$in', {
-		inversedOperator: '$nin',
-		defaultFetchingOperator: '$inValues',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'in', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$nin', {
-		inversedOperator: '$in',
-		defaultFetchingOperator: '$inValues',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'not in', value);
-		}
-	});
-
-
-	dialect.operators.comparison.add('$between', {
-		inversedOperator: '$nbetween',
-		defaultFetchingOperator: '$betweenValues',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'between', value);
-		}
-	});
-
-	dialect.operators.comparison.add('$nbetween', {
-		inversedOperator: '$between',
-		defaultFetchingOperator: '$betweenValues',
-		fn: function(field, value) {
-			return buildComparisonOperator(field, 'not between', value);
-		}
-	});
-};

package/node_modules/json-sql/lib/dialects/base/operators/fetching.js

@@ -1,79 +0,0 @@
-'use strict';
-
-var _ = require('underscore');
-
-module.exports = function(dialect) {
-	dialect.operators.fetching.add('$field', {
-		fn: function(value) {
-			return dialect.buildBlock('term', {term: value, type: 'field'});
-		}
-	});
-
-	dialect.operators.fetching.add('$value', {
-		fn: function(value) {
-			return dialect.buildBlock('term', {term: value, type: 'value'});
-		}
-	});
-
-	dialect.operators.fetching.add('$func', {
-		fn: function(value) {
-			return dialect.buildBlock('term', {term: value, type: 'func'});
-		}
-	});
-
-	dialect.operators.fetching.add('$expression', {
-		fn: function(value) {
-			return dialect.buildBlock('term', {term: value, type: 'expression'});
-		}
-	});
-
-	dialect.operators.fetching.add('$select', {
-		fn: function(value) {
-			return dialect.buildTemplate('subQuery', {queryBody: value});
-		}
-	});
-
-	dialect.operators.fetching.add('$query', {
-		fn: function(value) {
-			return dialect.buildTemplate('subQuery', {queryBody: value});
-		}
-	});
-
-	dialect.operators.fetching.add('$boolean', {
-		fn: function(value) {
-			return Boolean(value);
-		}
-	});
-
-	dialect.operators.fetching.add('$inValues', {
-		fn: function(value) {
-			if (!_.isObject(value)) {
-				throw new Error('Invalid `$in/$nin` value type "' + (typeof value) + '"');
-			}
-
-			if (_.isArray(value)) {
-				if (!value.length) value = [null];
-
-				return '(' + _(value).map(function(item) {
-					return dialect.builder._pushValue(item);
-				}).join(', ') + ')';
-			} else {
-				return dialect.buildTemplate('subQuery', {queryBody: value});
-			}
-		}
-	});
-
-	dialect.operators.fetching.add('$betweenValues', {
-		fn: function(value) {
-			if (!_.isArray(value)) {
-				throw new Error('Invalid `$between` value type "' + (typeof value) + '"');
-			}
-
-			if (value.length < 2) {
-				throw new Error('`$between` array length should be 2 or greater');
-			}
-
-			return dialect.builder._pushValue(value[0]) + ' and ' + dialect.builder._pushValue(value[1]);
-		}
-	});
-};

package/node_modules/json-sql/lib/dialects/base/operators/index.js

@@ -1,13 +0,0 @@
-'use strict';
-
-var comparisonOperatorsInit = require('./comparison');
-var logicalOperatorsInit = require('./logical');
-var fetchingOperatorsInit = require('./fetching');
-var stateOperatorsInit = require('./state');
-
-module.exports = function(dialect) {
-	comparisonOperatorsInit(dialect);
-	logicalOperatorsInit(dialect);
-	fetchingOperatorsInit(dialect);
-	stateOperatorsInit(dialect);
-};