110 lines
5.0 KiB
TypeScript
110 lines
5.0 KiB
TypeScript
import type { DatabaseType, TreeNode } from "@/types/database";
|
|
import type { ElasticsearchDeleteByQueryResult } from "@/lib/backend/tauri";
|
|
|
|
/**
|
|
* `elasticsearch-index` tree nodes are also used for Meilisearch indexes, which
|
|
* speak a different API. Only true Elasticsearch-protocol connections expose the
|
|
* mapping/settings/stats and clear-index actions.
|
|
*/
|
|
export function isElasticsearchProtocolIndex(nodeType: string, dbType: DatabaseType | undefined): boolean {
|
|
return nodeType === "elasticsearch-index" && (dbType === "elasticsearch" || dbType === "easysearch");
|
|
}
|
|
|
|
export function elasticsearchIndexAliasLabel(node: Pick<TreeNode, "searchAliases">): string | undefined {
|
|
const aliases = node.searchAliases?.filter((alias) => alias.trim()) ?? [];
|
|
return aliases.length ? aliases.join(", ") : undefined;
|
|
}
|
|
|
|
/**
|
|
* With an `index_grouping` regex configured, a sidebar index node is a collapsed
|
|
* pattern (`logs-2026.08.*`) rather than one index, and clearing it hits every
|
|
* index the pattern matches. `*` and `?` are illegal in real Elasticsearch index
|
|
* names, so their presence identifies a pattern node unambiguously — the clear
|
|
* confirmation must spell that blast radius out instead of naming "an index".
|
|
*/
|
|
export function isElasticsearchIndexPattern(index: string): boolean {
|
|
return index.includes("*") || index.includes("?");
|
|
}
|
|
|
|
/**
|
|
* Whether a concrete index name falls under a grouped node's pattern, so
|
|
* surfaces open on that index (e.g. document tabs) know a wildcard clear
|
|
* touched their data too. `*` matches any run of characters and `?` exactly
|
|
* one, mirroring the sidebar grouping semantics.
|
|
*/
|
|
export function matchesElasticsearchIndexPattern(pattern: string, index: string): boolean {
|
|
const match = (patternOffset: number, indexOffset: number): boolean => {
|
|
while (patternOffset < pattern.length) {
|
|
const character = pattern[patternOffset]!;
|
|
if (character === "*") {
|
|
for (let next = indexOffset; next <= index.length; next++) {
|
|
if (match(patternOffset + 1, next)) return true;
|
|
}
|
|
return false;
|
|
}
|
|
if (character !== "?" && character !== index[indexOffset]) return false;
|
|
if (indexOffset >= index.length) return false;
|
|
patternOffset++;
|
|
indexOffset++;
|
|
}
|
|
return indexOffset === index.length;
|
|
};
|
|
return match(0, 0);
|
|
}
|
|
|
|
/**
|
|
* Whether the operator has cleared the extra hurdle a wildcard node imposes.
|
|
*
|
|
* A concrete index name confirms with the button alone. A pattern node clears
|
|
* every index it matches, so it additionally requires the pattern to be typed
|
|
* back verbatim — the same stance Elasticsearch takes with its own
|
|
* `action.destructive_requires_name` default. Surrounding whitespace is
|
|
* forgiven because it is invisible in the input; nothing else is.
|
|
*/
|
|
export function isElasticsearchClearConfirmed(index: string, typedName: string): boolean {
|
|
if (!isElasticsearchIndexPattern(index)) return true;
|
|
return typedName.trim() === index;
|
|
}
|
|
|
|
/**
|
|
* The request the clear action sends, shown verbatim in the confirmation dialog
|
|
* so the reviewer can see it deletes documents rather than the index itself.
|
|
*/
|
|
export function elasticsearchClearIndexPreview(index: string): string {
|
|
return `POST /${index}/_delete_by_query?conflicts=proceed&refresh=true\n{ "query": { "match_all": {} } }`;
|
|
}
|
|
|
|
export const ELASTICSEARCH_INDEX_CLEARED_EVENT = "dbx-elasticsearch-index-cleared";
|
|
|
|
export interface ElasticsearchIndexClearedDetail {
|
|
connectionId: string;
|
|
index: string;
|
|
}
|
|
|
|
/**
|
|
* Tells an open document browser for this index that its rows are gone. Best
|
|
* effort: the clear itself already succeeded by the time this runs, so a
|
|
* missing DOM (non-browser host) must not turn into a reported failure.
|
|
*/
|
|
export function notifyElasticsearchIndexCleared(connectionId: string, index: string): void {
|
|
if (typeof window === "undefined") return;
|
|
window.dispatchEvent(new CustomEvent<ElasticsearchIndexClearedDetail>(ELASTICSEARCH_INDEX_CLEARED_EVENT, { detail: { connectionId, index } }));
|
|
}
|
|
|
|
/** Returns an unsubscribe function, so callers cannot leak the listener by unregistering a different closure. */
|
|
export function subscribeElasticsearchIndexCleared(listener: (detail: ElasticsearchIndexClearedDetail) => void): () => void {
|
|
if (typeof window === "undefined") return () => undefined;
|
|
const handleEvent = (event: Event) => listener((event as CustomEvent<ElasticsearchIndexClearedDetail>).detail);
|
|
window.addEventListener(ELASTICSEARCH_INDEX_CLEARED_EVENT, handleEvent);
|
|
return () => window.removeEventListener(ELASTICSEARCH_INDEX_CLEARED_EVENT, handleEvent);
|
|
}
|
|
|
|
/**
|
|
* `_delete_by_query` returns HTTP 200 even when shards failed or documents were
|
|
* skipped on a version conflict, so a plain "cleared" toast can be wrong. Report
|
|
* a partial outcome whenever the run did not delete every matched document.
|
|
*/
|
|
export function isPartialElasticsearchClear(result: ElasticsearchDeleteByQueryResult): boolean {
|
|
return result.timedOut || result.failures.length > 0 || result.versionConflicts > 0 || result.deleted < result.total;
|
|
}
|