Skip to content

armgit / dbx

Public Imported from GitHub
0

25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。

fix(mongodb): support shell regex literals

Guoyu Sud92e1194640a
diff --git a/crates/dbx-core/src/db/mongo_driver.rs b/crates/dbx-core/src/db/mongo_driver.rs
index c997c70bb1..96432abcfe 100644
--- a/crates/dbx-core/src/db/mongo_driver.rs
+++ b/crates/dbx-core/src/db/mongo_driver.rs
@@ -2655,6 +2655,11 @@ fn json_filter_value_to_bson(value: &serde_json::Value, field_name: Option<&str>
}
serde_json::Value::Object(obj) => {
if obj.len() == 1 {
+ if obj.contains_key("$regularExpression") {
+ if let Ok(Some(value)) = parse_extended_json_value(obj) {
+ return value;
+ }
+ }
if let Some(serde_json::Value::String(hex)) = obj.get("$oid") {
if let Ok(oid) = ObjectId::parse_str(hex) {
return Bson::ObjectId(oid);
@@ -3968,6 +3973,25 @@ mod tests {
assert!(matches!(doc.get("count"), Some(Bson::Int64(42))));
}
+ #[test]
+ fn json_filter_to_document_parses_extended_json_regex() {
+ let value = serde_json::json!({
+ "packagingRatio": {
+ "$regularExpression": {
+ "pattern": "^[^::]*盒",
+ "options": "im",
+ }
+ }
+ });
+ let doc = json_filter_to_document(&value).unwrap();
+
+ assert!(matches!(
+ doc.get("packagingRatio"),
+ Some(Bson::RegularExpression(regex))
+ if regex.pattern == "^[^::]*盒" && regex.options == "im"
+ ));
+ }
+
#[test]
fn json_object_to_document_extended_json_keeps_shell_date_strings_literal() {
let value = serde_json::json!({
diff --git a/crates/dbx-core/src/mongo_shell.rs b/crates/dbx-core/src/mongo_shell.rs
index 45977017ae..3eee085e0e 100644
--- a/crates/dbx-core/src/mongo_shell.rs
+++ b/crates/dbx-core/src/mongo_shell.rs
@@ -847,17 +847,228 @@ fn parse_explain_verbosity(args: &[String]) -> Result<String, String> {
}
fn normalized_json(input: &str) -> Result<String, String> {
- let transformed = transform_shell_constructors(input.trim())?;
+ let transformed = transform_shell_regex_literals(input.trim())?;
+ let transformed = transform_shell_constructors(&transformed)?;
let value: Value =
json5::from_str(&transformed).map_err(|error| format!("Invalid MongoDB JSON argument: {error}"))?;
serde_json::to_string(&value).map_err(|error| error.to_string())
}
+struct ShellRegexLiteral {
+ end: usize,
+ pattern: String,
+ options: String,
+}
+
+fn shell_regex_literal_at(input: &str, index: usize) -> Result<Option<ShellRegexLiteral>, String> {
+ if !input[index..].starts_with('/') || !is_shell_regex_value_position(input, index) {
+ return Ok(None);
+ }
+
+ read_shell_regex_literal(input, index).map(Some)
+}
+
+fn read_shell_regex_literal(input: &str, index: usize) -> Result<ShellRegexLiteral, String> {
+ let mut cursor = index + 1;
+ let mut pattern = String::new();
+ let mut escaped = false;
+ let mut in_character_class = false;
+ let mut closed = false;
+ while cursor < input.len() {
+ let current = input[cursor..].chars().next().ok_or("Invalid MongoDB regex literal.")?;
+ if matches!(current, '\n' | '\r' | '\u{2028}' | '\u{2029}') {
+ return Err("MongoDB regex literals cannot contain an unescaped line break.".to_string());
+ }
+ cursor += current.len_utf8();
+ if escaped {
+ pattern.push(current);
+ escaped = false;
+ continue;
+ }
+ if current == '\\' {
+ pattern.push(current);
+ escaped = true;
+ continue;
+ }
+ if current == '[' {
+ in_character_class = true;
+ } else if current == ']' && in_character_class {
+ in_character_class = false;
+ } else if current == '/' && !in_character_class {
+ closed = true;
+ break;
+ }
+ pattern.push(current);
+ }
+ if !closed {
+ return Err("Unclosed MongoDB regex literal.".to_string());
+ }
+
+ let mut options = Vec::new();
+ while cursor < input.len() {
+ let option = input[cursor..].chars().next().ok_or("Invalid MongoDB regex literal.")?;
+ if !option.is_ascii_alphabetic() {
+ break;
+ }
+ // JS-only regex flags (d/g/v/y) have no server-side meaning for a
+ // stored regex literal — MongoDB's $regex has no global modifier — so
+ // drop them instead of failing the whole command.
+ if matches!(option, 'd' | 'g' | 'v' | 'y') {
+ cursor += option.len_utf8();
+ continue;
+ }
+ if !matches!(option, 'i' | 'm' | 's' | 'u') || options.contains(&option) {
+ return Err(format!("Unsupported or duplicate MongoDB regex option: {option}"));
+ }
+ options.push(option);
+ cursor += option.len_utf8();
+ }
+ options.sort_unstable();
+ Ok(ShellRegexLiteral { end: cursor, pattern, options: options.into_iter().collect() })
+}
+
+fn transform_shell_regex_literals(input: &str) -> Result<String, String> {
+ let mut output = String::with_capacity(input.len());
+ let mut index = 0;
+ while index < input.len() {
+ let rest = &input[index..];
+ let ch = rest.chars().next().ok_or("Invalid MongoDB argument.")?;
+
+ if matches!(ch, '"' | '\'') {
+ let start = index;
+ index += ch.len_utf8();
+ let mut escaped = false;
+ while index < input.len() {
+ let current = input[index..].chars().next().ok_or("Invalid MongoDB argument.")?;
+ index += current.len_utf8();
+ if escaped {
+ escaped = false;
+ } else if current == '\\' {
+ escaped = true;
+ } else if current == ch {
+ break;
+ }
+ }
+ output.push_str(&input[start..index]);
+ continue;
+ }
+
+ if rest.starts_with("//") {
+ let end = rest.find(['\n', '\r']).map(|offset| index + offset).unwrap_or(input.len());
+ output.push_str(&input[index..end]);
+ index = end;
+ continue;
+ }
+ if rest.starts_with("/*") {
+ let end = rest.find("*/").map(|offset| index + offset + 2).unwrap_or(input.len());
+ output.push_str(&input[index..end]);
+ index = end;
+ continue;
+ }
+
+ if ch != '/' || !is_shell_regex_value_position(input, index) {
+ output.push(ch);
+ index += ch.len_utf8();
+ continue;
+ }
+
+ let literal = shell_regex_literal_at(input, index)?.ok_or("Invalid MongoDB regex literal.")?;
+ output.push_str(
+ &serde_json::to_string(&serde_json::json!({
+ "$regularExpression": {
+ "pattern": literal.pattern,
+ "options": literal.options,
+ }
+ }))
+ .map_err(|error| error.to_string())?,
+ );
+ index = literal.end;
+ }
+ Ok(output)
+}
+
+fn is_shell_regex_value_position(input: &str, index: usize) -> bool {
+ let mut previous_significant = None;
+ let mut cursor = 0;
+ while cursor < index {
+ let rest = &input[cursor..];
+ let current = rest.chars().next().expect("cursor is on a character boundary");
+
+ if matches!(current, '"' | '\'') {
+ let quote = current;
+ cursor += current.len_utf8();
+ let mut escaped = false;
+ while cursor < index {
+ let character = input[cursor..].chars().next().expect("cursor is on a character boundary");
+ cursor += character.len_utf8();
+ if escaped {
+ escaped = false;
+ } else if character == '\\' {
+ escaped = true;
+ } else if character == quote {
+ break;
+ }
+ }
+ previous_significant = Some('\0');
+ continue;
+ }
+
+ if rest.starts_with("//") {
+ cursor = rest.find(['\n', '\r']).map(|offset| cursor + offset).unwrap_or(index).min(index);
+ continue;
+ }
+ if rest.starts_with("/*") {
+ cursor = rest.find("*/").map(|offset| cursor + offset + 2).unwrap_or(index).min(index);
+ continue;
+ }
+
+ if current == '/' && is_shell_regex_value_prefix(previous_significant) {
+ if let Ok(literal) = read_shell_regex_literal(input, cursor) {
+ if literal.end <= index {
+ previous_significant = Some('\0');
+ cursor = literal.end;
+ continue;
+ }
+ }
+ }
+
+ if !current.is_whitespace() {
+ previous_significant = Some(current);
+ }
+ cursor += current.len_utf8();
+ }
+
+ is_shell_regex_value_prefix(previous_significant)
+}
+
+fn is_shell_regex_value_prefix(previous_significant: Option<char>) -> bool {
+ previous_significant.is_none_or(|character| matches!(character, ':' | '[' | ',' | '('))
+}
+
fn transform_shell_constructors(input: &str) -> Result<String, String> {
let mut output = String::with_capacity(input.len());
let mut index = 0;
while index < input.len() {
let rest = &input[index..];
+ let ch = rest.chars().next().ok_or("Invalid MongoDB argument.")?;
+ if matches!(ch, '"' | '\'') {
+ let start = index;
+ index += ch.len_utf8();
+ let mut escaped = false;
+ while index < input.len() {
+ let current = input[index..].chars().next().ok_or("Invalid MongoDB argument.")?;
+ index += current.len_utf8();
+ if escaped {
+ escaped = false;
+ } else if current == '\\' {
+ escaped = true;
+ } else if current == ch {
+ break;
+ }
+ }
+ output.push_str(&input[start..index]);
+ continue;
+ }
let constructor = if rest.starts_with("ObjectId(") {
Some("ObjectId(")
} else if rest.starts_with("ISODate(") {
@@ -866,7 +1077,6 @@ fn transform_shell_constructors(input: &str) -> Result<String, String> {
None
};
let Some(constructor) = constructor else {
- let ch = rest.chars().next().ok_or("Invalid MongoDB argument.")?;
output.push(ch);
index += ch.len_utf8();
continue;
@@ -944,14 +1154,15 @@ fn aggregate_writes(pipeline: &str) -> bool {
}
fn matching_paren(source: &str, open: usize) -> Option<usize> {
- let bytes = source.as_bytes();
let mut depth = 0;
let mut quote = None;
let mut escape = false;
- for (index, byte) in bytes.iter().enumerate().skip(open) {
- let ch = *byte as char;
+ let mut index = open;
+ while index < source.len() {
+ let ch = source[index..].chars().next()?;
if escape {
escape = false;
+ index += ch.len_utf8();
continue;
}
if quote.is_some() {
@@ -960,10 +1171,16 @@ fn matching_paren(source: &str, open: usize) -> Option<usize> {
} else if Some(ch) == quote {
quote = None;
}
+ index += ch.len_utf8();
continue;
}
if ch == '\'' || ch == '"' || ch == '`' {
quote = Some(ch);
+ } else if ch == '/' && is_shell_regex_value_position(source, index) {
+ if let Ok(Some(literal)) = shell_regex_literal_at(source, index) {
+ index = literal.end;
+ continue;
+ }
} else if ch == '(' {
depth += 1;
} else if ch == ')' {
@@ -972,6 +1189,7 @@ fn matching_paren(source: &str, open: usize) -> Option<usize> {
return Some(index);
}
}
+ index += ch.len_utf8();
}
None
}
@@ -985,10 +1203,12 @@ fn split_top_level(source: &str) -> Vec<String> {
let mut depth = 0;
let mut quote = None;
let mut escape = false;
- for (index, byte) in source.as_bytes().iter().enumerate() {
- let ch = *byte as char;
+ let mut index = 0;
+ while index < source.len() {
+ let ch = source[index..].chars().next().expect("index is on a character boundary");
if escape {
escape = false;
+ index += ch.len_utf8();
continue;
}
if quote.is_some() {
@@ -997,10 +1217,16 @@ fn split_top_level(source: &str) -> Vec<String> {
} else if Some(ch) == quote {
quote = None;
}
+ index += ch.len_utf8();
continue;
}
if ch == '\'' || ch == '"' || ch == '`' {
quote = Some(ch);
+ } else if ch == '/' && is_shell_regex_value_position(source, index) {
+ if let Ok(Some(literal)) = shell_regex_literal_at(source, index) {
+ index = literal.end;
+ continue;
+ }
} else if matches!(ch, '(' | '[' | '{') {
depth += 1;
} else if matches!(ch, ')' | ']' | '}') {
@@ -1009,6 +1235,7 @@ fn split_top_level(source: &str) -> Vec<String> {
result.push(source[start..index].trim().to_string());
start = index + 1;
}
+ index += ch.len_utf8();
}
result.push(source[start..].trim().to_string());
result
@@ -1231,6 +1458,130 @@ mod tests {
assert!(matches!(update, MongoCommand::Update { many: true, options: Some(_), .. }));
}
+ #[test]
+ fn parses_mongo_shell_regex_literals_in_update_filters() {
+ let command = parse(
+ r#"db.code_info.updateMany(
+ { level: "SECOND_LAYER", position: "B", packagingRatio: /^[^::]*盒/, type: { $ne: "PACK_IN" } },
+ { $set: { type: "PACK_IN" }, $currentDate: { lastUpdateTime: true } }
+ )"#,
+ )
+ .unwrap();
+ let MongoCommand::Update { collection, filter, many, .. } = command else {
+ panic!("expected update command");
+ };
+
+ assert_eq!(collection, "code_info");
+ assert!(many);
+ assert_eq!(
+ serde_json::from_str::<Value>(&filter).unwrap(),
+ serde_json::json!({
+ "level": "SECOND_LAYER",
+ "position": "B",
+ "packagingRatio": {
+ "$regularExpression": {
+ "pattern": "^[^::]*盒",
+ "options": "",
+ }
+ },
+ "type": { "$ne": "PACK_IN" },
+ })
+ );
+ }
+
+ #[test]
+ fn drops_js_only_regex_literal_flags() {
+ let command = parse(r#"db.items.find({ value: /abc/gi })"#).unwrap();
+ let MongoCommand::Find { filter, .. } = command else {
+ panic!("expected find command");
+ };
+ assert_eq!(
+ serde_json::from_str::<Value>(&filter).unwrap(),
+ serde_json::json!({
+ "value": {
+ "$regularExpression": {
+ "pattern": "abc",
+ "options": "i",
+ }
+ }
+ })
+ );
+ }
+
+ #[test]
+ fn ignores_delimiters_inside_mongo_shell_regex_literals() {
+ let command = parse(r#"db.items.updateMany({ value: /a\),b/ }, { $set: { matched: true } })"#).unwrap();
+ let MongoCommand::Update { filter, many, .. } = command else {
+ panic!("expected update command");
+ };
+
+ assert!(many);
+ assert_eq!(
+ serde_json::from_str::<Value>(&filter).unwrap(),
+ serde_json::json!({
+ "value": {
+ "$regularExpression": {
+ "pattern": r#"a\),b"#,
+ "options": "",
+ }
+ }
+ })
+ );
+ }
+
+ #[test]
+ fn normalizes_regex_literal_edges_without_touching_strings_or_comments() {
+ let normalized = normalized_json(
+ r#"{
+ pattern: /a\/b[/::]/mi,
+ constructorText: "ObjectId('literal')",
+ url: "https://example.com/a/b",
+ // slash comments stay comments
+ active: true,
+ }"#,
+ )
+ .unwrap();
+
+ assert_eq!(
+ serde_json::from_str::<Value>(&normalized).unwrap(),
+ serde_json::json!({
+ "pattern": {
+ "$regularExpression": {
+ "pattern": r#"a\/b[/::]"#,
+ "options": "im",
+ }
+ },
+ "constructorText": "ObjectId('literal')",
+ "url": "https://example.com/a/b",
+ "active": true,
+ })
+ );
+
+ for source in ["{pattern: /unterminated}", "{pattern: /value/ii}", "{pattern: /value/q}"] {
+ assert!(normalized_json(source).is_err(), "{source}");
+ }
+ }
+
+ #[test]
+ fn normalizes_regex_literals_after_comments() {
+ let normalized = normalized_json(
+ r#"{
+ block: /* explain the pattern */ /block/i,
+ line: // explain the next pattern
+ /line/m,
+ }"#,
+ )
+ .unwrap();
+
+ assert_eq!(
+ serde_json::from_str::<Value>(&normalized).unwrap(),
+ serde_json::json!({
+ "block": { "$regularExpression": { "pattern": "block", "options": "i" } },
+ "line": { "$regularExpression": { "pattern": "line", "options": "m" } },
+ })
+ );
+ }
+
#[test]
fn parses_legacy_update_with_single_and_multi_semantics() {
assert_eq!(
diff --git a/packages/app-tests/mongoShellCommand.test.ts b/packages/app-tests/mongoShellCommand.test.ts
index d2b08f9474..ace6cbb9bf 100644
--- a/packages/app-tests/mongoShellCommand.test.ts
+++ b/packages/app-tests/mongoShellCommand.test.ts
@@ -35,6 +35,7 @@ import {
} from "../../apps/desktop/src/lib/mongo/mongoShellCommand.ts";
import type { MongoWriteCommand } from "../../apps/desktop/src/lib/mongo/mongoShellCommand.ts";
import { buildMongoUpdateDocument as buildMongoDocumentUpdate, formatMongoShellLiteral as formatMongoDocumentShellLiteral } from "../../apps/desktop/src/lib/mongo/mongoDocumentValues.ts";
+import { normalizeJsonArgument } from "../mongo-shell/src/json.ts";
test("parseMongoFindCommand parses db collection find with an empty JSON filter", () => {
assert.deepEqual(parseMongoFindCommand("db.users.find({})"), {
@@ -596,6 +597,87 @@ test("parseMongoWriteCommand accepts updateMany arrayFilters options", () => {
);
});
+test("parseMongoWriteCommand accepts Mongo shell regex literals", () => {
+ const command = parseMongoWriteCommand(`db.code_info.updateMany(
+ { level: "SECOND_LAYER", position: "B", packagingRatio: /^[^::]*盒/, type: { $ne: "PACK_IN" } },
+ { $set: { type: "PACK_IN" }, $currentDate: { lastUpdateTime: true } }
+ )`);
+
+ assert.equal(command?.kind, "update");
+ if (command?.kind !== "update") return;
+ assert.equal(command.collection, "code_info");
+ assert.equal(command.many, true);
+ assert.deepEqual(JSON.parse(command.filter), {
+ level: "SECOND_LAYER",
+ position: "B",
+ packagingRatio: { $regularExpression: { pattern: "^[^::]*盒", options: "" } },
+ type: { $ne: "PACK_IN" },
+ });
+});
+
+test("parseMongoWriteCommand ignores delimiters inside Mongo shell regex literals", () => {
+ const command = parseMongoWriteCommand(String.raw`db.items.updateMany({ value: /a\),b/ }, { $set: { matched: true } })`);
+
+ assert.equal(command?.kind, "update");
+ if (command?.kind !== "update") return;
+ assert.deepEqual(JSON.parse(command.filter), {
+ value: { $regularExpression: { pattern: "a\\),b", options: "" } },
+ });
+});
+
+test("normalizeJsonArgument handles regex escapes, character classes, flags, strings, and comments", () => {
+ const normalized = normalizeJsonArgument(`{
+ pattern: /a\\/b[/::]/mi,
+ url: "https://example.com/a/b",
+ note: "// remains text",
+ // slash comments remain comments
+ active: true
+ }`);
+
+ assert.ok(normalized);
+ assert.deepEqual(JSON.parse(normalized), {
+ pattern: { $regularExpression: { pattern: "a\\/b[/::]", options: "im" } },
+ url: "https://example.com/a/b",
+ note: "// remains text",
+ active: true,
+ });
+});
+
+test("normalizeJsonArgument accepts a regex literal after comments", () => {
+ const normalized = normalizeJsonArgument(`{
+ block: /* explain the pattern */ /block/i,
+ line: // explain the next pattern
+ /line/m
+ }`);
+
+ assert.ok(normalized);
+ assert.deepEqual(JSON.parse(normalized), {
+ block: { $regularExpression: { pattern: "block", options: "i" } },
+ line: { $regularExpression: { pattern: "line", options: "m" } },
+ });
+});
+
+test("normalizeJsonArgument drops JS-only regex literal flags", () => {
+ const normalized = normalizeJsonArgument(`{
+ global: /value/g,
+ sticky: /value/yd,
+ verbose: /value/givs
+ }`);
+
+ assert.ok(normalized);
+ assert.deepEqual(JSON.parse(normalized), {
+ global: { $regularExpression: { pattern: "value", options: "" } },
+ sticky: { $regularExpression: { pattern: "value", options: "" } },
+ verbose: { $regularExpression: { pattern: "value", options: "is" } },
+ });
+});
+
+test("normalizeJsonArgument rejects malformed Mongo shell regex literals", () => {
+ for (const source of ["{pattern: /unterminated}", "{pattern: /value/ii}", "{pattern: /value/q}"]) {
+ assert.equal(normalizeJsonArgument(source), null, source);
+ }
+});
+
test("parseMongoWriteCommand parses createIndex with optional options", () => {
assert.deepEqual(parseMongoWriteCommand("db.users.createIndex({email: 1}, {unique: true, name: 'users_email_unique'})"), {
kind: "createIndex",
diff --git a/packages/mongo-shell/src/json.ts b/packages/mongo-shell/src/json.ts
index 19573ec571..7914465f25 100644
--- a/packages/mongo-shell/src/json.ts
+++ b/packages/mongo-shell/src/json.ts
@@ -7,7 +7,9 @@
export function normalizeJsonArgument(value: string): string | null {
const trimmed = value.trim();
if (!trimmed) return "{}";
- const withoutComments = stripMongoJsonComments(trimmed).trim();
+ const withRegexLiterals = replaceMongoRegexLiterals(trimmed);
+ if (!withRegexLiterals) return null;
+ const withoutComments = stripMongoJsonComments(withRegexLiterals).trim();
if (!withoutComments) return "{}";
const withoutEjsonDeserialize = replaceMongoEjsonDeserialize(withoutComments);
// Rewrite mongo shell constructors that are not valid JSON into extended JSON
@@ -22,6 +24,160 @@ export function normalizeJsonArgument(value: string): string | null {
}
}
+const MONGO_REGEX_LITERAL_OPTIONS = new Set(["i", "m", "s", "u"]);
+// JS-only regex flags with no server-side meaning for a stored regex literal
+// (MongoDB's $regex has no global modifier) are dropped instead of failing
+// the whole command.
+const MONGO_REGEX_LITERAL_IGNORED_OPTIONS = new Set(["d", "g", "v", "y"]);
+
+interface MongoRegexLiteral {
+ end: number;
+ pattern: string;
+ options: string;
+}
+
+function mongoRegexLiteralAt(source: string, index: number): MongoRegexLiteral | null {
+ if (source[index] !== "/" || !isMongoRegexValuePosition(source, index)) return null;
+
+ return readMongoRegexLiteral(source, index);
+}
+
+function readMongoRegexLiteral(source: string, index: number): MongoRegexLiteral | null {
+ let cursor = index + 1;
+ let pattern = "";
+ let escaped = false;
+ let inCharacterClass = false;
+ let closed = false;
+ while (cursor < source.length) {
+ const current = source[cursor] ?? "";
+ if (current === "\n" || current === "\r" || current === "\u2028" || current === "\u2029") return null;
+ if (escaped) {
+ pattern += current;
+ escaped = false;
+ cursor += 1;
+ continue;
+ }
+ if (current === "\\") {
+ pattern += current;
+ escaped = true;
+ cursor += 1;
+ continue;
+ }
+ if (current === "[") inCharacterClass = true;
+ else if (current === "]" && inCharacterClass) inCharacterClass = false;
+ else if (current === "/" && !inCharacterClass) {
+ closed = true;
+ cursor += 1;
+ break;
+ }
+ pattern += current;
+ cursor += 1;
+ }
+ if (!closed) return null;
+
+ const options: string[] = [];
+ while (/[A-Za-z]/.test(source[cursor] ?? "")) {
+ const option = source[cursor] ?? "";
+ cursor += 1;
+ if (MONGO_REGEX_LITERAL_IGNORED_OPTIONS.has(option)) continue;
+ if (!MONGO_REGEX_LITERAL_OPTIONS.has(option) || options.includes(option)) return null;
+ options.push(option);
+ }
+ options.sort();
+ return { end: cursor, pattern, options: options.join("") };
+}
+
+function replaceMongoRegexLiterals(source: string): string | null {
+ let result = "";
+ let index = 0;
+
+ while (index < source.length) {
+ const char = source[index] ?? "";
+ if (char === '"' || char === "'") {
+ const start = index;
+ const quote = char;
+ index += 1;
+ let escaped = false;
+ while (index < source.length) {
+ const current = source[index] ?? "";
+ index += 1;
+ if (escaped) escaped = false;
+ else if (current === "\\") escaped = true;
+ else if (current === quote) break;
+ }
+ result += source.slice(start, index);
+ continue;
+ }
+
+ const commentEnd = mongoCommentEndAt(source, index);
+ if (commentEnd !== null) {
+ result += source.slice(index, commentEnd);
+ index = commentEnd;
+ continue;
+ }
+
+ if (char !== "/" || !isMongoRegexValuePosition(source, index)) {
+ result += char;
+ index += 1;
+ continue;
+ }
+
+ const literal = mongoRegexLiteralAt(source, index);
+ if (!literal) return null;
+ result += JSON.stringify({ $regularExpression: { pattern: literal.pattern, options: literal.options } });
+ index = literal.end;
+ }
+
+ return result;
+}
+
+function isMongoRegexValuePosition(source: string, index: number): boolean {
+ let previousSignificant: string | null = null;
+ let cursor = 0;
+
+ while (cursor < index) {
+ const char = source[cursor] ?? "";
+ if (char === '"' || char === "'") {
+ const quote = char;
+ cursor += 1;
+ let escaped = false;
+ while (cursor < index) {
+ const current = source[cursor] ?? "";
+ cursor += 1;
+ if (escaped) escaped = false;
+ else if (current === "\\") escaped = true;
+ else if (current === quote) break;
+ }
+ previousSignificant = "value";
+ continue;
+ }
+
+ const commentEnd = mongoCommentEndAt(source, cursor);
+ if (commentEnd !== null) {
+ cursor = Math.min(commentEnd, index);
+ continue;
+ }
+
+ if (char === "/" && isMongoRegexValuePrefix(previousSignificant)) {
+ const literal = readMongoRegexLiteral(source, cursor);
+ if (literal && literal.end <= index) {
+ previousSignificant = "value";
+ cursor = literal.end;
+ continue;
+ }
+ }
+
+ if (!/\s/.test(char)) previousSignificant = char;
+ cursor += 1;
+ }
+
+ return isMongoRegexValuePrefix(previousSignificant);
+}
+
+function isMongoRegexValuePrefix(previousSignificant: string | null): boolean {
+ return previousSignificant === null || previousSignificant === ":" || previousSignificant === "[" || previousSignificant === "," || previousSignificant === "(";
+}
+
/** Object-shaped shell arg (options documents, etc.). */
export function parseMongoObjectArgument(arg: string | undefined): string | null {
if (!arg?.trim()) return null;
@@ -82,6 +238,12 @@ export function splitTopLevel(source: string): string[] {
continue;
}
+ const regexLiteral = mongoRegexLiteralAt(source, i);
+ if (regexLiteral) {
+ i = regexLiteral.end - 1;
+ continue;
+ }
+
if (char === '"' || char === "'") quote = char;
else if (char === "{" || char === "[" || char === "(") depth += 1;
else if (char === "}" || char === "]" || char === ")") depth -= 1;
@@ -116,6 +278,12 @@ export function findMatchingParen(source: string, openIndex: number): number {
continue;
}
+ const regexLiteral = mongoRegexLiteralAt(source, i);
+ if (regexLiteral) {
+ i = regexLiteral.end - 1;
+ continue;
+ }
+
if (char === '"' || char === "'") quote = char;
else if (char === "(") depth += 1;
else if (char === ")") {
@@ -145,6 +313,11 @@ export function hasUnclosedMongoDelimiters(source: string): boolean {
i = commentEnd - 1;
continue;
}
+ const regexLiteral = mongoRegexLiteralAt(source, i);
+ if (regexLiteral) {
+ i = regexLiteral.end - 1;
+ continue;
+ }
if (char === '"' || char === "'") {
quote = char;
continue;