jsonbadger 0.5.0 → 0.6.0

package/src/sql/read/where/index.js

@@ -0,0 +1,38 @@
+/*
+ * MODULE RESPONSIBILITY
+ * Compile one read-query filter object into SQL and bound params.
+ */
+import {create_parameter_state} from '#src/sql/parameter-binder.js';
+
+import {create_compile_context} from '#src/sql/read/where/context.js';
+import {compile_field_clause} from '#src/sql/read/where/field-clause.js';
+
+function where_compiler(query_filter, compile_options, start_index) {
+	const filter_object = query_filter ?? {};
+	const compile_context = create_compile_context(compile_options);
+	const parameter_state = create_parameter_state(start_index);
+	const filter_entries = Object.entries(filter_object);
+	const clause_list = [];
+	let entry_index = 0;
+
+	while(entry_index < filter_entries.length) {
+		const entry_pair = filter_entries[entry_index];
+		const path_value = entry_pair[0];
+		const comparison_value = entry_pair[1];
+		const clause = compile_field_clause(path_value, comparison_value, compile_context, parameter_state);
+
+		if(clause) {
+			clause_list.push(clause);
+		}
+
+		entry_index += 1;
+	}
+
+	return {
+		sql: clause_list.length > 0 ? clause_list.join(' AND ') : 'TRUE',
+		params: parameter_state.params,
+		next_index: parameter_state.current_index
+	};
+}
+
+export default where_compiler;

package/src/sql/read/where/operator-entries.js

@@ -0,0 +1,29 @@
+/*
+ * MODULE RESPONSIBILITY
+ * Iterate operator entries and compile their clause fragments.
+ */
+function compile_operator_entry_clauses(operator_definition, compile_operator_clause) {
+	const clause_list = [];
+	const operator_entries = Object.entries(operator_definition);
+	let entry_index = 0;
+
+	while(entry_index < operator_entries.length) {
+		const operator_entry = operator_entries[entry_index];
+		const operator_name = operator_entry[0];
+		const operator_value = operator_entry[1];
+
+		if(operator_name === '$options') {
+			entry_index += 1;
+			continue;
+		}
+
+		clause_list.push(compile_operator_clause(operator_name, operator_value));
+		entry_index += 1;
+	}
+
+	return clause_list;
+}
+
+export {
+	compile_operator_entry_clauses
+};

package/src/{query → sql/read/where}/operators/all.js

@@ -1,10 +1,16 @@
-import {bind_parameter} from '#src/sql/parameter-binder.js';
-import {jsonb_stringify} from '#src/utils/json.js';
-import {to_array} from '#src/utils/array.js';
-
-export default function all_operator(jsonb_expression, comparison_value, parameter_state) {
-	const value_list = to_array(comparison_value);
-	const placeholder = bind_parameter(parameter_state, jsonb_stringify(value_list));
-
-	return jsonb_expression + ' @> ' + placeholder + '::jsonb';
-}
+/*
+ * MODULE RESPONSIBILITY
+ * Compile the SQL fragment for the $all read-query operator.
+ */
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+import {jsonb_stringify} from '#src/utils/json.js';
+import {to_array} from '#src/utils/array.js';
+
+function all_operator(jsonb_expression, comparison_value, parameter_state) {
+	const value_list = to_array(comparison_value);
+	const placeholder = bind_parameter(parameter_state, jsonb_stringify(value_list));
+
+	return jsonb_expression + ' @> ' + placeholder + '::jsonb';
+}
+
+export default all_operator;

package/src/sql/read/where/operators/eq.js

@@ -0,0 +1,12 @@
+/*
+ * MODULE RESPONSIBILITY
+ * Compile the SQL fragment for the $eq read-query operator.
+ */
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+
+function eq_operator(sql_expression, comparison_value, parameter_state) {
+	const placeholder = bind_parameter(parameter_state, String(comparison_value));
+	return sql_expression + ' = ' + placeholder;
+}
+
+export default eq_operator;

package/src/{query → sql/read/where}/operators/gt.js

@@ -1,16 +1,23 @@
-import QueryError from '#src/errors/query-error.js';
-import {bind_parameter} from '#src/sql/parameter-binder.js';
-import {is_nan} from '#src/utils/value.js';
-
-export default function gt_operator(sql_expression, comparison_value, parameter_state) {
-	if(is_nan(comparison_value)) {
-		throw new QueryError('Invalid value for $gt operator', {
-			operator: '$gt',
-			value: comparison_value
-		});
-	}
-
-	const numeric_value = typeof comparison_value === 'bigint' ? comparison_value.toString() : Number(comparison_value);
-	const placeholder = bind_parameter(parameter_state, numeric_value);
-	return '(' + sql_expression + ')::numeric > ' + placeholder;
-}
+/*
+ * MODULE RESPONSIBILITY
+ * Compile the SQL fragment for the $gt read-query operator.
+ */
+import QueryError from '#src/errors/query-error.js';
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+import {is_nan} from '#src/utils/value.js';
+
+function gt_operator(sql_expression, comparison_value, parameter_state) {
+	if(is_nan(comparison_value)) {
+		throw new QueryError('Invalid value for $gt operator', {
+			operator: '$gt',
+			value: comparison_value
+		});
+	}
+
+	const numeric_value = typeof comparison_value === 'bigint' ? comparison_value.toString() : Number(comparison_value);
+	const placeholder = bind_parameter(parameter_state, numeric_value);
+
+	return '(' + sql_expression + ')::numeric > ' + placeholder;
+}
+
+export default gt_operator;

package/src/{query → sql/read/where}/operators/gte.js

@@ -1,16 +1,23 @@
-import QueryError from '#src/errors/query-error.js';
-import {bind_parameter} from '#src/sql/parameter-binder.js';
-import {is_nan} from '#src/utils/value.js';
-
-export default function gte_operator(sql_expression, comparison_value, parameter_state) {
-	if(is_nan(comparison_value)) {
-		throw new QueryError('Invalid value for $gte operator', {
-			operator: '$gte',
-			value: comparison_value
-		});
-	}
-
-	const numeric_value = typeof comparison_value === 'bigint' ? comparison_value.toString() : Number(comparison_value);
-	const placeholder = bind_parameter(parameter_state, numeric_value);
-	return '(' + sql_expression + ')::numeric >= ' + placeholder;
-}
+/*
+ * MODULE RESPONSIBILITY
+ * Compile the SQL fragment for the $gte read-query operator.
+ */
+import QueryError from '#src/errors/query-error.js';
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+import {is_nan} from '#src/utils/value.js';
+
+function gte_operator(sql_expression, comparison_value, parameter_state) {
+	if(is_nan(comparison_value)) {
+		throw new QueryError('Invalid value for $gte operator', {
+			operator: '$gte',
+			value: comparison_value
+		});
+	}
+
+	const numeric_value = typeof comparison_value === 'bigint' ? comparison_value.toString() : Number(comparison_value);
+	const placeholder = bind_parameter(parameter_state, numeric_value);
+
+	return '(' + sql_expression + ')::numeric >= ' + placeholder;
+}
+
+export default gte_operator;

package/src/{query → sql/read/where}/operators/in.js

@@ -1,12 +1,18 @@
-import {bind_parameter} from '#src/sql/parameter-binder.js';
-import {to_array} from '#src/utils/array.js';
-
-export default function in_operator(sql_expression, comparison_value, parameter_state) {
-	const value_list = to_array(comparison_value);
-	const normalized_values = value_list.map(function map_value(current_value) {
-		return String(current_value);
-	});
-	const placeholder = bind_parameter(parameter_state, normalized_values);
-
-	return sql_expression + ' = ANY(' + placeholder + '::text[])';
-}
+/*
+ * MODULE RESPONSIBILITY
+ * Compile the SQL fragment for the $in read-query operator.
+ */
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+import {to_array} from '#src/utils/array.js';
+
+function in_operator(sql_expression, comparison_value, parameter_state) {
+	const value_list = to_array(comparison_value);
+	const normalized_values = value_list.map(function map_value(current_value) {
+		return String(current_value);
+	});
+	const placeholder = bind_parameter(parameter_state, normalized_values);
+
+	return sql_expression + ' = ANY(' + placeholder + '::text[])';
+}
+
+export default in_operator;

package/src/sql/read/where/operators/index.js

@@ -0,0 +1,40 @@
+/*
+ * MODULE RESPONSIBILITY
+ * Expose the read-query operator fragment registry.
+ */
+import all_operator from './all.js';
+import eq_operator from './eq.js';
+import gt_operator from './gt.js';
+import gte_operator from './gte.js';
+import in_operator from './in.js';
+import lt_operator from './lt.js';
+import lte_operator from './lte.js';
+import ne_operator from './ne.js';
+import nin_operator from './nin.js';
+import regex_operator from './regex.js';
+
+export {
+	all_operator,
+	eq_operator,
+	gt_operator,
+	gte_operator,
+	in_operator,
+	lt_operator,
+	lte_operator,
+	ne_operator,
+	nin_operator,
+	regex_operator
+};
+
+export default {
+	all_operator,
+	eq_operator,
+	gt_operator,
+	gte_operator,
+	in_operator,
+	lt_operator,
+	lte_operator,
+	ne_operator,
+	nin_operator,
+	regex_operator
+};

package/src/{query → sql/read/where}/operators/lt.js

@@ -1,16 +1,23 @@
-import QueryError from '#src/errors/query-error.js';
-import {bind_parameter} from '#src/sql/parameter-binder.js';
-import {is_nan} from '#src/utils/value.js';
-
-export default function lt_operator(sql_expression, comparison_value, parameter_state) {
-	if(is_nan(comparison_value)) {
-		throw new QueryError('Invalid value for $lt operator', {
-			operator: '$lt',
-			value: comparison_value
-		});
-	}
-
-	const numeric_value = typeof comparison_value === 'bigint' ? comparison_value.toString() : Number(comparison_value);
-	const placeholder = bind_parameter(parameter_state, numeric_value);
-	return '(' + sql_expression + ')::numeric < ' + placeholder;
-}
+/*
+ * MODULE RESPONSIBILITY
+ * Compile the SQL fragment for the $lt read-query operator.
+ */
+import QueryError from '#src/errors/query-error.js';
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+import {is_nan} from '#src/utils/value.js';
+
+function lt_operator(sql_expression, comparison_value, parameter_state) {
+	if(is_nan(comparison_value)) {
+		throw new QueryError('Invalid value for $lt operator', {
+			operator: '$lt',
+			value: comparison_value
+		});
+	}
+
+	const numeric_value = typeof comparison_value === 'bigint' ? comparison_value.toString() : Number(comparison_value);
+	const placeholder = bind_parameter(parameter_state, numeric_value);
+
+	return '(' + sql_expression + ')::numeric < ' + placeholder;
+}
+
+export default lt_operator;

package/src/{query → sql/read/where}/operators/lte.js

@@ -1,16 +1,23 @@
-import QueryError from '#src/errors/query-error.js';
-import {bind_parameter} from '#src/sql/parameter-binder.js';
-import {is_nan} from '#src/utils/value.js';
-
-export default function lte_operator(sql_expression, comparison_value, parameter_state) {
-	if(is_nan(comparison_value)) {
-		throw new QueryError('Invalid value for $lte operator', {
-			operator: '$lte',
-			value: comparison_value
-		});
-	}
-
-	const numeric_value = typeof comparison_value === 'bigint' ? comparison_value.toString() : Number(comparison_value);
-	const placeholder = bind_parameter(parameter_state, numeric_value);
-	return '(' + sql_expression + ')::numeric <= ' + placeholder;
-}
+/*
+ * MODULE RESPONSIBILITY
+ * Compile the SQL fragment for the $lte read-query operator.
+ */
+import QueryError from '#src/errors/query-error.js';
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+import {is_nan} from '#src/utils/value.js';
+
+function lte_operator(sql_expression, comparison_value, parameter_state) {
+	if(is_nan(comparison_value)) {
+		throw new QueryError('Invalid value for $lte operator', {
+			operator: '$lte',
+			value: comparison_value
+		});
+	}
+
+	const numeric_value = typeof comparison_value === 'bigint' ? comparison_value.toString() : Number(comparison_value);
+	const placeholder = bind_parameter(parameter_state, numeric_value);
+
+	return '(' + sql_expression + ')::numeric <= ' + placeholder;
+}
+
+export default lte_operator;

package/src/sql/read/where/operators/ne.js

@@ -0,0 +1,12 @@
+/*
+ * MODULE RESPONSIBILITY
+ * Compile the SQL fragment for the $ne read-query operator.
+ */
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+
+function ne_operator(sql_expression, comparison_value, parameter_state) {
+	const placeholder = bind_parameter(parameter_state, String(comparison_value));
+	return sql_expression + ' != ' + placeholder;
+}
+
+export default ne_operator;

package/src/{query → sql/read/where}/operators/nin.js

@@ -1,12 +1,18 @@
-import {bind_parameter} from '#src/sql/parameter-binder.js';
-import {to_array} from '#src/utils/array.js';
-
-export default function nin_operator(sql_expression, comparison_value, parameter_state) {
-	const value_list = to_array(comparison_value);
-	const normalized_values = value_list.map(function map_value(current_value) {
-		return String(current_value);
-	});
-	const placeholder = bind_parameter(parameter_state, normalized_values);
-
-	return 'NOT (' + sql_expression + ' = ANY(' + placeholder + '::text[]))';
-}
+/*
+ * MODULE RESPONSIBILITY
+ * Compile the SQL fragment for the $nin read-query operator.
+ */
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+import {to_array} from '#src/utils/array.js';
+
+function nin_operator(sql_expression, comparison_value, parameter_state) {
+	const value_list = to_array(comparison_value);
+	const normalized_values = value_list.map(function map_value(current_value) {
+		return String(current_value);
+	});
+	const placeholder = bind_parameter(parameter_state, normalized_values);
+
+	return 'NOT (' + sql_expression + ' = ANY(' + placeholder + '::text[]))';
+}
+
+export default nin_operator;

package/src/{query → sql/read/where}/operators/regex.js

@@ -1,8 +1,14 @@
-import {bind_parameter} from '#src/sql/parameter-binder.js';
-
-export default function regex_operator(sql_expression, pattern_value, option_value, parameter_state) {
-	const regex_operator_value = option_value && option_value.indexOf('i') >= 0 ? '~*' : '~';
-	const placeholder = bind_parameter(parameter_state, String(pattern_value));
-
-	return sql_expression + ' ' + regex_operator_value + ' ' + placeholder;
-}
+/*
+ * MODULE RESPONSIBILITY
+ * Compile the SQL fragment for the $regex read-query operator.
+ */
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+
+function regex_operator(sql_expression, pattern_value, option_value, parameter_state) {
+	const regex_operator_value = option_value && option_value.indexOf('i') >= 0 ? '~*' : '~';
+	const placeholder = bind_parameter(parameter_state, String(pattern_value));
+
+	return sql_expression + ' ' + regex_operator_value + ' ' + placeholder;
+}
+
+export default regex_operator;

package/src/sql/read/where/operators.js

@@ -0,0 +1,126 @@
+/*
+ * MODULE RESPONSIBILITY
+ * Compile operator-style read-query objects into SQL predicates.
+ */
+import {
+	all_operator
+} from '#src/sql/read/where/operators/index.js';
+import contains_operator from '#src/sql/jsonb/read/operators/contains.js';
+import has_all_keys_operator from '#src/sql/jsonb/read/operators/has-all-keys.js';
+import has_any_keys_operator from '#src/sql/jsonb/read/operators/has-any-keys.js';
+import has_key_operator from '#src/sql/jsonb/read/operators/has-key.js';
+import jsonpath_exists_operator from '#src/sql/jsonb/read/operators/jsonpath-exists.js';
+import jsonpath_match_operator from '#src/sql/jsonb/read/operators/jsonpath-match.js';
+import size_operator from '#src/sql/jsonb/read/operators/size.js';
+import {build_json_expression, build_text_expression, parse_path} from '#src/sql/jsonb/path-parser.js';
+
+import QueryError from '#src/errors/query-error.js';
+
+import {cast_operator_value} from '#src/sql/read/where/casting.js';
+import {is_array_root} from '#src/sql/read/where/context.js';
+import {compile_nested_array_operator} from '#src/sql/jsonb/read/elem-match.js';
+import {compile_operator_entry_clauses} from '#src/sql/read/where/operator-entries.js';
+import {compile_text_operator} from '#src/sql/read/where/text-operators.js';
+
+import {build_nested_object} from '#src/utils/object-path.js';
+
+function compile_operator_object(path_value, operator_definition, compile_context, parameter_state) {
+	const path_info = parse_path(path_value);
+	const regex_options = operator_definition.$options || '';
+	const has_array_path = is_array_root(compile_context, path_info.root_path) && path_info.child_segments.length > 0;
+
+	const clause_list = compile_operator_entry_clauses(operator_definition, function (operator_name, operator_value) {
+		if(has_array_path) {
+			return compile_nested_array_operator(
+				operator_name,
+				operator_value,
+				regex_options,
+				path_info,
+				compile_context.data_column_reference,
+				parameter_state
+			);
+		}
+
+		return compile_standard_operator({
+			name: operator_name,
+			value: operator_value,
+			regex_options,
+			path_value,
+			compile_context,
+			parameter_state
+		});
+	});
+
+	return clause_list.join(' AND ');
+}
+
+function compile_standard_operator(context) {
+	const {
+		name,
+		value,
+		regex_options,
+		path_value,
+		compile_context,
+		parameter_state
+	} = context;
+
+	const data_column_reference = compile_context.data_column_reference;
+	const text_expression = build_text_expression(data_column_reference, path_value);
+	const json_expression = build_json_expression(data_column_reference, path_value);
+	const casted_value = cast_operator_value(path_value, name, value, compile_context);
+	const text_operator_clause = compile_text_operator({
+		name,
+		value,
+		casted_value,
+		regex_options,
+		text_expression,
+		parameter_state,
+		error_message: 'Unsupported operator'
+	});
+
+	if(text_operator_clause) {
+		return text_operator_clause;
+	}
+
+	if(name === '$contains') {
+		const nested_object = build_nested_object(path_value, value);
+		return contains_operator(data_column_reference, nested_object, parameter_state);
+	}
+
+	if(name === '$has_key') {
+		return has_key_operator(json_expression, value, parameter_state);
+	}
+
+	if(name === '$has_any_keys') {
+		return has_any_keys_operator(json_expression, value, parameter_state);
+	}
+
+	if(name === '$has_all_keys') {
+		return has_all_keys_operator(json_expression, value, parameter_state);
+	}
+
+	if(name === '$json_path_exists') {
+		return jsonpath_exists_operator(json_expression, value, parameter_state);
+	}
+
+	if(name === '$json_path_match') {
+		return jsonpath_match_operator(json_expression, value, parameter_state);
+	}
+
+	if(name === '$all') {
+		return all_operator(json_expression, casted_value, parameter_state);
+	}
+
+	if(name === '$size') {
+		return size_operator(json_expression, value, parameter_state);
+	}
+
+	throw new QueryError('Unsupported operator: ' + name, {
+		operator: name,
+		path: path_value
+	});
+}
+
+export {
+	compile_operator_object
+};

package/src/sql/read/where/text-operators.js

@@ -0,0 +1,83 @@
+/*
+ * MODULE RESPONSIBILITY
+ * Compile scalar and text read-query operators into SQL predicates.
+ */
+import {
+	eq_operator,
+	gt_operator,
+	gte_operator,
+	in_operator,
+	lt_operator,
+	lte_operator,
+	ne_operator,
+	nin_operator,
+	regex_operator
+} from '#src/sql/read/where/operators/index.js';
+
+/**
+ * Compile one scalar comparison operator into a SQL predicate.
+ *
+ * @param {object} operator_context
+ * @param {string} operator_context.name
+ * @param {*} operator_context.value
+ * @param {*} [operator_context.casted_value]
+ * @param {*} operator_context.regex_options
+ * @param {string} operator_context.text_expression
+ * @param {object} operator_context.parameter_state
+ * @param {string} operator_context.error_message
+ * @returns {string|null}
+ * @throws {QueryError}
+ */
+function compile_text_operator(operator_context) {
+	const {
+		name,
+		value,
+		casted_value = value,
+		regex_options,
+		text_expression,
+		parameter_state,
+		error_message
+	} = operator_context;
+
+	if(name === '$eq') {
+		return eq_operator(text_expression, casted_value, parameter_state);
+	}
+
+	if(name === '$ne') {
+		return ne_operator(text_expression, casted_value, parameter_state);
+	}
+
+	if(name === '$gt') {
+		return gt_operator(text_expression, casted_value, parameter_state);
+	}
+
+	if(name === '$gte') {
+		return gte_operator(text_expression, casted_value, parameter_state);
+	}
+
+	if(name === '$lt') {
+		return lt_operator(text_expression, casted_value, parameter_state);
+	}
+
+	if(name === '$lte') {
+		return lte_operator(text_expression, casted_value, parameter_state);
+	}
+
+	if(name === '$in') {
+		return in_operator(text_expression, casted_value, parameter_state);
+	}
+
+	if(name === '$nin') {
+		return nin_operator(text_expression, casted_value, parameter_state);
+	}
+
+	if(name === '$regex') {
+		return regex_operator(text_expression, value, regex_options, parameter_state);
+	}
+
+	return null;
+}
+
+export {
+	compile_text_operator
+};