From 6ccc467eba62bb5a11b293bcf4e5d4dfad2a76fe Mon Sep 17 00:00:00 2001 From: eust-w Date: Thu, 18 Jun 2026 12:49:46 +0800 Subject: [PATCH] =?UTF-8?q?=F0=9F=9B=A1=EF=B8=8F=20Validate=20database=20b?= =?UTF-8?q?rowser=20UI=20inputs?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- src/lib/database-browser.js | 196 +++++++++++++++++++++++ src/pages/DatabaseBrowser.tsx | 45 +++++- tests/frontend/database-browser.test.mjs | 48 +++++- 3 files changed, 281 insertions(+), 8 deletions(-) diff --git a/src/lib/database-browser.js b/src/lib/database-browser.js index 2f806a06..5b7a2f6e 100644 --- a/src/lib/database-browser.js +++ b/src/lib/database-browser.js @@ -34,3 +34,199 @@ export function buildDatabaseBrowserPageOptions({ limitText, skipText }) { error: errors.join("; "), }; } + +function isRecord(value) { + return Boolean(value) && typeof value === "object" && !Array.isArray(value); +} + +function hasEmptyPathSegment(value) { + return value.startsWith(".") || value.endsWith(".") || value.includes(".."); +} + +function containsNUL(value) { + return value.includes("\u0000"); +} + +function parseJSONRecord(rawValue, field) { + let parsed; + try { + parsed = JSON.parse(String(rawValue ?? "").trim() || "{}"); + } catch (_error) { + throw new Error(`${field} must be a valid JSON object`); + } + if (!isRecord(parsed)) { + throw new Error(`${field} must be a JSON object`); + } + return parsed; +} + +function firstIssue(issues) { + return issues[0] || ""; +} + +export function validateDatabaseCollectionName(value, { field = "collection name" } = {}) { + const name = String(value ?? "").trim(); + if (!name) { + return `${field} is required`; + } + if (name === "." || name === "..") { + return `${field} is invalid`; + } + if (containsNUL(name)) { + return `${field} cannot contain NUL bytes`; + } + if (/[\\/]/.test(name)) { + return `${field} cannot contain path separators`; + } + if (name.includes("$")) { + return `${field} cannot contain $`; + } + if (name.toLowerCase().startsWith("system.")) { + return `${field} cannot use the reserved system prefix`; + } + return ""; +} + +export function validateDatabaseIndexName(value, { required = false } = {}) { + const name = String(value ?? "").trim(); + if (!name) { + return required ? "index name is required" : ""; + } + if (name === "_id_") { + return "index name _id_ is reserved"; + } + if (containsNUL(name)) { + return "index name cannot contain NUL bytes"; + } + if (/[\\/]/.test(name)) { + return "index name cannot contain path separators"; + } + if (name.includes("$")) { + return "index name cannot contain $"; + } + return ""; +} + +export function validateDatabaseIndexKeys(keys) { + if (!isRecord(keys)) { + return "index keys must be a JSON object"; + } + const entries = Object.entries(keys); + if (entries.length === 0) { + return "index keys are required"; + } + for (const [key, value] of entries) { + const trimmedKey = key.trim(); + if (!trimmedKey) { + return "index keys cannot contain empty field names"; + } + if (containsNUL(trimmedKey)) { + return "index keys cannot contain NUL bytes"; + } + if (trimmedKey.startsWith("$")) { + return "index keys cannot contain Mongo operator keys"; + } + if (hasEmptyPathSegment(trimmedKey)) { + return "index keys cannot contain empty path segments"; + } + const normalizedDirection = String(value).trim().toLowerCase(); + if (!["1", "1.0", "-1", "-1.0", "text", "hashed", "2d", "2dsphere"].includes(normalizedDirection)) { + return "index key direction must be 1, -1, text, hashed, 2d, or 2dsphere"; + } + } + return ""; +} + +export function parseDatabaseIndexKeysText(rawValue) { + const keys = parseJSONRecord(rawValue, "index keys"); + const error = validateDatabaseIndexKeys(keys); + if (error) { + throw new Error(error); + } + return keys; +} + +export function validateDatabaseFilter(value, { field = "filter" } = {}) { + return firstIssue(validateDatabaseFilterValue(value, field)); +} + +function validateDatabaseFilterValue(value, field) { + const issues = []; + if (Array.isArray(value)) { + value.forEach((item, index) => { + issues.push(...validateDatabaseFilterValue(item, `${field}[${index}]`)); + }); + return issues; + } + if (!isRecord(value)) { + return issues; + } + for (const [key, item] of Object.entries(value)) { + const trimmedKey = key.trim(); + const itemField = trimmedKey ? `${field}.${trimmedKey}` : field; + if (!trimmedKey) { + issues.push(`${field} cannot contain empty field names`); + continue; + } + if (containsNUL(trimmedKey)) { + issues.push(`${field} cannot contain NUL bytes`); + continue; + } + if (trimmedKey === "$where") { + issues.push(`${field} cannot use the $where operator`); + continue; + } + if (!trimmedKey.startsWith("$") && hasEmptyPathSegment(trimmedKey)) { + issues.push(`${field} cannot contain empty path segments`); + continue; + } + issues.push(...validateDatabaseFilterValue(item, itemField)); + } + return issues; +} + +export function parseDatabaseFilterText(rawValue) { + const filter = parseJSONRecord(rawValue, "filter"); + const error = validateDatabaseFilter(filter); + if (error) { + throw new Error(error); + } + return filter; +} + +export function validateDatabaseDocumentPayload(value, { field = "document" } = {}) { + if (!isRecord(value)) { + return `${field} must be a JSON object`; + } + if (Object.keys(value).length === 0) { + return `${field} is required`; + } + return firstIssue(validateDatabaseDocumentValue(value, field)); +} + +function validateDatabaseDocumentValue(value, field) { + const issues = []; + if (Array.isArray(value)) { + value.forEach((item, index) => { + issues.push(...validateDatabaseDocumentValue(item, `${field}[${index}]`)); + }); + return issues; + } + if (!isRecord(value)) { + return issues; + } + for (const [key, item] of Object.entries(value)) { + const trimmedKey = key.trim(); + const itemField = trimmedKey ? `${field}.${trimmedKey}` : field; + if (!trimmedKey) { + issues.push(`${field} cannot contain empty field names`); + continue; + } + if (trimmedKey.startsWith("$")) { + issues.push(`${field} cannot contain Mongo operator keys`); + continue; + } + issues.push(...validateDatabaseDocumentValue(item, itemField)); + } + return issues; +} diff --git a/src/pages/DatabaseBrowser.tsx b/src/pages/DatabaseBrowser.tsx index df45ff20..6feed4b1 100644 --- a/src/pages/DatabaseBrowser.tsx +++ b/src/pages/DatabaseBrowser.tsx @@ -18,7 +18,14 @@ import { } from "lucide-react"; import { cn } from "../lib/utils"; import { formatCompactDateTime } from "../lib/datetime"; -import { buildDatabaseBrowserPageOptions } from "../lib/database-browser.js"; +import { + buildDatabaseBrowserPageOptions, + parseDatabaseFilterText, + parseDatabaseIndexKeysText, + validateDatabaseCollectionName, + validateDatabaseDocumentPayload, + validateDatabaseIndexName, +} from "../lib/database-browser.js"; import type { DatabaseCollectionSummary, DatabaseIndexSummary, @@ -256,10 +263,19 @@ export default function DatabaseBrowser() { setQueryError(pageOptions.error); return null; } + let filter: Record; + try { + filter = parseDatabaseFilterText(filterText) as Record; + } catch (error) { + setQueryLoading(false); + setQueryResult(null); + setQueryError(error instanceof Error ? error.message : "查询条件格式错误"); + return null; + } try { const item = await databaseApi.queryCollection(collection.name, { connectionId: selectedConnectionId, - filter: filterText, + filter: safeJSONStringify(filter), limit: pageOptions.limit, skip: pageOptions.skip, }); @@ -665,6 +681,11 @@ export default function DatabaseBrowser() { setCollectionActionError("请输入集合名称。"); return; } + const validationError = validateDatabaseCollectionName(name); + if (validationError) { + setCollectionActionError(validationError); + return; + } setCollectionActionLoading(true); setCollectionActionError(""); try { @@ -691,6 +712,11 @@ export default function DatabaseBrowser() { setCollectionActionError("请输入新的集合名称。"); return; } + const validationError = validateDatabaseCollectionName(newName, { field: "new collection name" }); + if (validationError) { + setCollectionActionError(validationError); + return; + } setCollectionActionLoading(true); setCollectionActionError(""); try { @@ -748,6 +774,10 @@ export default function DatabaseBrowser() { setDocumentActionError(""); try { const document = parseEditorDocument(); + const validationError = validateDatabaseDocumentPayload(document); + if (validationError) { + throw new Error(validationError); + } const currentDocumentId = documentIdValue(selectedDocument); const result = !isNewDocumentMode && currentDocumentId @@ -780,13 +810,14 @@ export default function DatabaseBrowser() { setIndexesError("请先选择集合。"); return; } + const indexNameError = validateDatabaseIndexName(indexDraftName); + if (indexNameError) { + setIndexesError(indexNameError); + return; + } let keys: Record; try { - const parsed = JSON.parse(indexDraftKeys); - if (!parsed || Array.isArray(parsed) || typeof parsed !== "object") { - throw new Error("索引 keys 必须是 JSON 对象。"); - } - keys = parsed as Record; + keys = parseDatabaseIndexKeysText(indexDraftKeys) as Record; } catch (error) { setIndexesError(error instanceof Error ? error.message : "索引定义格式错误"); return; diff --git a/tests/frontend/database-browser.test.mjs b/tests/frontend/database-browser.test.mjs index 56021261..2272cbff 100644 --- a/tests/frontend/database-browser.test.mjs +++ b/tests/frontend/database-browser.test.mjs @@ -1,7 +1,16 @@ import test from "node:test"; import assert from "node:assert/strict"; -import { buildDatabaseBrowserPageOptions, parseDatabaseBrowserPageNumber } from "../../src/lib/database-browser.js"; +import { + buildDatabaseBrowserPageOptions, + parseDatabaseBrowserPageNumber, + parseDatabaseFilterText, + parseDatabaseIndexKeysText, + validateDatabaseCollectionName, + validateDatabaseDocumentPayload, + validateDatabaseIndexName, + validateDatabaseIndexKeys, +} from "../../src/lib/database-browser.js"; test("database browser page parser keeps blank values as defaults", () => { assert.deepEqual(parseDatabaseBrowserPageNumber("", { field: "Limit", defaultValue: 50, minValue: 1 }), { @@ -50,3 +59,40 @@ test("database browser page options collect query errors before API calls", () = "Limit must be an integer; Skip must be greater than or equal to 0", ); }); + +test("database browser collection name validator mirrors backend reserved names", () => { + assert.equal(validateDatabaseCollectionName("orders_2026"), ""); + assert.match(validateDatabaseCollectionName("system.profile"), /reserved system prefix/); + assert.match(validateDatabaseCollectionName("orders/archive"), /path separators/); + assert.match(validateDatabaseCollectionName("orders$archive"), /cannot contain \$/); +}); + +test("database browser index validators reject unsafe index definitions", () => { + assert.equal(validateDatabaseIndexName("orders_created_at"), ""); + assert.match(validateDatabaseIndexName("_id_"), /reserved/); + assert.deepEqual(parseDatabaseIndexKeysText('{ "createdAt": -1, "status": 1 }'), { + createdAt: -1, + status: 1, + }); + assert.equal(validateDatabaseIndexKeys({ name: "text", location: "2dsphere" }), ""); + assert.match(validateDatabaseIndexKeys({ $where: 1 }), /operator keys/); + assert.match(validateDatabaseIndexKeys({ "metadata..name": 1 }), /empty path segments/); + assert.throws(() => parseDatabaseIndexKeysText('{ "createdAt": "ascending" }'), /index key direction/); +}); + +test("database browser filter parser rejects unsafe query operators before API calls", () => { + assert.deepEqual(parseDatabaseFilterText('{ "$or": [{ "status": "open" }, { "priority": { "$in": [1, 2] } }] }'), { + $or: [{ status: "open" }, { priority: { $in: [1, 2] } }], + }); + assert.deepEqual(parseDatabaseFilterText(""), {}); + assert.throws(() => parseDatabaseFilterText('{ "$where": "return true" }'), /cannot use the \$where operator/); + assert.throws(() => parseDatabaseFilterText('{ "metadata..name": "demo" }'), /empty path segments/); + assert.throws(() => parseDatabaseFilterText('{ "": "demo" }'), /empty field names/); +}); + +test("database browser document payload validator rejects empty and operator-key documents", () => { + assert.equal(validateDatabaseDocumentPayload({ name: "demo", nested: [{ count: 1 }] }), ""); + assert.match(validateDatabaseDocumentPayload({}), /required/); + assert.match(validateDatabaseDocumentPayload({ $set: { name: "demo" } }), /operator keys/); + assert.match(validateDatabaseDocumentPayload({ nested: [{ $inc: { count: 1 } }] }), /operator keys/); +});