Files
dbx/apps/desktop/src/lib/redis/redisKeyPattern.ts
T

158 lines
6.4 KiB
TypeScript

// Full glob metacharacter set — escaped when a value must match literally
// (group subtree patterns, non-fuzzy text).
const REDIS_GLOB_SPECIAL_CHARS = /[\\*?[\]]/g;
// In fuzzy mode the user's `*` / `?` are intentional wildcards ("search keys
// containing this text"), so only `[` / `]` / `\` are escaped to avoid
// accidental character-class / escape ambiguity. The outer `*…*` wrap added
// by `redisKeySearchPattern` keeps the substring-contains contract, so inputs
// like `prod:*` or `2026*` match the same keys a SCAN with that glob would.
// (#9012: previously `*` was escaped too, so `prod:*` became a literal-`*`
// substring match and found nothing.)
const REDIS_GLOB_LITERAL_CHARS_FUZZY = /[\\[\]]/g;
export function escapeRedisGlobText(value: string, fuzzy = false): string {
return value.replace(fuzzy ? REDIS_GLOB_LITERAL_CHARS_FUZZY : REDIS_GLOB_SPECIAL_CHARS, "\\$&");
}
export function redisKeySearchPattern(value: string, fuzzy: boolean): string {
const pattern = value.trim();
if (!pattern) return "*";
return fuzzy ? `*${escapeRedisGlobText(pattern, fuzzy)}*` : pattern;
}
type RedisGlobToken = { kind: "literal"; value: number } | { kind: "star" } | { kind: "any" } | { kind: "class"; negate: boolean; chars: Set<number>; ranges: Array<[number, number]> };
const redisPatternEncoder = new TextEncoder();
const REDIS_NON_ASCII = /[\u0080-\uffff]/;
function parseRedisGlobClass(pattern: Uint8Array, start: number): { token: RedisGlobToken; next: number } {
let index = start + 1;
let negate = false;
if (pattern[index] === 94) {
negate = true;
index++;
}
const chars = new Set<number>();
const ranges: Array<[number, number]> = [];
while (index < pattern.length) {
if (pattern[index] === 93) {
return { token: { kind: "class", negate, chars, ranges }, next: index + 1 };
}
const value = pattern[index]!;
if (value === 92 && index + 1 < pattern.length) {
chars.add(pattern[index + 1]!);
index += 2;
} else if (index + 2 < pattern.length && pattern[index + 1] === 45) {
const startByte = (value << 24) >> 24;
const endByte = (pattern[index + 2]! << 24) >> 24;
ranges.push([Math.min(startByte, endByte), Math.max(startByte, endByte)]);
index += 3;
} else {
chars.add(value);
index++;
}
}
return { token: { kind: "class", negate, chars, ranges }, next: index };
}
function redisGlobTokens(patternText: string): RedisGlobToken[] {
const pattern = redisPatternEncoder.encode(patternText);
const tokens: RedisGlobToken[] = [];
for (let index = 0; index < pattern.length; index++) {
const value = pattern[index]!;
if (value === 92 && index + 1 < pattern.length) {
tokens.push({ kind: "literal", value: pattern[++index]! });
} else if (value === 42) {
if (tokens[tokens.length - 1]?.kind !== "star") tokens.push({ kind: "star" });
} else if (value === 63) {
tokens.push({ kind: "any" });
} else if (value === 91) {
const parsed = parseRedisGlobClass(pattern, index);
tokens.push(parsed.token);
index = parsed.next - 1;
} else {
tokens.push({ kind: "literal", value });
}
}
return tokens;
}
function redisGlobClassMatches(token: Extract<RedisGlobToken, { kind: "class" }>, value: number): boolean {
const signedValue = (value << 24) >> 24;
const matches = token.chars.has(value) || token.ranges.some(([start, end]) => start <= signedValue && signedValue <= end);
return token.negate ? !matches : matches;
}
export function createRedisKeyPatternMatcher(pattern: string): (value: string, keyRaw?: string) => boolean {
const tokens = redisGlobTokens(pattern);
return (value, keyRaw) => {
let bytes: string | Uint8Array;
if (keyRaw && value.includes("\\")) {
try {
bytes = atob(keyRaw);
} catch {
return false;
}
} else {
bytes = REDIS_NON_ASCII.test(value) ? redisPatternEncoder.encode(value) : value;
}
let valueIndex = 0;
let tokenIndex = 0;
let starTokenIndex = -1;
let starValueIndex = -1;
while (valueIndex < bytes.length) {
const token = tokens[tokenIndex];
const byte = typeof bytes === "string" ? bytes.charCodeAt(valueIndex) : bytes[valueIndex]!;
const matches = token?.kind === "literal" ? token.value === byte : token?.kind === "any" ? true : token?.kind === "class" ? redisGlobClassMatches(token, byte) : false;
if (matches) {
tokenIndex++;
valueIndex++;
} else if (token?.kind === "star") {
starTokenIndex = tokenIndex++;
starValueIndex = valueIndex;
} else if (starTokenIndex >= 0) {
tokenIndex = starTokenIndex + 1;
valueIndex = ++starValueIndex;
} else {
return false;
}
}
while (tokens[tokenIndex]?.kind === "star") tokenIndex++;
return tokenIndex === tokens.length;
};
}
export function redisKeyMatchesPattern(value: string, pattern: string): boolean {
return createRedisKeyPatternMatcher(pattern)(value);
}
/**
* SCAN MATCH pattern covering exactly the subtree of a tree group: every
* segment is glob-escaped so keys containing `*`/`?`/`[`/`]` match literally,
* and the trailing `*` only widens to the group's descendants.
*/
export function redisGroupSubtreePattern(pathSegments: readonly string[], separator = ":"): string {
const prefix = pathSegments.map((segment) => escapeRedisGlobText(segment)).join(separator);
return `${prefix}${separator}*`;
}
// Fuzzy key search has to walk the Redis keyspace because MATCH has no index.
// Start conservatively, then use DBSIZE to cover ordinary databases while
// retaining a hard upper bound for unusually large instances.
export const REDIS_KEY_SEARCH_SCAN_COUNT_BUDGET = 50_000;
export const REDIS_FUZZY_SEARCH_SCAN_COUNT_MAX = 1_000_000;
export function redisFuzzySearchScanBudget(totalKeys: number): number {
const normalizedTotalKeys = Number.isFinite(totalKeys) ? Math.max(0, Math.floor(totalKeys)) : 0;
return Math.min(Math.max(REDIS_KEY_SEARCH_SCAN_COUNT_BUDGET, normalizedTotalKeys), REDIS_FUZZY_SEARCH_SCAN_COUNT_MAX);
}
// Redis scan page size (COUNT parameter per SCAN round-trip) — shared defaults
// and validation bounds used by the connection form and key browser.
export const REDIS_SCAN_PAGE_SIZE_DEFAULT = 1000;
export const REDIS_SCAN_PAGE_SIZE_MIN = 200;
export const REDIS_SCAN_PAGE_SIZE_MAX = 10_000;
export const REDIS_SCAN_PAGE_SIZE_OPTIONS = [200, 1000, 2000, 5000, 10_000] as const;