fix(ui): сохранять фильтры серверов в адресе страницы

lib/data-filters/server-url-state.test.ts

@@ -0,0 +1,37 @@
+import assert from "node:assert/strict"
+import { test } from "node:test"
+import { emptyServerQuery, encodeServerQuery, patchServerUrl, readServerUrl, validateServerQuery } from "./server-url-state"
+import type { FilterQuery } from "../../components/reui/filters/filters-types"
+const query = (): FilterQuery => ({ ...emptyServerQuery(), combinator: "or", rules: [
+  { id: "a", type: "rule", path: ["country"], operator: "is_any_of", value: ["RU", "DE"], negated: true },
+  { id: "nested", type: "group", combinator: "and", rules: [{ id: "b", type: "rule", path: ["status"], operator: "is", value: "offline" }] },
+] })
+test("URL roundtrip preserves groups, negation, context and unrelated keys", () => {
+  const href = patchServerUrl(new URLSearchParams("server=2&keep=1"), { q: "Тест & /", type: "exit-node", filters: encodeServerQuery(query()) })
+  const params = new URL(href, "http://test").searchParams
+  assert.deepEqual(readServerUrl(params), { search: "Тест & /", type: "exit-node", query: query(), error: null })
+  assert.equal(patchServerUrl(params, { q: null, type: null, filters: null }), "/servers?server=2&keep=1")
+})
+test("draft conditions never serialize as a completed filter", () => {
+  const draft = { ...emptyServerQuery(), rules: [{ id: "draft", type: "rule" as const, path: ["status"], operator: "is", value: undefined }] }
+  assert.equal(validateServerQuery(draft), "draft")
+  assert.throws(() => encodeServerQuery(draft))
+  assert.ok(readServerUrl(new URLSearchParams({ filters: JSON.stringify({ v: 1, query: draft }) })).error)
+})
+test("invalid URL variants are rejected instead of widening a selection", () => {
+  for (const filters of ["{", "null", JSON.stringify({ v: 2, query: query() }), " ".repeat(8193), JSON.stringify({ v: 1, query: { ...query(), rules: [{ id: "x", type: "rule", path: ["password"], operator: "is", value: "RU" }] } })]) {
+    assert.ok(readServerUrl(new URLSearchParams({ filters })).error)
+  }
+  assert.ok(readServerUrl(new URLSearchParams("type=unexpected")).error)
+  assert.ok(readServerUrl(new URLSearchParams("type=exit-node&type=jump-host")).error)
+})
+test("limits, IDs, operator arity and values are validated", () => {
+  const rule = { id: "r", type: "rule", path: ["country"], operator: "is", value: "RU" }
+  for (const rules of [[rule, rule], [{ ...rule, operator: "unknown" }], [{ ...rule, value: "XX" }], [{ ...rule, operator: "is_any_of" }], [{ ...rule, operator: "empty" }], Array.from({ length: 51 }, (_, i) => ({ ...rule, id: String(i) }))]) {
+    assert.equal(validateServerQuery({ ...emptyServerQuery(), rules }), "invalid")
+  }
+  let nested: FilterQuery = emptyServerQuery()
+  for (let i = 0; i < 6; i++) nested = { id: "group" + i, type: "group", combinator: "and", rules: [nested] }
+  assert.equal(validateServerQuery(nested), "invalid")
+  assert.equal(encodeServerQuery(emptyServerQuery()), null)
+})

lib/data-filters/server-url-state.ts

@@ -0,0 +1,68 @@
+import type { FilterQuery } from "@/components/reui/filters/filters-types"
+import { SERVER_FILTER_FIELDS } from "./server-filter-fields"
+
+export type ServerTypeFilter = "all" | "jump-host" | "exit-node" | "home-router"
+export const emptyServerQuery = (): FilterQuery => ({ id: "root", type: "group", combinator: "and", rules: [] })
+const types = ["jump-host", "exit-node", "home-router"]
+const MAX_BYTES = 8192
+const options = new Map(SERVER_FILTER_FIELDS.map(field => [field.id, new Set((field.options ?? []).map(option => option.value))]))
+const record = (value: unknown): value is Record<string, unknown> => typeof value === "object" && value !== null && !Array.isArray(value)
+
+export function validateServerQuery(value: unknown): "valid" | "draft" | "invalid" {
+  const ids = new Set<string>()
+  let count = 0
+  let draft = false
+  function visit(node: unknown, depth: number): boolean {
+    if (!record(node) || depth > 4 || ++count > 50 || typeof node.id !== "string" || !node.id || ids.has(node.id)) return false
+    ids.add(node.id)
+    if (node.type === "group") return (node.combinator === "and" || node.combinator === "or") && Array.isArray(node.rules) && node.rules.every(child => visit(child, depth + 1))
+    if (node.type !== "rule" || !Array.isArray(node.path) || node.path.length !== 1 || typeof node.path[0] !== "string") return false
+    const allowed = options.get(node.path[0])
+    if (!allowed || (node.negated !== undefined && typeof node.negated !== "boolean")) return false
+    if (node.operator === "" || node.operator === undefined) { draft = true; return true }
+    if (node.operator === "empty" || node.operator === "not_empty") return node.value === undefined
+    if (!["is", "is_not", "is_any_of", "is_none_of"].includes(String(node.operator))) return false
+    if (node.value === undefined || node.value === "" || (Array.isArray(node.value) && node.value.length === 0)) { draft = true; return true }
+    if (node.operator === "is" || node.operator === "is_not") return typeof node.value === "string" && allowed.has(node.value)
+    return Array.isArray(node.value) && node.value.every(item => typeof item === "string" && allowed.has(item))
+  }
+  if (!record(value) || value.type !== "group" || !visit(value, 0)) return "invalid"
+  return draft ? "draft" : "valid"
+}
+
+export function encodeServerQuery(query: FilterQuery): string | null {
+  if (validateServerQuery(query) !== "valid") throw new Error("Завершите условия фильтра и проверьте их значения.")
+  if (query.rules.length === 0) return null
+  const encoded = JSON.stringify({ v: 1, query })
+  if (new TextEncoder().encode(encoded).length > MAX_BYTES) throw new Error("Слишком большой набор фильтров для ссылки.")
+  return encoded
+}
+
+export function readServerUrl(params: URLSearchParams) {
+  const search = params.get("q") ?? ""
+  const rawType = params.get("type")
+  const type: ServerTypeFilter = types.includes(rawType ?? "") ? rawType as ServerTypeFilter : "all"
+  let error: string | null = rawType !== null && !types.includes(rawType) ? "В ссылке указан неизвестный тип сервера." : null
+  let query = emptyServerQuery()
+  const raw = params.get("filters")
+  if (["q", "type", "filters"].some(key => params.getAll(key).length > 1)) error = "В ссылке повторяются параметры списка."
+  if (raw !== null) {
+    try {
+      if (new TextEncoder().encode(raw).length > MAX_BYTES) throw new Error()
+      const parsed: unknown = JSON.parse(raw)
+      if (!record(parsed) || parsed.v !== 1 || validateServerQuery(parsed.query) !== "valid") throw new Error()
+      query = parsed.query as FilterQuery
+    } catch { error = "Не удалось прочитать фильтры из ссылки. Сбросьте фильтры и задайте их заново." }
+  }
+  return { search, type, query, error }
+}
+
+/** Update only owned keys; retain object context and parameters from other features. */
+export function patchServerUrl(params: URLSearchParams, changes: Record<string, string | null>) {
+  const next = new URLSearchParams(params)
+  for (const [key, value] of Object.entries(changes)) {
+    if (value === null || value === "") next.delete(key)
+    else next.set(key, value)
+  }
+  return "/servers" + (next.size ? "?" + next.toString() : "")
+}