jsonbadger 0.5.0

package/src/query/operators/in.js

@@ -0,0 +1,12 @@
+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[])';
+}

package/src/query/operators/index.js

@@ -0,0 +1,60 @@
+import all_operator from './all.js';
+import contains_operator from './contains.js';
+import elem_match_operator from './elem-match.js';
+import eq_operator from './eq.js';
+import gt_operator from './gt.js';
+import gte_operator from './gte.js';
+import has_all_keys_operator from './has-all-keys.js';
+import has_any_keys_operator from './has-any-keys.js';
+import has_key_operator from './has-key.js';
+import in_operator from './in.js';
+import jsonpath_exists_operator from './jsonpath-exists.js';
+import jsonpath_match_operator from './jsonpath-match.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';
+import size_operator from './size.js';
+
+export {
+	all_operator,
+	contains_operator,
+	elem_match_operator,
+	eq_operator,
+	gt_operator,
+	gte_operator,
+	has_all_keys_operator,
+	has_any_keys_operator,
+	has_key_operator,
+	in_operator,
+	jsonpath_exists_operator,
+	jsonpath_match_operator,
+	lt_operator,
+	lte_operator,
+	ne_operator,
+	nin_operator,
+	regex_operator,
+	size_operator
+};
+
+export default {
+	all_operator,
+	contains_operator,
+	elem_match_operator,
+	eq_operator,
+	gt_operator,
+	gte_operator,
+	has_all_keys_operator,
+	has_any_keys_operator,
+	has_key_operator,
+	in_operator,
+	jsonpath_exists_operator,
+	jsonpath_match_operator,
+	lt_operator,
+	lte_operator,
+	ne_operator,
+	nin_operator,
+	regex_operator,
+	size_operator
+};

package/src/query/operators/jsonpath-exists.js

@@ -0,0 +1,15 @@
+import QueryError from '#src/errors/query-error.js';
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+import {is_string} from '#src/utils/value.js';
+
+export default function jsonpath_exists_operator(jsonb_expression, comparison_value, parameter_state) {
+	if(!is_string(comparison_value) || comparison_value.trim() === '') {
+		throw new QueryError('Invalid value for $json_path_exists operator', {
+			operator: '$json_path_exists',
+			value: comparison_value
+		});
+	}
+
+	const placeholder = bind_parameter(parameter_state, comparison_value);
+	return jsonb_expression + ' @? ' + placeholder + '::jsonpath';
+}

package/src/query/operators/jsonpath-match.js

@@ -0,0 +1,15 @@
+import QueryError from '#src/errors/query-error.js';
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+import {is_string} from '#src/utils/value.js';
+
+export default function jsonpath_match_operator(jsonb_expression, comparison_value, parameter_state) {
+	if(!is_string(comparison_value) || comparison_value.trim() === '') {
+		throw new QueryError('Invalid value for $json_path_match operator', {
+			operator: '$json_path_match',
+			value: comparison_value
+		});
+	}
+
+	const placeholder = bind_parameter(parameter_state, comparison_value);
+	return jsonb_expression + ' @@ ' + placeholder + '::jsonpath';
+}

package/src/query/operators/lt.js

@@ -0,0 +1,16 @@
+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;
+}

package/src/query/operators/lte.js

@@ -0,0 +1,16 @@
+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;
+}

package/src/query/operators/ne.js

@@ -0,0 +1,6 @@
+import {bind_parameter} from '#src/sql/parameter-binder.js';
+
+export default function ne_operator(sql_expression, comparison_value, parameter_state) {
+	const placeholder = bind_parameter(parameter_state, String(comparison_value));
+	return sql_expression + ' != ' + placeholder;
+}

package/src/query/operators/nin.js

@@ -0,0 +1,12 @@
+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[]))';
+}

package/src/query/operators/regex.js

@@ -0,0 +1,8 @@
+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;
+}

package/src/query/operators/size.js

@@ -0,0 +1,16 @@
+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 size_operator(jsonb_expression, comparison_value, parameter_state) {
+	if(is_nan(comparison_value)) {
+		throw new QueryError('Invalid value for $size operator', {
+			operator: '$size',
+			value: comparison_value
+		});
+	}
+
+	const numeric_value = Number(comparison_value);
+	const placeholder = bind_parameter(parameter_state, numeric_value);
+	return 'jsonb_array_length(' + jsonb_expression + ') = ' + placeholder;
+}

package/src/query/path-parser.js

@@ -0,0 +1,43 @@
+import {assert_path} from '#src/utils/assert.js';
+import {build_path_literal, split_dot_path} from '#src/utils/object-path.js';
+
+export function build_text_expression(column_reference, path_value) {
+	const path_segments = split_dot_path(path_value);
+
+	if(path_segments.length === 1) {
+		return column_reference + " ->> '" + path_segments[0] + "'";
+	}
+
+	return column_reference + " #>> '" + build_path_literal(path_segments) + "'";
+}
+
+export function build_json_expression(column_reference, path_value) {
+	const path_segments = split_dot_path(path_value);
+
+	if(path_segments.length === 1) {
+		return column_reference + " -> '" + path_segments[0] + "'";
+	}
+
+	return column_reference + " #> '" + build_path_literal(path_segments) + "'";
+}
+
+export function build_elem_text_expression(elem_alias, path_segments) {
+	if(path_segments.length === 1) {
+		return elem_alias + "->>'" + path_segments[0] + "'";
+	}
+
+	return elem_alias + " #>> '" + build_path_literal(path_segments) + "'";
+}
+
+export function parse_path(path_value) {
+	assert_path(path_value, 'path');
+
+	const path_segments = split_dot_path(path_value);
+
+	return {
+		path_segments: path_segments,
+		root_path: path_segments[0],
+		child_segments: path_segments.slice(1),
+		is_nested: path_segments.length > 1
+	};
+}

package/src/query/query-builder.js

@@ -0,0 +1,93 @@
+import limit_skip_compiler from '#src/query/limit-skip-compiler.js';
+import sort_compiler from '#src/query/sort-compiler.js';
+import where_compiler from '#src/query/where-compiler.js';
+
+import sql_runner from '#src/sql/sql-runner.js';
+
+import {quote_identifier} from '#src/utils/assert.js';
+
+export default function QueryBuilder(model_constructor, operation_name, query_filter, projection_value) {
+	this.model_constructor = model_constructor;
+	this.operation_name = operation_name;
+	this.base_filter = query_filter || {};
+	this.where_filter = {};
+	this.sort_definition = null;
+	this.limit_count = null;
+	this.skip_count = null;
+	this.projection_value = projection_value || null;
+}
+
+QueryBuilder.prototype.where = function (extra_filter) {
+	this.where_filter = Object.assign({}, this.where_filter, extra_filter || {});
+	return this;
+};
+
+QueryBuilder.prototype.sort = function (sort_definition) {
+	this.sort_definition = sort_definition || null;
+	return this;
+};
+
+QueryBuilder.prototype.limit = function (limit_value) {
+	this.limit_count = limit_value;
+	return this;
+};
+
+QueryBuilder.prototype.skip = function (skip_value) {
+	this.skip_count = skip_value;
+	return this;
+};
+
+QueryBuilder.prototype.exec = async function () {
+	const schema_instance = this.model_constructor.schema_instance;
+	const model_options = this.model_constructor.model_options;
+	const table_name = model_options.table_name;
+	const data_column = model_options.data_column;
+	const table_identifier = quote_identifier(table_name);
+	const data_identifier = quote_identifier(data_column);
+	const merged_filter = Object.assign({}, this.base_filter, this.where_filter);
+	const where_result = where_compiler(merged_filter, {
+		data_column: data_column,
+		schema: schema_instance
+	});
+
+
+	if(this.operation_name === 'count_documents') {
+		const count_sql = 'SELECT COUNT(*)::int AS total_count FROM ' + table_identifier + ' WHERE ' + where_result.sql;
+		const count_result = await sql_runner(count_sql, where_result.params);
+
+		if(count_result.rows.length === 0) {
+			return 0;
+		}
+
+		return Number(count_result.rows[0].total_count);
+	}
+
+	let sql_text = 'SELECT ' + data_identifier + ' AS data FROM ' + table_identifier + ' WHERE ' + where_result.sql;
+	const sort_sql = sort_compiler(this.sort_definition, {
+		data_column: data_column
+	});
+
+	sql_text += sort_sql;
+
+	if(this.operation_name === 'find_one') {
+		if(this.limit_count === null || this.limit_count === undefined) {
+			this.limit_count = 1;
+		}
+	}
+
+	sql_text += limit_skip_compiler(this.limit_count, this.skip_count);
+
+	const query_result = await sql_runner(sql_text, where_result.params);
+
+	if(this.operation_name === 'find_one') {
+		if(query_result.rows.length === 0) {
+			return null;
+		}
+
+		return query_result.rows[0].data;
+	}
+
+	return query_result.rows.map(function map_row(row_value) {
+		return row_value.data;
+	});
+};

package/src/query/sort-compiler.js

@@ -0,0 +1,30 @@
+import {quote_identifier} from '#src/utils/assert.js';
+import {build_text_expression} from '#src/query/path-parser.js';
+
+export default function sort_compiler(sort_definition, compile_options) {
+	if(!sort_definition || typeof sort_definition !== 'object') {
+		return '';
+	}
+
+	const data_column_name = compile_options?.data_column ?? 'data';
+	const data_column_reference = quote_identifier(data_column_name);
+	const sort_entries = Object.entries(sort_definition);
+	const sort_clauses = [];
+	let entry_index = 0;
+
+	while(entry_index < sort_entries.length) {
+		const sort_entry = sort_entries[entry_index];
+		const path_value = sort_entry[0];
+		const direction_value = Number(sort_entry[1]) === -1 ? 'DESC' : 'ASC';
+		const text_expression = build_text_expression(data_column_reference, path_value);
+
+		sort_clauses.push(text_expression + ' ' + direction_value);
+		entry_index += 1;
+	}
+
+	if(sort_clauses.length === 0) {
+		return '';
+	}
+
+	return ' ORDER BY ' + sort_clauses.join(', ');
+}