Files
dbx/apps/desktop/src/lib/nacos/nacosAdmin.ts
T

756 lines
28 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
import type { NacosConfigHistoryItem, NacosConfigItem, NacosConfigKey, NacosContentMatch, NacosImplementation, NacosInstanceInfo, NacosPermissionInfo, NacosRawRequest, NacosServiceInfo, NacosVersionMode } from "@/types/nacos";
import { diffArrays, diffChars } from "diff";
export type NacosRawTemplateKey = "serverState" | "namespaceList" | "configDetail" | "serviceList" | "instanceList";
export interface NacosRawTemplate {
key: NacosRawTemplateKey;
method: string;
path: string;
query: string;
body: string;
}
export const NACOS_RAW_TEMPLATES: NacosRawTemplate[] = [
{ key: "serverState", method: "GET", path: "/v3/admin/core/state", query: "", body: "" },
{ key: "namespaceList", method: "GET", path: "/v3/admin/core/namespace/list", query: "", body: "" },
{
key: "configDetail",
method: "GET",
path: "/v3/admin/cs/config",
query: "dataId=application.yaml&groupName=DEFAULT_GROUP&namespaceId=",
body: "",
},
{
key: "serviceList",
method: "GET",
path: "/v3/admin/ns/service/list",
query: "pageNo=1&pageSize=20&namespaceId=",
body: "",
},
{
key: "instanceList",
method: "GET",
path: "/v3/admin/ns/instance/list",
query: "serviceName=DEFAULT_GROUP@@example&namespaceId=",
body: "",
},
];
export interface RNacosOpenApiFallback {
serverAddr: string;
contextPath: string;
}
export interface RNacosOpenApiFallbackOptions {
/** Treat the well-known r-nacos console port as a candidate after the original connection fails. */
allowConsolePortInference?: boolean;
}
export interface NacosEndpointNormalization {
serverAddr: string;
contextPath: string;
detectedImplementation?: NacosImplementation;
detectedVersion?: Exclude<NacosVersionMode, "auto">;
warnings: string[];
}
export interface NacosEndpointNormalizationOptions {
implementation?: NacosImplementation;
versionMode?: NacosVersionMode;
contextPath?: string;
}
/**
* Splits a pasted browser/API URL into the persisted origin and API context.
* We only strip documented Nacos 3 UI routes; every other prefix remains an
* explicit context path so reverse proxies are not silently broken.
*/
export function normalizeNacosEndpoint(input: string, options: NacosEndpointNormalizationOptions = {}): NacosEndpointNormalization {
let url: URL;
try {
url = new URL(input.trim());
} catch {
throw new Error("Nacos address must be a valid absolute URL");
}
if (url.username || url.password) throw new Error("Nacos address must not contain embedded credentials");
const rawPath = url.pathname.replace(/\/+$/, "");
const implementation = options.implementation;
const versionMode = options.versionMode || "auto";
const warnings: string[] = [];
const hasRNacosSuffix = /\/rnacos$/i.test(rawPath);
const hasNacosSuffix = /\/nacos$/i.test(rawPath);
const hasNacos3UiSuffix = /\/(?:next(?:\/index\.html)?|index\.html)$/i.test(rawPath);
const detectedImplementation: NacosImplementation | undefined = implementation || (hasRNacosSuffix || url.port === "10848" ? "rnacos" : "nacos");
const detectedVersion: Exclude<NacosVersionMode, "auto"> | undefined = detectedImplementation === "rnacos" ? undefined : versionMode === "auto" ? (hasNacos3UiSuffix ? "v3" : hasNacosSuffix ? "v2" : undefined) : versionMode;
let contextPath = rawPath;
if (detectedImplementation === "rnacos") {
if (hasRNacosSuffix || url.port === "10848") warnings.push("This looks like an r-nacos console URL; use the compatible API address as the primary endpoint.");
contextPath = hasNacosSuffix ? rawPath : options.contextPath?.trim() || "/nacos";
} else if (detectedVersion === "v3" || hasNacos3UiSuffix) {
contextPath = rawPath.replace(/\/(?:next(?:\/index\.html)?|index\.html)$/i, "");
if (!contextPath) contextPath = options.contextPath?.trim() || "/nacos";
if (hasNacos3UiSuffix) warnings.push("The Nacos 3 console route was removed from the API context.");
} else if (!contextPath) {
contextPath = options.contextPath?.trim() || (versionMode === "v2" ? "/nacos" : "");
}
url.pathname = "/";
url.search = "";
url.hash = "";
return {
serverAddr: url.toString().replace(/\/$/, ""),
contextPath: contextPath ? `/${contextPath.replace(/^\/+|\/+$/g, "")}` : "",
detectedImplementation,
detectedVersion,
warnings,
};
}
export function normalizeNacosMetricsUrl(input: string): string {
const value = input.trim();
let url: URL;
try {
url = new URL(value);
} catch {
throw new Error("Nacos Prometheus metrics URL must be a valid absolute URL");
}
if (!["http:", "https:"].includes(url.protocol)) throw new Error("Nacos Prometheus metrics URL must use HTTP or HTTPS");
if (url.username || url.password) throw new Error("Nacos Prometheus metrics URL must not contain embedded credentials");
if (value.includes("#")) throw new Error("Nacos Prometheus metrics URL must not contain a fragment");
return url.toString();
}
export function nacosMetricsCandidates(serverAddr: string, contextPath: string, implementation: NacosImplementation): string[] {
const base = serverAddr.replace(/\/+$/, "");
const context = contextPath.replace(/\/+$/, "");
const raw = implementation === "rnacos" ? [`${base}/metrics`, `${base}${context}/metrics`, `${base}/rnacos/metrics`] : [`${base}${context}/actuator/prometheus`, `${base}/nacos/actuator/prometheus`, `${base}/actuator/prometheus`];
return [...new Set(raw.map((value) => new URL(value).toString()))];
}
/**
* r-nacos exposes its Nacos-compatible OpenAPI on the service port (8848) at
* `/nacos`; `/rnacos` on 10848 is the separate web console and rejects these
* OpenAPI POST requests. Port-only detection is deliberately opt-in: 10848
* may also be a legitimate user mapping for a normal Nacos OpenAPI, so callers
* must only use that weaker signal as a tested fallback candidate.
*/
export function resolveRNacosOpenApiFallback(serverAddr: string, contextPath: string, options: RNacosOpenApiFallbackOptions = {}): RNacosOpenApiFallback | null {
const normalizedContextPath = `/${contextPath.trim().replace(/^\/+|\/+$/g, "")}`.replace(/\/$/, "");
let parsed: URL;
try {
parsed = new URL(serverAddr.trim());
} catch {
return null;
}
const explicitRNacosContext = normalizedContextPath === "/rnacos";
const inferredRNacosConsolePort = options.allowConsolePortInference === true && parsed.port === "10848";
if (!explicitRNacosContext && !inferredRNacosConsolePort) return null;
if (parsed.port === "10848") parsed.port = "8848";
return {
serverAddr: parsed.toString().replace(/\/$/, ""),
contextPath: "/nacos",
};
}
export function parseNacosRawQuery(text: string): Record<string, string> | undefined {
const trimmed = text.trim().replace(/^\?/, "");
if (!trimmed) return undefined;
return Object.fromEntries(new URLSearchParams(trimmed).entries());
}
export function parseNacosManagedNamespaces(text: string): string[] {
return [
...new Set(
text
.split(/[\n,,]+/)
.map((value) => value.trim())
.filter(Boolean),
),
];
}
export type NacosNamespacePermissionAction = "r" | "w" | "rw";
export interface NacosNamespacePermissionAssignment {
namespaceId: string;
action: NacosNamespacePermissionAction;
}
/**
* The Nacos permission table may store read and write as separate rows for the
* same role and namespace. The editor exposes one assignment per namespace, so
* combine those rows before populating the form to avoid dropping either half
* when an unchanged role is saved.
*/
export function mergeNacosNamespacePermissionAssignments(permissions: Pick<NacosPermissionInfo, "actionRaw" | "parsedScope">[]): NacosNamespacePermissionAssignment[] {
const assignments = new Map<string, NacosNamespacePermissionAction>();
for (const permission of permissions) {
const namespaceId = permission.parsedScope?.namespaceId;
if (!namespaceId || !["r", "w", "rw"].includes(permission.actionRaw)) continue;
const current = assignments.get(namespaceId);
const readable = current?.includes("r") || permission.actionRaw.includes("r");
const writable = current?.includes("w") || permission.actionRaw.includes("w");
assignments.set(namespaceId, readable && writable ? "rw" : readable ? "r" : "w");
}
return [...assignments].map(([namespaceId, action]) => ({ namespaceId, action }));
}
export function parseNacosRawBody(text: string): unknown {
const trimmed = text.trim();
if (!trimmed) return undefined;
try {
return JSON.parse(trimmed);
} catch {
return text;
}
}
export function buildNacosRawRequest(method: string, path: string, queryText: string, bodyText: string): NacosRawRequest {
return {
method,
path: path.trim(),
query: parseNacosRawQuery(queryText),
body: parseNacosRawBody(bodyText),
};
}
export function isNacosRawMutation(method: string): boolean {
return method.trim().toUpperCase() !== "GET";
}
export function isNacosErrorCode(error: unknown, code: string): boolean {
const message = error instanceof Error ? error.message : String(error);
return message.includes(`NACOS_ERROR[${code}]`);
}
export function formatNacosConfigIdentity(item: Pick<NacosConfigItem, "namespace" | "dataId" | "group">, fallbackNamespace = ""): string {
return [`namespace=${item.namespace || fallbackNamespace || "public"}`, `dataId=${item.dataId}`, `group=${item.group || "DEFAULT_GROUP"}`].join("\n");
}
export function buildNacosConfigExport(item: NacosConfigItem, content: string): string {
return [`# namespace: ${item.namespace || "public"}`, `# dataId: ${item.dataId}`, `# group: ${item.group || "DEFAULT_GROUP"}`, item.configType ? `# type: ${item.configType}` : "", "", content].filter((line, index) => index >= 4 || line).join("\n");
}
export function buildNacosConfigCopy(item: NacosConfigItem, content: string): string {
return `${formatNacosConfigIdentity(item)}\n\n${content}`;
}
export function resolveNacosConfigCopyText(selectionText: string, editorText: string | undefined, stateText: string): string {
return selectionText || editorText || stateText;
}
export interface NacosLatestRequestGuard {
begin(): number;
invalidate(): void;
isCurrent(requestId: number): boolean;
}
export function createNacosLatestRequestGuard(): NacosLatestRequestGuard {
let sequence = 0;
return {
begin() {
sequence += 1;
return sequence;
},
invalidate() {
sequence += 1;
},
isCurrent(requestId) {
return requestId === sequence;
},
};
}
export interface NacosConfigSaveSnapshot {
requestId: number;
editorSessionId: number;
connectionId: string;
wasCreating: boolean;
originalKey: NacosConfigKey | null;
targetKey: NacosConfigKey;
config: NacosConfigItem;
content: string;
configType: string;
}
export interface NacosConfigSaveSnapshotInput {
requestId: number;
editorSessionId: number;
connectionId: string;
fallbackNamespace?: string;
originalKey: NacosConfigKey | null;
config: NacosConfigItem;
content: string;
configType: string;
}
export function createNacosConfigSaveSnapshot(input: NacosConfigSaveSnapshotInput): NacosConfigSaveSnapshot {
const dataId = input.config.dataId.trim();
const group = input.config.group.trim() || "DEFAULT_GROUP";
const namespace = input.originalKey?.namespace || input.config.namespace || input.fallbackNamespace || undefined;
const configType = input.configType || "text";
const config: NacosConfigItem = {
...input.config,
namespace: namespace || "",
dataId,
group,
content: input.content,
configType,
};
return {
requestId: input.requestId,
editorSessionId: input.editorSessionId,
connectionId: input.connectionId,
wasCreating: !input.originalKey,
originalKey: input.originalKey ? { ...input.originalKey } : null,
targetKey: { namespace, dataId, group },
config,
content: input.content,
configType,
};
}
export interface NacosConfigEditorComparableState {
latestRequestId: number;
editorSessionId: number;
connectionId: string;
originalKey: NacosConfigKey | null;
config: NacosConfigItem | null;
content: string;
configType: string;
}
function sameNacosConfigKey(left: NacosConfigKey | null, right: NacosConfigKey | null): boolean {
if (!left || !right) return left === right;
return (left.namespace || "") === (right.namespace || "") && left.dataId === right.dataId && (left.group || "DEFAULT_GROUP") === (right.group || "DEFAULT_GROUP");
}
export function isNacosConfigSaveSnapshotSameEditor(snapshot: NacosConfigSaveSnapshot, current: NacosConfigEditorComparableState): boolean {
const config = current.config;
return (
snapshot.requestId === current.latestRequestId &&
snapshot.editorSessionId === current.editorSessionId &&
snapshot.connectionId === current.connectionId &&
sameNacosConfigKey(snapshot.originalKey, current.originalKey) &&
!!config &&
snapshot.config.dataId === config.dataId.trim() &&
snapshot.config.group === (config.group.trim() || "DEFAULT_GROUP") &&
(snapshot.config.namespace || "") === (config.namespace || snapshot.targetKey.namespace || "")
);
}
export function isNacosConfigSaveSnapshotCurrent(snapshot: NacosConfigSaveSnapshot, current: NacosConfigEditorComparableState): boolean {
const config = current.config;
return (
isNacosConfigSaveSnapshotSameEditor(snapshot, current) &&
!!config &&
snapshot.content === current.content &&
snapshot.configType === current.configType &&
(snapshot.config.appName || "") === (config.appName || "") &&
(snapshot.config.desc || "") === (config.desc || "") &&
(snapshot.config.tags || "") === (config.tags || "")
);
}
export type NacosConfigSaveCompletion =
| { kind: "stale" }
| {
kind: "saved" | "saved-with-later-edits";
originalKey: NacosConfigKey;
savedConfig: NacosConfigItem;
baseline: {
content: string;
configType: string;
appName: string;
desc: string;
tags: string;
};
};
export function resolveNacosConfigSaveCompletion(snapshot: NacosConfigSaveSnapshot, current: NacosConfigEditorComparableState): NacosConfigSaveCompletion {
if (!isNacosConfigSaveSnapshotSameEditor(snapshot, current)) return { kind: "stale" };
return {
kind: isNacosConfigSaveSnapshotCurrent(snapshot, current) ? "saved" : "saved-with-later-edits",
originalKey: { ...snapshot.targetKey },
savedConfig: { ...snapshot.config },
baseline: {
content: snapshot.content,
configType: snapshot.configType,
appName: snapshot.config.appName || "",
desc: snapshot.config.desc || "",
tags: snapshot.config.tags || "",
},
};
}
export function canDeleteNacosConfig(readOnly: boolean, originalKey: NacosConfigKey | null): boolean {
return !readOnly && !!originalKey;
}
export interface NacosConfigMutationGuardState {
readOnly: boolean;
saving: boolean;
deleting: boolean;
hasPendingDelete: boolean;
hasPendingSave: boolean;
}
export function canStartNacosConfigSave(state: NacosConfigMutationGuardState): boolean {
return !state.readOnly && !state.saving && !state.deleting && !state.hasPendingDelete;
}
export function canStartNacosConfigDelete(state: NacosConfigMutationGuardState, originalKey: NacosConfigKey | null): boolean {
return canDeleteNacosConfig(state.readOnly, originalKey) && !state.saving && !state.deleting && !state.hasPendingSave && !state.hasPendingDelete;
}
export interface NacosConfigDeleteSnapshot {
connectionId: string;
key: NacosConfigKey;
config: NacosConfigItem;
}
export function createNacosConfigDeleteSnapshot(connectionId: string, key: NacosConfigKey, config: NacosConfigItem): NacosConfigDeleteSnapshot {
return {
connectionId,
key: {
namespace: key.namespace || undefined,
dataId: key.dataId,
group: key.group || "DEFAULT_GROUP",
},
config: {
...config,
namespace: key.namespace || "",
dataId: key.dataId,
group: key.group || "DEFAULT_GROUP",
},
};
}
export function isNacosConfigDeleteSnapshotInScope(snapshot: NacosConfigDeleteSnapshot, connectionId: string, namespace?: string): boolean {
return snapshot.connectionId === connectionId && (snapshot.key.namespace || "") === (namespace || "");
}
export interface NacosLiteralMatchSegment {
text: string;
matched: boolean;
}
export function splitNacosContentLiteralMatches(text: string, query: string): NacosLiteralMatchSegment[] {
if (!text || !query) return text ? [{ text, matched: false }] : [];
const segments: NacosLiteralMatchSegment[] = [];
let cursor = 0;
while (cursor < text.length) {
const matchIndex = text.indexOf(query, cursor);
if (matchIndex < 0) {
segments.push({ text: text.slice(cursor), matched: false });
break;
}
if (matchIndex > cursor) {
segments.push({ text: text.slice(cursor, matchIndex), matched: false });
}
segments.push({ text: text.slice(matchIndex, matchIndex + query.length), matched: true });
cursor = matchIndex + query.length;
}
return segments;
}
function nacosSearchCsvCell(value: string | number): string {
let text = String(value);
if (/^[\t\r ]*[=+\-@]/.test(text)) text = `'${text}`;
return `"${text.replaceAll('"', '""')}"`;
}
export function buildNacosContentSearchCsv(matches: readonly NacosContentMatch[]): string {
const rows: Array<Array<string | number>> = [["namespace", "group", "dataId", "lineNumber", "snippet"], ...matches.map((match) => [match.namespace || "public", match.group || "DEFAULT_GROUP", match.dataId, match.lineNumber, match.snippet])];
return `\uFEFF${rows.map((row) => row.map(nacosSearchCsvCell).join(",")).join("\r\n")}\r\n`;
}
export function sanitizeNacosConfigFileNameSegment(value: string): string {
const sanitized = value
.trim()
.replace(/[<>:"/\\|?*\p{Cc}]/gu, "_")
.replace(/\s+/g, " ")
.replace(/^[._\s-]+/, "")
.replace(/\.+$/, "");
return sanitized || "nacos-config";
}
export function nacosConfigFileExtension(configType?: string): string {
const normalized = configType?.trim().toLowerCase();
if (normalized === "yaml" || normalized === "yml") return "yaml";
if (normalized === "json") return "json";
if (normalized === "xml") return "xml";
if (normalized === "html") return "html";
if (normalized === "properties" || normalized === "props") return "properties";
if (normalized === "toml") return "toml";
return "txt";
}
export function buildNacosConfigExportFileName(item: Pick<NacosConfigItem, "dataId" | "configType">): string {
const baseName = sanitizeNacosConfigFileNameSegment(item.dataId || "nacos-config");
if (/\.[A-Za-z0-9][A-Za-z0-9_-]{0,15}$/.test(baseName)) return baseName;
return `${baseName}.${nacosConfigFileExtension(item.configType)}`;
}
export function createNacosSaveAsCopy(item: NacosConfigItem): NacosConfigItem {
return {
...item,
dataId: item.dataId ? `${item.dataId}.copy` : "",
content: item.content ?? "",
};
}
export interface NacosDiffSummary {
changed: boolean;
addedLines: number;
removedLines: number;
preview: string;
}
export type NacosDiffLineType = "equal" | "delete" | "insert" | "modify" | "padding";
export interface NacosInlineSegment {
value: string;
changed: boolean;
}
export interface NacosSideBySideDiffRow {
id: string;
leftLineNumber: number | null;
rightLineNumber: number | null;
leftContent: string;
rightContent: string;
leftType: NacosDiffLineType;
rightType: NacosDiffLineType;
leftInline: NacosInlineSegment[];
rightInline: NacosInlineSegment[];
}
export interface NacosInlineDiffRow {
id: string;
lineNumber: number | null;
content: string;
type: Exclude<NacosDiffLineType, "modify" | "padding">;
segments: NacosInlineSegment[];
}
export function summarizeNacosConfigDiff(before: string, after: string, maxPreviewLines = 40): NacosDiffSummary {
const changes = diffArrays(splitDiffLines(before), splitDiffLines(after));
const lines: string[] = [];
let addedLines = 0;
let removedLines = 0;
for (const change of changes) {
if (!change.added && !change.removed) continue;
const prefix = change.added ? "+" : "-";
for (const line of change.value) {
if (change.added) addedLines += 1;
else removedLines += 1;
if (lines.length < maxPreviewLines) lines.push(`${prefix} ${line}`);
}
}
const changed = addedLines > 0 || removedLines > 0;
if (!changed) return { changed: false, addedLines: 0, removedLines: 0, preview: "No content changes." };
if (lines.length < addedLines + removedLines) lines.push("...");
return { changed: true, addedLines, removedLines, preview: lines.join("\n") };
}
function normalizeNacosDiffText(value: string): string {
return value.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
}
function splitDiffLines(value: string): string[] {
const lines = normalizeNacosDiffText(value).split("\n");
if (lines.length > 0 && lines[lines.length - 1] === "") lines.pop();
return lines;
}
function inlineSegments(left: string, right: string): { left: NacosInlineSegment[]; right: NacosInlineSegment[] } {
const changes = diffChars(left, right);
const leftSegments: NacosInlineSegment[] = [];
const rightSegments: NacosInlineSegment[] = [];
for (const change of changes) {
if (change.removed) {
leftSegments.push({ value: change.value, changed: true });
} else if (change.added) {
rightSegments.push({ value: change.value, changed: true });
} else {
leftSegments.push({ value: change.value, changed: false });
rightSegments.push({ value: change.value, changed: false });
}
}
return { left: leftSegments, right: rightSegments };
}
function pairChangedLines(leftLines: string[], rightLines: string[], leftStart: number, rightStart: number, rows: NacosSideBySideDiffRow[], nextId: () => string) {
const max = Math.max(leftLines.length, rightLines.length);
for (let index = 0; index < max; index += 1) {
const left = leftLines[index];
const right = rightLines[index];
const hasLeft = left !== undefined;
const hasRight = right !== undefined;
const inline = hasLeft && hasRight ? inlineSegments(left, right) : { left: [], right: [] };
rows.push({
id: nextId(),
leftLineNumber: hasLeft ? leftStart + index : null,
rightLineNumber: hasRight ? rightStart + index : null,
leftContent: left ?? "",
rightContent: right ?? "",
leftType: hasLeft ? (hasRight ? "modify" : "delete") : "padding",
rightType: hasRight ? (hasLeft ? "modify" : "insert") : "padding",
leftInline: inline.left,
rightInline: inline.right,
});
}
}
export function buildNacosSideBySideDiff(before: string, after: string): NacosSideBySideDiffRow[] {
const changes = diffArrays(splitDiffLines(before), splitDiffLines(after));
const rows: NacosSideBySideDiffRow[] = [];
let leftLineNumber = 1;
let rightLineNumber = 1;
let id = 0;
const nextId = () => `nacos-diff-${id++}`;
for (let index = 0; index < changes.length; index += 1) {
const change = changes[index];
if (!change.added && !change.removed) {
for (const line of change.value) {
rows.push({
id: nextId(),
leftLineNumber,
rightLineNumber,
leftContent: line,
rightContent: line,
leftType: "equal",
rightType: "equal",
leftInline: [{ value: line, changed: false }],
rightInline: [{ value: line, changed: false }],
});
leftLineNumber += 1;
rightLineNumber += 1;
}
continue;
}
if (change.removed) {
const leftLines = change.value;
const next = changes[index + 1];
if (next?.added) {
const rightLines = next.value;
pairChangedLines(leftLines, rightLines, leftLineNumber, rightLineNumber, rows, nextId);
leftLineNumber += leftLines.length;
rightLineNumber += rightLines.length;
index += 1;
} else {
pairChangedLines(leftLines, [], leftLineNumber, rightLineNumber, rows, nextId);
leftLineNumber += leftLines.length;
}
continue;
}
if (change.added) {
const rightLines = change.value;
pairChangedLines([], rightLines, leftLineNumber, rightLineNumber, rows, nextId);
rightLineNumber += rightLines.length;
}
}
return rows;
}
function visibleInlineSegments(content: string, segments: NacosInlineSegment[]): NacosInlineSegment[] {
return segments.length ? segments : [{ value: content, changed: false }];
}
export function buildNacosInlineDiff(before: string, after: string): NacosInlineDiffRow[] {
return buildNacosSideBySideDiff(before, after).flatMap((row) => {
if (row.leftType === "equal" && row.rightType === "equal") {
return [
{
id: `${row.id}-equal`,
lineNumber: row.leftLineNumber,
content: row.leftContent,
type: "equal" as const,
segments: visibleInlineSegments(row.leftContent, row.leftInline),
},
];
}
const rows: NacosInlineDiffRow[] = [];
if (row.leftType === "delete" || row.leftType === "modify") {
rows.push({
id: `${row.id}-delete`,
lineNumber: row.leftLineNumber,
content: row.leftContent,
type: "delete",
segments: visibleInlineSegments(row.leftContent, row.leftInline),
});
}
if (row.rightType === "insert" || row.rightType === "modify") {
rows.push({
id: `${row.id}-insert`,
lineNumber: row.rightLineNumber,
content: row.rightContent,
type: "insert",
segments: visibleInlineSegments(row.rightContent, row.rightInline),
});
}
return rows;
});
}
export function buildNacosConfigDeleteConfirm(item: NacosConfigItem, fallbackNamespace = ""): string {
return formatNacosConfigIdentity(item, fallbackNamespace);
}
export function formatNacosHistoryTime(value?: string | null): string {
const trimmed = value?.trim();
if (!trimmed) return "-";
if (/^0+$/.test(trimmed)) return "-";
if (/^\d{10}(?:\d{3})?$/.test(trimmed)) {
const timestamp = Number(trimmed);
const date = new Date(trimmed.length === 10 ? timestamp * 1_000 : timestamp);
if (!Number.isNaN(date.getTime())) {
const datePart = [date.getFullYear(), date.getMonth() + 1, date.getDate()].map((part) => String(part).padStart(2, "0")).join("-");
const timePart = [date.getHours(), date.getMinutes(), date.getSeconds()].map((part) => String(part).padStart(2, "0")).join(":");
return `${datePart} ${timePart}`;
}
}
const match = trimmed.match(/^(\d{4}-\d{2}-\d{2})[T ](\d{2}:\d{2}:\d{2})(?:\.\d+)?(?:Z|[+-]\d{2}:?\d{2})?$/);
if (!match) return trimmed;
return `${match[1]} ${match[2]}`;
}
export function buildNacosConfigHistoryRollbackConfirm(item: NacosConfigHistoryItem, fallbackNamespace = ""): string {
return [`namespace=${item.namespace || fallbackNamespace || "public"}`, `dataId=${item.dataId}`, `group=${item.group || "DEFAULT_GROUP"}`, item.lastModifiedTime ? `historyTime=${item.lastModifiedTime}` : "", item.operator ? `operator=${item.operator}` : ""].filter(Boolean).join("\n");
}
export function buildNacosInstanceConfirm(service: NacosServiceInfo, instance: NacosInstanceInfo, patch: Partial<NacosInstanceInfo>, fallbackGroup = "", namespace = ""): string {
const targetEnabled = patch.enabled ?? instance.enabled;
const targetHealthy = patch.healthy ?? instance.healthy;
return [
`namespace=${namespace || "public"}`,
`serviceName=${service.serviceName}`,
`group=${instance.groupName || service.groupName || fallbackGroup || "DEFAULT_GROUP"}`,
`instance=${instance.ip}:${instance.port}`,
`cluster=${instance.clusterName || "DEFAULT"}`,
`ephemeral=${instance.ephemeral === true ? "true" : instance.ephemeral === false ? "false" : "unknown"}`,
patch.enabled == null ? "" : `targetEnabled=${targetEnabled === false ? "false" : "true"}`,
patch.healthy == null ? "" : `targetHealthy=${targetHealthy === false ? "false" : "true"}`,
patch.weight == null ? "" : `targetWeight=${patch.weight}`,
patch.metadata == null ? "" : `targetMetadata=${JSON.stringify(patch.metadata)}`,
]
.filter(Boolean)
.join("\n");
}
export function buildNacosRawMutationConfirm(req: NacosRawRequest): string {
return [`method=${req.method.toUpperCase()}`, `path=${req.path}`, req.query ? `query=${JSON.stringify(req.query)}` : ""].filter(Boolean).join("\n");
}