25 MB lightweight cross-platform database client for 100+ databases, including MySQL, PostgreSQL, SQLite, Redis, MongoDB, DuckDB, SQL Server, and Dameng. Built-in AI, MCP Server, CLI, desktop and Docker. | 轻量级跨平台数据库管理工具,支持 MySQL、PostgreSQL、SQLite、Redis、MongoDB、达梦等 100+ 数据库,提供桌面端、Docker、CLI、内置 AI 助手和 MCP。
TypeScript aicliclickhousedatabasedatabase-clientdatabase-managementdockerguimcpmongodbmysqlpostgresqlredisrustsql-serversqlitetaurivue
<script setup lang="ts">
import { computed, nextTick, onBeforeUnmount, reactive, ref, shallowRef, watch } from "vue";
import { AlertTriangle, ChevronDown, Circle, CircleHelp, CircleMinus, CircleX, Clock, Loader2, RefreshCw, Wrench } from "@lucide/vue";
import { useI18n } from "vue-i18n";
import { DynamicScroller, DynamicScrollerItem } from "vue-virtual-scroller";
import "vue-virtual-scroller/dist/vue-virtual-scroller.css";
import { Button } from "@/components/ui/button";
import { Dialog, DialogContent, DialogFooter, DialogHeader, DialogTitle } from "@/components/ui/dialog";
import { Input } from "@/components/ui/input";
import { DropdownMenu, DropdownMenuCheckboxItem, DropdownMenuContent, DropdownMenuSeparator, DropdownMenuTrigger } from "@/components/ui/dropdown-menu";
import type { ConnectionConfig, DatabaseType } from "@/types/database";
import * as api from "@/lib/backend/api";
import { executeWithProductionSqlGuard } from "@/lib/database/productionExecutionGuard";
import { effectiveDatabaseTypeForConnection } from "@/lib/database/jdbcDialect";
import { uuid } from "@/lib/common/utils";
import { formatError, normalizeBackendError } from "@/lib/backend/errorUtils";
import { oracleWriteRejected } from "@/lib/database/oracleSecurity";
import { readOracleTriggerSnapshot, prepareOracleTriggerPlan, type OracleTriggerSnapshot, type OracleTriggerTarget, type OracleTriggerExecutionResult } from "@/lib/database/oracleTriggerPlan";
import { confirmOracleTriggerPlan } from "@/lib/database/oracleTriggerActions";
import {
oracleCompileUnsupportedReason,
oracleInvalidObjectSourceKind,
buildOracleCompileSql,
buildOracleInvalidObjectsSql,
buildOracleObjectErrorsSql,
buildOracleObjectIdentitySql,
buildOracleObjectStatusSql,
mapOracleInvalidObjects,
mapOracleObjectErrors,
readAllOracleInvalidObjects,
type OracleInvalidObject,
type OracleObjectError,
} from "@/lib/database/oracleInvalidObjects";
const props = defineProps<{ open: boolean; connection: ConnectionConfig; database: string; schema: string; triggerContext?: { target: Readonly<OracleTriggerTarget>; expectedObjectId?: string; originTabId?: string; originRevision?: number } }>();
const emit = defineEmits<{
"update:open": [open: boolean];
"open-source": [object: OracleInvalidObject, location?: Pick<OracleObjectError, "line" | "position">];
"compile-finished": [scope: { connectionId: string; database: string; schema: string }];
"trigger-result": [target: Readonly<OracleTriggerTarget>, result: OracleTriggerExecutionResult, before: OracleTriggerSnapshot, originTabId?: string, originRevision?: number];
}>();
const { t } = useI18n();
const objects = ref<OracleInvalidObject[]>([]);
const selected = ref<OracleInvalidObject | null>(null);
const selectedObjects = ref(new Map<string, OracleInvalidObject>());
const currentView = ref<"list" | "detail">("list");
const detailReturnKey = ref("");
const nameFilter = ref("");
const typeFilter = ref<Set<string> | null>(null);
const fullObjects = ref<OracleInvalidObject[]>([]);
const unverifiedKeys = ref(new Set<string>());
const rowResults = ref(new Map<string, BatchItem>());
const fullReadState = ref<"idle" | "reading" | "complete" | "error" | "stopped">("idle");
const fullReadError = ref("");
const fullReadGeneration = ref(0);
const verifyMissingOnNextRead = ref(false);
const errors = ref<OracleObjectError[]>([]);
const triggerSnapshot = shallowRef<OracleTriggerSnapshot>();
const diagnosticErrors = computed(() => (props.triggerContext ? (triggerSnapshot.value?.metadata.errors ?? []) : errors.value));
const errorsTruncated = ref(false);
const loadError = ref("");
const errorLoadError = ref("");
const loading = ref(false);
const compiling = ref(false);
const truncated = ref(false);
const outcome = ref("");
const fullReadCount = ref(0);
const generation = ref(0);
type ManagedSession = { id: string; connectionId: string; database: string; active: number; closeRequested: boolean; closed: boolean };
type ExecutionScope = { connection: ConnectionConfig; connectionKey: string; database: string; schema: string; generation: number; session: ManagedSession };
type BatchStatus = "pending" | "running" | "unsupported" | "valid" | "still-invalid" | "already-valid" | "target-changed" | "deleted" | "failed" | "unknown" | "not-run";
type BatchItem = { object: OracleInvalidObject; sql?: string; unsupportedReason?: "unsupported-type" | "unsupported-on-engine"; status: BatchStatus; message?: string; errors?: OracleObjectError[]; errorsTruncated?: boolean; diagnosticError?: string };
type BatchRun = {
id: string;
scope: ExecutionScope;
state: "running" | "complete";
readCount: number;
items: BatchItem[];
stopRequested: boolean;
submittedAny: boolean;
currentName: string;
readError: string;
remaining?: OracleInvalidObject[];
remainingError: string;
};
const batchRun = ref<BatchRun | null>(null);
const batchSupportedCount = computed(() => batchRun.value?.items.filter((item) => !!item.sql).length ?? 0);
const batchSkippedCount = computed(() => batchRun.value?.items.filter((item) => !item.sql || item.status === "not-run").length ?? 0);
const batchHandledCount = computed(() => batchRun.value?.items.filter((item) => item.status !== "pending" && item.status !== "running" && item.status !== "unsupported").length ?? 0);
const batchValidCount = computed(() => batchRun.value?.items.filter((item) => item.status === "valid" || item.status === "already-valid").length ?? 0);
const batchStillInvalidCount = computed(() => batchRun.value?.items.filter((item) => item.status === "still-invalid").length ?? 0);
const batchFailureCount = computed(() => batchRun.value?.items.filter((item) => item.status === "failed" || item.status === "unknown" || item.status === "target-changed" || item.status === "deleted").length ?? 0);
let batchExecutionGeneration = 0;
function newManagedSession(connectionId: string, database: string): ManagedSession {
return { id: `invalid-objects:${uuid()}`, connectionId, database, active: 0, closeRequested: false, closed: false };
}
let managedSession: ManagedSession | null = null;
let sessionDrainWaiters: Array<() => void> = [];
const displayedObjects = computed(() => objects.value);
const filteredObjects = computed(() => displayedObjects.value.filter(matchesFilters));
const availableTypes = computed(() => [...new Set([...objects.value.map((object) => object.type), ...(typeFilter.value ?? [])])].sort());
const hasFilters = computed(() => nameFilter.value !== "" || typeFilter.value !== null);
const selectedCount = computed(() => selectedObjects.value.size);
const selectedSupportedCount = computed(() => [...selectedObjects.value.values()].filter(canCompileObject).length);
const completeMatchingObjects = computed(() => {
const completeObjects = new Map(fullObjects.value.map((object) => [selectionKey(object), object]));
return filteredObjects.value.flatMap((object) => {
const current = completeObjects.get(selectionKey(object));
return current && sameObject(object, current) && object.lastDdlTime === current.lastDdlTime && !unverifiedKeys.value.has(selectionKey(object)) ? [current] : [];
});
});
const allSupportedCount = computed(() => completeMatchingObjects.value.filter(canCompileObject).length);
const allSelectedInFilter = computed(() => {
const supported = filteredObjects.value.filter(canCompileObject);
return supported.length > 0 && supported.every((object) => selectedObjects.value.has(selectionKey(object)));
});
const someSelectedInFilter = computed(() => filteredObjects.value.some((object) => selectedObjects.value.has(selectionKey(object))) && !allSelectedInFilter.value);
let singleCompilationGeneration = 0;
let diagnosticGeneration = 0;
let listLoadGeneration = 0;
const databaseType = computed(() => (effectiveDatabaseTypeForConnection(props.connection) ?? props.connection.db_type) as DatabaseType);
const compileDatabaseType = computed(() => (props.triggerContext && triggerSnapshot.value ? (triggerSnapshot.value.metadata.engine === "dm" ? "dameng" : triggerSnapshot.value.metadata.engine) : databaseType.value));
const compileOptions = computed(() => (props.triggerContext ? { triggerProfile: triggerSnapshot.value?.metadata } : undefined));
type ListCache = { keys: Array<string | number>; sizes: Array<number | null> };
type ListScroller = {
$el: HTMLElement;
findItemIndex: (offset: number) => number;
getItemOffset: (index: number) => number;
scrollToItem: (index: number, options?: { align: "nearest" }) => void;
scrollToPosition: (position: number) => void;
cacheSnapshot: ListCache;
};
type ListViewport = { key: string; index: number; offset: number; focusedKey?: string; focusedControl?: "checkbox" | "name" };
const listScroller = ref<ListScroller | null>(null);
const listCache = shallowRef<ListCache>();
let detailViewport: ListViewport | null = null;
let viewportGeneration = 0;
function isCurrent(token: number): boolean {
return token === generation.value && props.open;
}
function selectionKey(object: OracleInvalidObject): string {
return `${object.owner}:${object.objectId}`;
}
function sameObject(left: OracleInvalidObject, right: OracleInvalidObject): boolean {
return selectionKey(left) === selectionKey(right) && left.name === right.name && left.type === right.type;
}
function renderKey(object: OracleInvalidObject): string {
return JSON.stringify([object.owner, object.name, object.type, object.objectId]);
}
function matchesFilters(object: OracleInvalidObject): boolean {
return object.name.toLowerCase().includes(nameFilter.value.toLowerCase()) && (typeFilter.value === null || typeFilter.value.has(object.type));
}
function captureViewport(): ListViewport | null {
const scroller = listScroller.value;
if (!scroller || currentView.value !== "list" || filteredObjects.value.length === 0) return null;
const index = Math.min(Math.max(0, scroller.findItemIndex(scroller.$el.scrollTop)), filteredObjects.value.length - 1);
const object = filteredObjects.value[index]!;
const focused = scroller.$el.contains(document.activeElement) ? (document.activeElement as HTMLElement) : null;
return { key: renderKey(object), index, offset: scroller.$el.scrollTop - scroller.getItemOffset(index), focusedKey: focused?.closest<HTMLElement>("[data-row-key]")?.dataset.rowKey, focusedControl: focused?.tagName === "INPUT" ? "checkbox" : "name" };
}
async function restoreViewport(viewport: ListViewport | null, focusKey?: string, control: "checkbox" | "name" = "name") {
if (!viewport) return;
const requestId = ++viewportGeneration;
const token = generation.value;
await nextTick();
if (!isCurrent(token) || requestId !== viewportGeneration || currentView.value !== "list") return;
const rows = filteredObjects.value;
if (rows.length === 0) {
if (focusKey) document.querySelector<HTMLElement>("[data-list-heading]")?.focus();
return;
}
const anchorIndex = rows.findIndex((object) => renderKey(object) === viewport.key);
const index = anchorIndex >= 0 ? anchorIndex : Math.min(viewport.index, rows.length - 1);
listScroller.value?.scrollToPosition(Math.max(0, (listScroller.value?.getItemOffset(index) ?? 0) + viewport.offset));
if (!focusKey) return;
const focusIndex = rows.findIndex((object) => renderKey(object) === focusKey);
const targetIndex = focusIndex >= 0 ? focusIndex : index;
listScroller.value?.scrollToItem(targetIndex, { align: "nearest" });
await nextTick();
await new Promise<void>((resolve) => requestAnimationFrame(() => resolve()));
if (!isCurrent(token) || requestId !== viewportGeneration || currentView.value !== "list") return;
const row = Array.from(listScroller.value?.$el.querySelectorAll<HTMLElement>("[data-row-key]") ?? []).find((element) => element.dataset.rowKey === renderKey(rows[targetIndex]!));
(row?.querySelector<HTMLElement>(control === "checkbox" ? "input:not(:disabled)" : "[data-object-key]") ?? row?.querySelector<HTMLElement>("[data-object-key]") ?? document.querySelector<HTMLElement>("[data-list-heading]"))?.focus({ preventScroll: true });
}
function keepViewport(viewport: ListViewport | null) {
const focusedRemoved = viewport?.focusedKey && !filteredObjects.value.some((object) => renderKey(object) === viewport.focusedKey);
void restoreViewport(viewport, focusedRemoved ? viewport.focusedKey : undefined, viewport?.focusedControl);
}
function resetFilterSelection() {
selectedObjects.value = new Map();
viewportGeneration++;
detailViewport = null;
void nextTick(() => listScroller.value?.scrollToPosition(0));
}
function setNameFilter(value: string | number) {
if (compiling.value) return;
resetFilterSelection();
nameFilter.value = String(value);
}
function setTypeFilter(type: string, checked: boolean) {
if (compiling.value) return;
resetFilterSelection();
const next = new Set(typeFilter.value ?? availableTypes.value);
if (checked) next.add(type);
else next.delete(type);
typeFilter.value = next;
}
function setAllTypes(checked: boolean) {
if (compiling.value) return;
resetFilterSelection();
typeFilter.value = checked ? null : new Set();
}
function clearFilters() {
if (compiling.value) return;
resetFilterSelection();
nameFilter.value = "";
typeFilter.value = null;
}
function onRowTab(event: KeyboardEvent, object: OracleInvalidObject, control: "checkbox" | "name") {
if (event.ctrlKey || event.altKey || event.metaKey) return;
if ((!event.shiftKey && control === "checkbox") || (event.shiftKey && control === "name" && !compiling.value && canCompileObject(object))) return;
const index = filteredObjects.value.findIndex((row) => sameObject(row, object)) + (event.shiftKey ? -1 : 1);
const next = filteredObjects.value[index];
if (!next) return;
event.preventDefault();
const viewport = captureViewport();
if (!viewport) return;
const nextControl = !event.shiftKey && !compiling.value && canCompileObject(next) ? "checkbox" : "name";
void restoreViewport(viewport, renderKey(next), nextControl);
}
function canCompileObject(object: OracleInvalidObject): boolean {
if (props.triggerContext && (object.type !== "TRIGGER" || object.objectId !== triggerSnapshot.value?.metadata.objectId)) return false;
return !unverifiedKeys.value.has(selectionKey(object)) && !oracleCompileUnsupportedReason(compileDatabaseType.value, object.type, compileOptions.value);
}
function removeValidObject(object: OracleInvalidObject) {
const viewport = captureViewport();
objects.value = objects.value.filter((current) => !sameObject(current, object));
fullObjects.value = fullObjects.value.filter((current) => !sameObject(current, object));
selectedObjects.value.delete(selectionKey(object));
unverifiedKeys.value.delete(selectionKey(object));
rowResults.value.delete(selectionKey(object));
keepViewport(viewport);
}
function mergeDictionaryRows(rows: OracleInvalidObject[], complete: boolean, acceptChangedIdentity = false) {
const viewport = captureViewport();
const incoming = new Map(rows.map((object) => [selectionKey(object), object]));
const merged: OracleInvalidObject[] = [];
const unverified = new Set(unverifiedKeys.value);
for (const previous of objects.value) {
const key = selectionKey(previous);
const current = incoming.get(key);
if (current && sameObject(previous, current)) {
const result = rowResults.value.get(key);
const changed = previous.lastDdlTime !== current.lastDdlTime;
if (result && (changed || unverified.has(key)) && !acceptChangedIdentity) {
merged.push(previous);
unverified.add(key);
} else {
merged.push(current);
unverified.delete(key);
}
incoming.delete(key);
} else if (current) {
// The ID now describes another name/type; require explicit refresh before rebinding it.
if (acceptChangedIdentity) {
merged.push(current);
rowResults.value.delete(key);
unverified.delete(key);
} else {
merged.push(previous);
unverified.add(key);
}
incoming.delete(key);
} else {
merged.push(previous);
if (complete) unverified.add(key);
}
}
merged.push(...incoming.values());
objects.value = merged;
unverifiedKeys.value = unverified;
const current = new Map(merged.map((object) => [selectionKey(object), object]));
selectedObjects.value = new Map(
[...selectedObjects.value].filter(([key, previous]) => {
const refreshed = current.get(key);
return refreshed && matchesFilters(refreshed) && canCompileObject(refreshed) && sameObject(refreshed, previous) && refreshed.lastDdlTime === previous.lastDdlTime;
}),
);
keepViewport(viewport);
}
function waitForSessionDrain(session: ManagedSession): Promise<void> {
if (session.active === 0) return Promise.resolve();
return new Promise((resolve) => {
const check = () => {
if (session.active === 0) {
sessionDrainWaiters = sessionDrainWaiters.filter((waiter) => waiter !== check);
resolve();
}
};
sessionDrainWaiters.push(check);
});
}
function ensureManagedSession(connectionId: string, database: string): ManagedSession {
if (!managedSession || managedSession.connectionId !== connectionId || managedSession.database !== database || managedSession.closeRequested || managedSession.closed) rotateManagedSession(connectionId, database);
return managedSession!;
}
function captureExecutionScope(): ExecutionScope {
const connection = { ...props.connection };
const database = props.database;
return { connection, connectionKey: JSON.stringify(connection), database, schema: props.schema, generation: generation.value, session: ensureManagedSession(connection.id, database) };
}
function scopeIsCurrent(scope: ExecutionScope): boolean {
return isCurrent(scope.generation) && props.connection.id === scope.connection.id && JSON.stringify(props.connection) === scope.connectionKey && props.database === scope.database && props.schema === scope.schema;
}
async function query(sql: string, maxRows = 501, scope?: ExecutionScope, allowExecutionError = false) {
const connectionId = scope?.connection.id ?? props.connection.id;
const database = scope?.database ?? props.database;
const schema = scope?.schema ?? props.schema;
const session = scope?.session ?? ensureManagedSession(connectionId, database);
session.active++;
try {
const result = await api.executeQuery(connectionId, database, sql, schema, undefined, { maxRows, clientSessionId: session.id });
if (!allowExecutionError && result.execution_error) throw new Error(result.error ? formatError(result.error) : String(result.rows[0]?.[0] ?? "Database query failed"));
return result;
} finally {
session.active--;
if (session.active === 0) sessionDrainWaiters.slice().forEach((waiter) => waiter());
closeManagedSession(session);
}
}
function closeManagedSession(session: ManagedSession) {
if (!session.closeRequested || session.active > 0 || session.closed) return;
session.closeRequested = false;
session.closed = true;
void api.closeClientConnectionSession(session.connectionId, session.database, session.id).catch(() => undefined);
}
function retireManagedSession() {
const previous = managedSession;
managedSession = null;
if (!previous) return;
previous.closeRequested = true;
closeManagedSession(previous);
}
function rotateManagedSession(connectionId: string, database: string) {
retireManagedSession();
managedSession = newManagedSession(connectionId, database);
}
function closeCurrentManagedSession() {
if (!managedSession) return;
managedSession.closeRequested = true;
closeManagedSession(managedSession);
}
async function loadList(existingToken?: number, options?: { allowLastDdlTimeChange?: boolean; preserveSelected?: boolean; loadDiagnostics?: boolean }) {
const token = existingToken ?? ++generation.value;
const readId = ++listLoadGeneration;
loading.value = true;
loadError.value = "";
if (options?.loadDiagnostics !== false) {
errorLoadError.value = "";
errorsTruncated.value = false;
outcome.value = "";
}
try {
const context = props.triggerContext;
if (context) {
if (context.target.connectionId !== props.connection.id || context.target.database !== props.database) throw new Error(t("oracleTrigger.reloadBaseline"));
const snapshot = await readOracleTriggerSnapshot(context.target);
if (!isCurrent(token) || readId !== listLoadGeneration) return;
if (!snapshot.exists || (context.expectedObjectId !== undefined && snapshot.metadata.objectId !== context.expectedObjectId)) throw new Error(t("oracleTrigger.reloadBaseline"));
showTriggerSnapshot(snapshot);
return;
}
const result = await query(buildOracleInvalidObjectsSql(props.schema, 501), 501);
if (!isCurrent(token) || readId !== listLoadGeneration) return;
const rows = mapOracleInvalidObjects(result.rows, props.schema);
mergeDictionaryRows(rows, false, verifyMissingOnNextRead.value);
truncated.value = result.truncated === true || rows.length >= 501;
if (selected.value) {
const previous = selected.value;
const refreshed = rows.find((row) => sameObject(row, previous)) ?? null;
if (!refreshed || refreshed.name !== previous.name || refreshed.type !== previous.type || (!options?.allowLastDdlTimeChange && refreshed.lastDdlTime !== previous.lastDdlTime)) {
if (refreshed) outcome.value = t("processList.oracleInvalidObjects.targetChanged");
}
selected.value = refreshed ?? (options?.preserveSelected ? previous : null);
}
if (options?.loadDiagnostics !== false) {
if (selected.value) await loadErrors(selected.value, token);
else {
errors.value = [];
errorsTruncated.value = false;
}
}
if (isCurrent(token) && readId === listLoadGeneration && !compiling.value) void startFullRead(token);
} catch (error) {
if (isCurrent(token) && readId === listLoadGeneration) {
loadError.value = error instanceof Error ? error.message : String(error);
}
} finally {
if (isCurrent(token) && readId === listLoadGeneration) loading.value = false;
}
}
function showTriggerSnapshot(snapshot: OracleTriggerSnapshot) {
triggerSnapshot.value = snapshot;
const metadata = snapshot.metadata;
const object: OracleInvalidObject = { owner: metadata.owner, name: metadata.name, type: "TRIGGER", objectId: metadata.objectId!, lastDdlTime: metadata.lastDdlTime ?? "" };
selected.value = object;
objects.value = snapshot.raw.trigger?.valid === true && metadata.reads.validity?.state === "available" ? [] : [object];
fullObjects.value = [...objects.value];
fullReadState.value = "complete";
truncated.value = false;
currentView.value = "detail";
const read = metadata.reads.errors;
errorsTruncated.value = read?.state === "incomplete";
errorLoadError.value = read?.state === "available" || read?.state === "incomplete" ? "" : read?.message || t(`oracleSecurity.${read?.state === "denied" ? "denied" : read?.state === "error" ? "error" : "unavailable"}`);
if (metadata.reads.validity?.state !== "available") outcome.value = t("processList.oracleInvalidObjects.compileUnknown");
else if (snapshot.raw.trigger?.valid === true) outcome.value = t("processList.oracleInvalidObjects.compileValid");
}
async function startFullRead(token = generation.value) {
if (!isCurrent(token) || compiling.value) return;
const readId = ++fullReadGeneration.value;
const scope = captureExecutionScope();
fullReadState.value = "reading";
fullReadError.value = "";
fullReadCount.value = 0;
try {
const all = await readAllOracleInvalidObjects((sql, maxRows) => query(sql, maxRows, scope), scope.schema, {
isCurrent: () => isCurrent(token) && fullReadGeneration.value === readId && !compiling.value,
onProgress: (count) => {
if (isCurrent(token) && fullReadGeneration.value === readId) fullReadCount.value = count;
},
});
if (!isCurrent(token) || fullReadGeneration.value !== readId || compiling.value) return;
const verifyMissing = verifyMissingOnNextRead.value;
verifyMissingOnNextRead.value = false;
fullObjects.value = all;
mergeDictionaryRows(all, true, verifyMissing);
if (verifyMissing) {
for (const key of unverifiedKeys.value) {
if (!isCurrent(token) || fullReadGeneration.value !== readId || compiling.value) return;
const object = objects.value.find((row) => selectionKey(row) === key);
if (!object) continue;
try {
const status = await readObjectStatus(scope, object);
if (!isCurrent(token) || fullReadGeneration.value !== readId || compiling.value) return;
const row = status.rows.length === 1 ? status.rows[0] : undefined;
if (row && String(row[0] ?? "") === object.objectId && String(row[2] ?? "") === "VALID") {
removeValidObject(object);
} else if (row && String(row[0] ?? "") === object.objectId && String(row[2] ?? "") === "INVALID") {
const refreshed = { ...object, lastDdlTime: String(row[1] ?? object.lastDdlTime) };
objects.value = objects.value.map((current) => (sameObject(current, object) ? refreshed : current));
fullObjects.value.push(refreshed);
unverifiedKeys.value.delete(key);
} else {
const result = rowResults.value.get(key);
if (result) {
result.status = row ? "target-changed" : "deleted";
result.message = t(row ? "processList.oracleInvalidObjects.batchTargetChanged" : "processList.oracleInvalidObjects.batchDeleted");
}
}
} catch {
// Keep unconfirmed rows visible and unselectable after a failed read-only check.
}
}
}
if (!isCurrent(token) || fullReadGeneration.value !== readId || compiling.value) return;
fullReadState.value = "complete";
} catch (error) {
if (!isCurrent(token) || fullReadGeneration.value !== readId || compiling.value) return;
fullReadState.value = "error";
fullReadError.value = writeErrorMessage(error);
}
}
async function loadErrors(object: OracleInvalidObject, token = generation.value) {
if (props.triggerContext) {
await loadList(token);
return;
}
const requestId = ++diagnosticGeneration;
errorLoadError.value = "";
errors.value = [];
errorsTruncated.value = false;
try {
const result = await readObjectErrors(captureExecutionScope(), object);
if (!isCurrent(token) || requestId !== diagnosticGeneration || selectionKey(selected.value ?? object) !== selectionKey(object)) return;
errors.value = result.errors;
errorsTruncated.value = result.truncated;
} catch (error) {
if (isCurrent(token) && requestId === diagnosticGeneration && selectionKey(selected.value ?? object) === selectionKey(object)) errorLoadError.value = error instanceof Error ? error.message : String(error);
}
}
function selectObject(object: OracleInvalidObject) {
diagnosticGeneration++;
selected.value = object;
const previousResult = rowBatchItem(object);
errors.value = previousResult?.errors ?? [];
errorsTruncated.value = previousResult?.errorsTruncated ?? false;
errorLoadError.value = previousResult?.diagnosticError ?? "";
outcome.value = previousResult?.message ?? "";
if (!compiling.value && !previousResult?.errors?.length && !previousResult?.diagnosticError && !unverifiedKeys.value.has(selectionKey(object))) void loadErrors(object);
}
class BatchWriteError extends Error {
constructor(
readonly value: unknown,
readonly unknown: boolean,
) {
super(writeErrorMessage(value));
}
}
class IncompleteObjectStatusError extends Error {}
function writeErrorMessage(value: unknown): string {
if (value && typeof value === "object" && "execution_error" in value) {
const result = value as { error?: unknown; rows?: unknown[][] };
return result.error ? formatError(result.error) : String(result.rows?.[0]?.[0] ?? "Database execution failed");
}
return formatError(value);
}
function knownWriteRejection(value: unknown): boolean {
const backendError = normalizeBackendError(value);
if (backendError?.operationOutcome === "not_started") return true;
const message = backendError?.detail ?? writeErrorMessage(value);
return oracleWriteRejected(message, true);
}
function objectIdentityMatches(object: OracleInvalidObject, row: unknown[] | undefined): boolean {
return !!row && String(row[0] ?? "") === object.objectId && String(row[1] ?? "") === object.lastDdlTime;
}
function objectIdMatches(object: OracleInvalidObject, row: unknown[] | undefined): boolean {
return !!row && String(row[0] ?? "") === object.objectId;
}
function objectDdlTimeMatches(object: OracleInvalidObject, row: unknown[] | undefined): boolean {
return !!row && String(row[1] ?? "") === object.lastDdlTime;
}
async function readObjectStatus(scope: ExecutionScope, object: OracleInvalidObject) {
const result = await query(buildOracleObjectStatusSql(object.owner, object), 2, scope);
if (result.truncated === true) throw new IncompleteObjectStatusError();
return result;
}
async function readObjectErrors(scope: ExecutionScope, object: OracleInvalidObject) {
const result = await query(buildOracleObjectErrorsSql(object.owner, object), 1000, scope);
return {
errors: mapOracleObjectErrors(result.rows),
truncated: result.truncated === true || result.rows.length >= 1000,
};
}
async function submitCompile(scope: ExecutionScope, sql: string) {
try {
const result = await query(sql, 1, scope, true);
if (result.execution_error) throw new BatchWriteError(result, !knownWriteRejection(result));
return result;
} catch (error) {
if (error instanceof BatchWriteError) throw error;
throw new BatchWriteError(error, !knownWriteRejection(error));
}
}
const unsupportedReason = computed(() => (selected.value ? oracleCompileUnsupportedReason(compileDatabaseType.value, selected.value.type, compileOptions.value) : "unsupported-type"));
const singleTargetPresent = computed(() => {
if (!selected.value) return false;
return canCompileObject(selected.value) && objects.value.some((object) => sameObject(object, selected.value!));
});
async function compileSingle() {
if (props.triggerContext) return compileExactTrigger();
const target = selected.value ? { ...selected.value } : null;
if (!target || unsupportedReason.value || compiling.value) return;
const scope = captureExecutionScope();
let sql: string;
try {
sql = buildOracleCompileSql(databaseType.value, target.owner, target);
} catch (error) {
outcome.value = writeErrorMessage(error);
return;
}
const executionGeneration = ++singleCompilationGeneration;
const token = scope.generation;
const connection = scope.connection;
const database = scope.database;
const schema = scope.schema;
const item: BatchItem = reactive({ object: target, sql, status: "pending", errors: [...errors.value], errorsTruncated: errorsTruncated.value, diagnosticError: errorLoadError.value });
rowResults.value.set(selectionKey(target), item);
batchRun.value = null;
let actionSubmitted = false;
compiling.value = true;
outcome.value = "";
listLoadGeneration++;
diagnosticGeneration++;
loading.value = false;
fullReadGeneration.value++;
if (fullReadState.value === "reading" || fullReadState.value === "complete") fullReadState.value = "stopped";
try {
await waitForSessionDrain(scope.session);
if (!scopeIsCurrent(scope)) return;
const result = await executeWithProductionSqlGuard({
connection,
database: scope.schema,
sql,
source: t("production.sourceAdmin"),
execute: async () => {
if (!scopeIsCurrent(scope)) throw new Error(t("processList.oracleInvalidObjects.targetChanged"));
item.status = "running";
const identity = await query(buildOracleObjectIdentitySql(target.owner, target), 2, scope);
if (!scopeIsCurrent(scope)) return undefined;
if (identity.truncated === true || identity.rows.length > 1) {
item.status = "unknown";
item.message = t("processList.oracleInvalidObjects.batchIdentityUnknown");
unverifiedKeys.value.add(selectionKey(target));
return undefined;
}
const row = identity.rows[0];
if (!objectIdentityMatches(target, row)) {
item.status = "target-changed";
unverifiedKeys.value.add(selectionKey(target));
await loadList(token, { preserveSelected: true, loadDiagnostics: false });
if (!scopeIsCurrent(scope)) return undefined;
item.message = t("processList.oracleInvalidObjects.targetChanged");
return undefined;
}
actionSubmitted = true;
try {
return await submitCompile(scope, sql);
} catch (error) {
if (error instanceof BatchWriteError && !error.unknown) actionSubmitted = false;
throw error;
}
},
});
if (!scopeIsCurrent(scope)) return;
if (result === undefined) {
if (item.status === "pending") {
item.status = "not-run";
item.message = t("processList.oracleInvalidObjects.batchGuardDeclined");
}
return;
}
const statusResult = await readObjectStatus(scope, target);
if (!scopeIsCurrent(scope)) return;
const statusRow = statusResult.rows.length === 1 ? statusResult.rows[0] : undefined;
// Compilation is DDL and can update LAST_DDL_TIME on the same object.
// OBJECT_ID distinguishes a replacement; the preflight above still checks both fields.
const sameObject = statusRow && String(statusRow[0]) === target.objectId;
const status = sameObject ? String(statusRow[2] ?? "") : "";
if (sameObject && status === "VALID") {
item.status = "valid";
removeValidObject(target);
} else if (sameObject && status === "INVALID") {
item.status = "still-invalid";
updateInvalidObject(item, statusRow!);
} else {
item.status = !statusRow ? "deleted" : sameObject ? "unknown" : "target-changed";
unverifiedKeys.value.add(selectionKey(target));
}
if (sameObject && (status === "VALID" || status === "INVALID")) {
try {
const diagnostics = await readObjectErrors(scope, target);
if (!scopeIsCurrent(scope)) return;
item.errors = diagnostics.errors;
item.errorsTruncated = diagnostics.truncated;
item.diagnosticError = "";
} catch (error) {
if (!scopeIsCurrent(scope)) return;
item.diagnosticError = writeErrorMessage(error);
}
}
await loadList(token, { allowLastDdlTimeChange: true, preserveSelected: true, loadDiagnostics: false });
if (!scopeIsCurrent(scope)) return;
item.message = !statusRow
? t("processList.oracleInvalidObjects.compileGone")
: !sameObject
? t("processList.oracleInvalidObjects.targetChanged")
: status === "VALID"
? t("processList.oracleInvalidObjects.compileValid")
: status === "INVALID"
? t("processList.oracleInvalidObjects.compileStillInvalid")
: t("processList.oracleInvalidObjects.compileUnknown");
} catch (error) {
if (scopeIsCurrent(scope)) {
if (actionSubmitted) {
item.status = "unknown";
unverifiedKeys.value.add(selectionKey(target));
await loadList(token, { allowLastDdlTimeChange: true, preserveSelected: true, loadDiagnostics: false });
if (!scopeIsCurrent(scope)) return;
item.message =
error instanceof BatchWriteError && !error.unknown
? t("processList.oracleInvalidObjects.compileFailed", { message: writeErrorMessage(error.value) })
: error instanceof IncompleteObjectStatusError
? t("processList.oracleInvalidObjects.compileUnknown")
: `${t("processList.oracleInvalidObjects.compileUnknown")} ${writeErrorMessage(error)}`;
} else {
item.status = "failed";
item.message = t("processList.oracleInvalidObjects.compileFailed", { message: writeErrorMessage(error instanceof BatchWriteError ? error.value : error) });
}
}
} finally {
if (actionSubmitted) emit("compile-finished", { connectionId: connection.id, database, schema });
if (singleCompilationGeneration === executionGeneration && scopeIsCurrent(scope)) {
if (selected.value && sameObject(selected.value, target)) {
outcome.value = item.message ?? "";
errors.value = item.errors ?? [];
errorsTruncated.value = item.errorsTruncated ?? false;
errorLoadError.value = item.diagnosticError ?? "";
}
compiling.value = false;
if (currentView.value === "detail" && selected.value && !sameObject(selected.value, target) && !unverifiedKeys.value.has(selectionKey(selected.value)) && !rowBatchItem(selected.value)) void loadErrors(selected.value, token);
void startFullRead(token);
}
}
}
async function compileExactTrigger() {
const context = props.triggerContext;
const selectedObject = selected.value;
if (!context || !selectedObject || compiling.value || unsupportedReason.value || !singleTargetPresent.value) return;
const token = generation.value;
const contextKey = JSON.stringify(context);
const current = () => isCurrent(token) && JSON.stringify(props.triggerContext) === contextKey;
compiling.value = true;
outcome.value = "";
try {
const plan = await prepareOracleTriggerPlan({ target: context.target, action: "compile", expectedObjectId: selectedObject.objectId });
if (!current()) return;
const result = await confirmOracleTriggerPlan(plan, { isCurrent: current });
if (result.steps.some((step) => step.receipt !== undefined)) emit("trigger-result", plan.target, result, plan.before, context.originTabId, context.originRevision);
if (!current() || result.cancelled) return;
if (result.snapshot?.exists && result.snapshot.metadata.objectId === selectedObject.objectId) showTriggerSnapshot(result.snapshot);
const step = result.steps[0];
outcome.value =
step?.state === "committed" && step.verification === "valid"
? t("processList.oracleInvalidObjects.compileValid")
: step?.state === "committed" && step.verification === "invalid"
? t("processList.oracleInvalidObjects.compileStillInvalid")
: step?.state === "rejected"
? t("oracleSecurity.writeRejected")
: t("processList.oracleInvalidObjects.compileUnknown");
const detail = [step?.error, step?.readbackError, result.refreshError].filter(Boolean).join("\n");
if (detail) outcome.value += `\n${detail}`;
} catch (error) {
if (current()) outcome.value = writeErrorMessage(error);
} finally {
if (current()) compiling.value = false;
}
}
function batchIsCurrent(run: BatchRun): boolean {
return batchRun.value?.id === run.id && scopeIsCurrent(run.scope);
}
function buildBatchItems(objects: OracleInvalidObject[]): BatchItem[] {
return objects.map((object) => {
const unsupportedReason = oracleCompileUnsupportedReason(databaseType.value, object.type);
if (unsupportedReason) return { object, unsupportedReason, status: "unsupported" };
try {
return { object, sql: buildOracleCompileSql(databaseType.value, object.owner, object), status: "pending" };
} catch (error) {
return { object, unsupportedReason: "unsupported-type", status: "unsupported", message: formatError(error) };
}
});
}
function readBatchPlan() {
void startFullRead();
}
function toggleObjectSelection(object: OracleInvalidObject, checked: boolean) {
if (compiling.value || unverifiedKeys.value.has(selectionKey(object)) || oracleCompileUnsupportedReason(databaseType.value, object.type)) return;
const next = new Map(selectedObjects.value);
if (checked) next.set(selectionKey(object), { ...object });
else next.delete(selectionKey(object));
selectedObjects.value = next;
}
function toggleFilteredSelection(checked: boolean) {
if (compiling.value) return;
const next = new Map(selectedObjects.value);
for (const object of filteredObjects.value) {
if (!canCompileObject(object)) continue;
const key = selectionKey(object);
if (checked) next.set(key, { ...object });
else next.delete(key);
}
selectedObjects.value = next;
}
function showDetail(object: OracleInvalidObject) {
detailViewport = captureViewport();
listCache.value = listScroller.value?.cacheSnapshot;
detailReturnKey.value = renderKey(object);
currentView.value = "detail";
selectObject(object);
}
function returnFromDetail() {
currentView.value = "list";
void restoreViewport(detailViewport, detailReturnKey.value);
}
function refreshCurrentList() {
if (compiling.value) return;
fullReadGeneration.value++;
fullReadState.value = "idle";
fullReadError.value = "";
verifyMissingOnNextRead.value = true;
batchRun.value = null;
selectedObjects.value = new Map();
generation.value++;
void loadList();
}
function stopBatch() {
const run = batchRun.value;
if (!run) return;
if (run.state === "running") run.stopRequested = true;
}
function classifyBatchWriteFailure(error: unknown): "failed" | "unknown" {
if (error instanceof BatchWriteError) return error.unknown ? "unknown" : "failed";
return knownWriteRejection(error) ? "failed" : "unknown";
}
async function readBatchObjectErrors(run: BatchRun, item: BatchItem): Promise<void> {
try {
const result = await readObjectErrors(run.scope, item.object);
if (!batchIsCurrent(run)) return;
item.errors = result.errors;
item.errorsTruncated = result.truncated;
} catch (error) {
if (batchIsCurrent(run)) item.diagnosticError = writeErrorMessage(error);
}
}
async function refreshBatchRemainder(run: BatchRun) {
try {
const remaining = await readAllOracleInvalidObjects((sql, maxRows) => query(sql, maxRows, run.scope), run.scope.schema, { isCurrent: () => scopeIsCurrent(run.scope) });
if (!batchIsCurrent(run)) return;
run.remaining = remaining;
run.remainingError = "";
fullObjects.value = remaining;
mergeDictionaryRows(remaining, true);
fullReadState.value = "complete";
fullReadError.value = "";
truncated.value = false;
loadError.value = "";
} catch (error) {
if (!batchIsCurrent(run)) return;
run.remainingError = writeErrorMessage(error);
fullReadState.value = "error";
fullReadError.value = run.remainingError;
loadError.value = run.remainingError;
}
}
async function executeBatchItem(run: BatchRun, item: BatchItem): Promise<boolean> {
const object = item.object;
if (!batchIsCurrent(run) || !item.sql) return false;
if (run.stopRequested) {
item.status = "not-run";
return false;
}
item.status = "running";
run.currentName = `${object.owner}.${object.name}`;
let before;
try {
before = await readObjectStatus(run.scope, object);
} catch (error) {
if (batchIsCurrent(run)) {
item.status = error instanceof IncompleteObjectStatusError ? "unknown" : "failed";
item.message = error instanceof IncompleteObjectStatusError ? t("processList.oracleInvalidObjects.batchIdentityUnknown") : writeErrorMessage(error);
unverifiedKeys.value.add(selectionKey(object));
}
return true;
}
if (!batchIsCurrent(run)) return false;
if (run.stopRequested) {
item.status = "not-run";
return false;
}
if (before.rows.length === 0) {
item.status = "deleted";
item.message = t("processList.oracleInvalidObjects.batchDeleted");
unverifiedKeys.value.add(selectionKey(object));
return true;
}
if (before.rows.length !== 1) {
item.status = "unknown";
item.message = t("processList.oracleInvalidObjects.batchIdentityUnknown");
unverifiedKeys.value.add(selectionKey(object));
return true;
}
const beforeStatus = before.rows[0]![2];
if (!objectIdMatches(object, before.rows[0])) {
item.status = "target-changed";
item.message = t("processList.oracleInvalidObjects.batchTargetChanged");
unverifiedKeys.value.add(selectionKey(object));
return true;
}
if (beforeStatus === "VALID") {
item.status = "already-valid";
item.message = t("processList.oracleInvalidObjects.batchAlreadyValid");
removeValidObject(object);
return true;
}
if (beforeStatus !== "INVALID") {
item.status = "unknown";
item.message = t("processList.oracleInvalidObjects.batchIdentityUnknown");
unverifiedKeys.value.add(selectionKey(object));
return true;
}
if (!objectDdlTimeMatches(object, before.rows[0])) {
item.status = "target-changed";
item.message = t("processList.oracleInvalidObjects.batchTargetChanged");
unverifiedKeys.value.add(selectionKey(object));
return true;
}
if (!batchIsCurrent(run) || run.stopRequested) return false;
const previouslySubmitted = run.submittedAny;
run.submittedAny = true;
try {
await submitCompile(run.scope, item.sql);
} catch (error) {
if (!batchIsCurrent(run)) return false;
const status = classifyBatchWriteFailure(error);
if (status === "failed") run.submittedAny = previouslySubmitted;
item.status = status;
item.message = writeErrorMessage(error);
if (status === "unknown") unverifiedKeys.value.add(selectionKey(object));
return status !== "unknown";
}
if (!batchIsCurrent(run)) return false;
let after;
try {
after = await readObjectStatus(run.scope, object);
} catch (error) {
if (batchIsCurrent(run)) {
item.status = "unknown";
item.message = error instanceof IncompleteObjectStatusError ? t("processList.oracleInvalidObjects.compileUnknown") : `${t("processList.oracleInvalidObjects.compileUnknown")} ${writeErrorMessage(error)}`;
unverifiedKeys.value.add(selectionKey(object));
}
return false;
}
if (!batchIsCurrent(run)) return false;
if (after.rows.length === 0) {
item.status = "deleted";
item.message = t("processList.oracleInvalidObjects.batchDeleted");
unverifiedKeys.value.add(selectionKey(object));
return true;
}
if (after.rows.length !== 1) {
item.status = "unknown";
item.message = t("processList.oracleInvalidObjects.compileUnknown");
unverifiedKeys.value.add(selectionKey(object));
return false;
}
const [afterId, , afterStatus] = after.rows[0]!;
if (String(afterId ?? "") !== object.objectId) {
item.status = "target-changed";
item.message = t("processList.oracleInvalidObjects.batchTargetChanged");
unverifiedKeys.value.add(selectionKey(object));
return true;
}
if (afterStatus === "VALID") {
item.status = "valid";
item.message = t("processList.oracleInvalidObjects.compileValid");
removeValidObject(object);
} else if (afterStatus === "INVALID") {
item.status = "still-invalid";
item.message = t("processList.oracleInvalidObjects.compileStillInvalid");
updateInvalidObject(item, after.rows[0]!);
await readBatchObjectErrors(run, item);
} else {
item.status = "unknown";
item.message = t("processList.oracleInvalidObjects.compileUnknown");
unverifiedKeys.value.add(selectionKey(object));
return false;
}
return true;
}
async function startBatchCompile(mode: "selected" | "all") {
if (!props.open || compiling.value || (!managedSession && mode !== "all")) return;
const stableObjects = objects.value;
const targets =
mode === "all"
? fullReadState.value === "complete"
? completeMatchingObjects.value.map((object) => ({ ...object }))
: []
: stableObjects.filter((object) => selectedObjects.value.has(selectionKey(object)) && canCompileObject(object)).map((object) => ({ ...selectedObjects.value.get(selectionKey(object))! }));
if (targets.length === 0) return;
const scope = captureExecutionScope();
const frozenItems = buildBatchItems(targets);
const executionGeneration = ++batchExecutionGeneration;
const run: BatchRun = reactive({
id: uuid(),
scope,
state: "running",
readCount: targets.length,
items: frozenItems,
stopRequested: false,
submittedAny: false,
currentName: "",
readError: "",
remainingError: "",
});
batchRun.value = run;
for (const item of run.items) rowResults.value.set(selectionKey(item.object), item);
compiling.value = true;
listLoadGeneration++;
diagnosticGeneration++;
loading.value = false;
fullReadGeneration.value++;
if (fullReadState.value === "reading" || fullReadState.value === "complete") fullReadState.value = "stopped";
const queue = run.items.filter((item) => !!item.sql);
const auditSql = queue.map((item) => item.sql).join(";\n");
try {
await waitForSessionDrain(scope.session);
if (!batchIsCurrent(run)) return;
const guarded = await executeWithProductionSqlGuard({
connection: scope.connection,
database: scope.schema,
sql: auditSql,
source: t("production.sourceAdmin"),
execute: async () => {
for (const item of queue) {
if (!batchIsCurrent(run) || run.stopRequested) break;
const keepGoing = await executeBatchItem(run, item);
if (!keepGoing) break;
}
return true;
},
});
if (!batchIsCurrent(run)) return;
if (guarded === undefined) {
for (const item of queue) if (item.status === "pending" || item.status === "running") item.status = "not-run";
run.readError = t("processList.oracleInvalidObjects.batchGuardDeclined");
} else {
for (const item of queue) if (item.status === "pending" || item.status === "running") item.status = "not-run";
}
run.state = "complete";
run.currentName = "";
await refreshBatchRemainder(run);
} catch (error) {
if (!batchIsCurrent(run)) return;
run.readError = writeErrorMessage(error);
for (const item of queue) if (item.status === "pending" || item.status === "running") item.status = "not-run";
run.state = "complete";
await refreshBatchRemainder(run);
} finally {
if (run.submittedAny) emit("compile-finished", { connectionId: scope.connection.id, database: scope.database, schema: scope.schema });
if (batchExecutionGeneration === executionGeneration && scopeIsCurrent(scope)) compiling.value = false;
}
}
function batchStatusLabel(status: BatchStatus): string {
return t(`processList.oracleInvalidObjects.batchStatus.${status}`);
}
function rowBatchItem(object: OracleInvalidObject): BatchItem | undefined {
const item = rowResults.value.get(selectionKey(object));
return item && sameObject(item.object, object) ? item : undefined;
}
function updateInvalidObject(item: BatchItem, status: unknown[]) {
const refreshed = { ...item.object, lastDdlTime: String(status[1] ?? item.object.lastDdlTime) };
objects.value = objects.value.map((object) => (sameObject(object, item.object) ? refreshed : object));
item.object = refreshed;
}
function rowStatus(object: OracleInvalidObject): BatchStatus | "invalid" {
return rowBatchItem(object)?.status ?? (unverifiedKeys.value.has(selectionKey(object)) ? "unknown" : oracleCompileUnsupportedReason(databaseType.value, object.type) ? "unsupported" : "invalid");
}
function rowStatusLabel(object: OracleInvalidObject): string {
const status = rowStatus(object);
return status === "invalid" ? "INVALID" : batchStatusLabel(status);
}
function openErrorSource(error: { line?: number | null; position?: number | null }) {
if (!selected.value || !Number.isSafeInteger(error.line) || !Number.isSafeInteger(error.position) || (error.line ?? 0) < 1 || (error.position ?? 0) < 1) return;
emit("open-source", selected.value, { line: error.line!, position: error.position! });
}
function close() {
generation.value++;
emit("update:open", false);
}
watch(
() => [props.open, JSON.stringify(props.connection), props.database, props.schema, JSON.stringify(props.triggerContext)] as const,
([open], previous) => {
const scopeChanged = !!previous && (previous[1] !== JSON.stringify(props.connection) || previous[2] !== props.database || previous[3] !== props.schema || previous[4] !== JSON.stringify(props.triggerContext));
if (scopeChanged || !open) {
singleCompilationGeneration++;
batchExecutionGeneration++;
batchRun.value = null;
compiling.value = false;
fullReadGeneration.value++;
fullReadState.value = "idle";
fullReadError.value = "";
fullObjects.value = [];
unverifiedKeys.value = new Set();
rowResults.value = new Map();
verifyMissingOnNextRead.value = false;
objects.value = [];
selected.value = null;
triggerSnapshot.value = undefined;
errors.value = [];
errorsTruncated.value = false;
diagnosticGeneration++;
selectedObjects.value = new Map();
currentView.value = "list";
nameFilter.value = "";
typeFilter.value = null;
listCache.value = undefined;
detailViewport = null;
viewportGeneration++;
}
if (previous && (previous[1] !== JSON.stringify(props.connection) || previous[2] !== props.database)) retireManagedSession();
if (open) void loadList();
else {
generation.value++;
objects.value = [];
errors.value = [];
errorsTruncated.value = false;
selected.value = null;
selectedObjects.value = new Map();
outcome.value = "";
closeCurrentManagedSession();
}
},
{ immediate: true },
);
onBeforeUnmount(() => {
generation.value++;
singleCompilationGeneration++;
batchExecutionGeneration++;
batchRun.value = null;
closeCurrentManagedSession();
});
</script>
<template>
<Dialog :open="open" @update:open="(value) => !value && close()">
<DialogContent class="h-[min(85vh,760px)] max-h-[min(85vh,760px)] w-[calc(100vw-2rem)] max-w-5xl flex flex-col gap-0 overflow-hidden p-0" @interact-outside="(event) => compiling && event.preventDefault()" @escape-key-down="(event) => compiling && event.preventDefault()">
<DialogHeader class="shrink-0 border-b px-5 py-4">
<DialogTitle>{{ t("processList.oracleInvalidObjects.title") }} · {{ connection.name }} · {{ schema }}</DialogTitle>
</DialogHeader>
<section v-if="currentView === 'list'" class="flex min-h-0 flex-1 flex-col overflow-hidden" :aria-label="t('processList.oracleInvalidObjects.listLabel')" data-list-heading tabindex="-1">
<div class="flex shrink-0 flex-wrap items-center justify-between gap-2 border-b px-3 py-2 text-xs">
<span class="text-muted-foreground"
>{{ hasFilters ? t("processList.oracleInvalidObjects.filterCount", { matched: filteredObjects.length, total: displayedObjects.length }) : t("processList.oracleInvalidObjects.listCount", { count: displayedObjects.length })
}}<span v-if="fullReadState !== 'complete'"> · {{ t("processList.oracleInvalidObjects.currentlyLoaded") }}</span> · {{ t("processList.oracleInvalidObjects.batchSelectedCount", { count: selectedCount }) }}</span
>
<div class="flex flex-wrap items-center gap-1">
<Button variant="destructive" size="sm" class="h-7 px-2 text-xs" :disabled="selectedSupportedCount === 0 || compiling" @click="startBatchCompile('selected')">{{ t("processList.oracleInvalidObjects.batchCompileSelected", { count: selectedSupportedCount }) }}</Button>
<Button variant="outline" size="sm" class="h-7 gap-1 px-2 text-xs" :disabled="fullReadState !== 'complete' || allSupportedCount === 0 || compiling" @click="startBatchCompile('all')"
><Wrench class="h-3.5 w-3.5" />{{
fullReadState === "complete"
? t(hasFilters ? "processList.oracleInvalidObjects.batchCompileFiltered" : "processList.oracleInvalidObjects.batchCompileAll", { count: allSupportedCount })
: t(hasFilters ? "processList.oracleInvalidObjects.compileFiltered" : "processList.oracleInvalidObjects.compileAll")
}}</Button
>
<Button variant="ghost" size="icon" class="h-7 w-7" :title="t('common.refresh')" :disabled="loading || compiling" @click="refreshCurrentList"><RefreshCw class="h-3.5 w-3.5" :class="{ 'animate-spin': loading || fullReadState === 'reading' }" /></Button>
<Button variant="ghost" size="sm" class="h-7 px-2 text-xs" :disabled="compiling" @click="close">{{ t("common.close") }}</Button>
</div>
</div>
<div class="flex shrink-0 flex-wrap items-center gap-2 border-b px-3 py-2 text-xs">
<label class="flex min-w-40 flex-1 items-center gap-2">
<span class="shrink-0 text-muted-foreground">{{ t("processList.oracleInvalidObjects.nameFilterLabel") }}</span>
<Input type="search" class="h-8 text-xs" :model-value="nameFilter" :aria-label="t('processList.oracleInvalidObjects.filterName')" :placeholder="t('processList.oracleInvalidObjects.filterName')" :disabled="compiling" @update:model-value="setNameFilter" />
</label>
<DropdownMenu>
<DropdownMenuTrigger as-child>
<Button variant="outline" size="sm" class="h-8 gap-1 text-xs" :disabled="compiling"
>{{ t("processList.oracleInvalidObjects.filterTypes") }} · {{ typeFilter === null ? t("processList.oracleInvalidObjects.allTypes") : t("processList.oracleInvalidObjects.selectedTypeCount", { count: typeFilter.size }) }}<ChevronDown class="h-3.5 w-3.5"
/></Button>
</DropdownMenuTrigger>
<DropdownMenuContent align="end" class="min-w-44 max-h-72 overflow-y-auto">
<DropdownMenuCheckboxItem :model-value="typeFilter === null" :disabled="compiling" @select.prevent @update:model-value="setAllTypes($event === true)">{{ t("processList.oracleInvalidObjects.allTypes") }}</DropdownMenuCheckboxItem>
<DropdownMenuSeparator />
<DropdownMenuCheckboxItem v-for="type in availableTypes" :key="type" :model-value="typeFilter === null || typeFilter.has(type)" :disabled="compiling" @select.prevent @update:model-value="setTypeFilter(type, $event === true)">{{ type }}</DropdownMenuCheckboxItem>
</DropdownMenuContent>
</DropdownMenu>
<Button variant="ghost" size="sm" class="h-8 px-2 text-xs" :disabled="compiling || !hasFilters" @click="clearFilters">{{ t("processList.oracleInvalidObjects.clearFilters") }}</Button>
</div>
<p class="shrink-0 border-b px-3 py-1.5 text-[11px] text-muted-foreground">{{ t("processList.oracleInvalidObjects.ddlWarning") }}</p>
<div v-if="batchRun" class="flex shrink-0 items-center justify-between gap-2 border-b px-3 py-2 text-xs" role="status" aria-live="polite">
<span v-if="batchRun.state === 'running'" class="min-w-0 flex-1 break-words">{{
batchRun.stopRequested ? t("processList.oracleInvalidObjects.batchStopping") : t("processList.oracleInvalidObjects.batchProgress", { handled: batchHandledCount, total: batchSupportedCount, current: batchRun.currentName || t("processList.oracleInvalidObjects.batchRunning") })
}}</span>
<span v-else class="min-w-0 flex-1 break-words"
>{{ t("processList.oracleInvalidObjects.batchSummary", { valid: batchValidCount, stillInvalid: batchStillInvalidCount, failed: batchFailureCount, skipped: batchSkippedCount })
}}<span v-if="batchRun.remaining"> · {{ t("processList.oracleInvalidObjects.batchRemaining", { count: batchRun.remaining.length }) }}</span
><span v-else-if="batchRun.remainingError" class="text-destructive"> · {{ t("processList.oracleInvalidObjects.batchRemainingUnknown", { message: batchRun.remainingError }) }}</span></span
>
<Button v-if="batchRun.state === 'running'" variant="outline" size="sm" class="shrink-0" :disabled="batchRun.stopRequested" @click="stopBatch">{{ t("processList.oracleInvalidObjects.batchStop") }}</Button>
</div>
<p v-if="batchRun?.readError" class="shrink-0 border-b px-3 py-2 text-xs text-destructive" role="alert">{{ batchRun.readError }}</p>
<div v-if="loadError" class="m-3 shrink-0 break-words rounded border border-destructive/40 bg-destructive/10 p-3 text-xs text-destructive">{{ loadError }}</div>
<p v-else-if="fullReadState === 'reading'" class="shrink-0 border-b px-3 py-2 text-xs text-muted-foreground" role="status" aria-live="polite">{{ t("processList.oracleInvalidObjects.batchReadProgress", { count: fullReadCount }) }}</p>
<p v-else-if="fullReadState === 'error'" class="shrink-0 break-words border-b px-3 py-2 text-xs text-destructive" role="alert">
{{ t("processList.oracleInvalidObjects.batchReadFailed") }} · {{ fullReadError }} <Button variant="ghost" size="sm" class="h-6 px-1" @click="readBatchPlan">{{ t("processList.oracleInvalidObjects.batchRetryRead") }}</Button>
</p>
<label class="flex shrink-0 cursor-pointer items-center gap-2 border-b px-4 py-2 text-xs font-medium">
<input type="checkbox" :checked="allSelectedInFilter" :indeterminate.prop="someSelectedInFilter" :disabled="compiling || !filteredObjects.some(canCompileObject)" @change="toggleFilteredSelection(($event.target as HTMLInputElement).checked)" />
{{ t("processList.oracleInvalidObjects.batchSelectFiltered") }}
</label>
<p v-if="!loading && displayedObjects.length === 0 && !loadError" class="px-4 py-8 text-center text-sm text-muted-foreground">{{ t("processList.oracleInvalidObjects.empty") }}</p>
<p v-else-if="filteredObjects.length === 0 && displayedObjects.length > 0" class="px-4 py-8 text-center text-sm text-muted-foreground">{{ t("processList.oracleInvalidObjects.noFilterMatches") }}</p>
<DynamicScroller v-if="filteredObjects.length > 0" ref="listScroller" data-object-scroller class="min-h-0 flex-1 overflow-x-hidden" :items="filteredObjects" :min-item-size="44" :buffer="400" :skip-hover="true" :key-field="renderKey" :cache="listCache">
<template #default="{ item: object, index, active }">
<DynamicScrollerItem :item="object" :active="active" :index="index">
<div :data-row-key="renderKey(object)" :inert="!active" :aria-hidden="!active || undefined" class="flex min-w-0 items-center gap-1 border-b px-2 py-1.5">
<label class="inline-flex h-7 w-7 shrink-0 cursor-pointer items-center justify-center">
<input
type="checkbox"
:aria-label="`${object.name} ${object.type}`"
:checked="selectedObjects.has(selectionKey(object))"
:disabled="compiling || unverifiedKeys.has(selectionKey(object)) || !!oracleCompileUnsupportedReason(databaseType, object.type)"
@change="toggleObjectSelection(object, ($event.target as HTMLInputElement).checked)"
@keydown.tab="onRowTab($event, object, 'checkbox')"
/>
</label>
<Button
variant="ghost"
class="h-auto min-w-0 flex-1 justify-start whitespace-normal break-all px-1 py-1 text-left text-xs font-medium"
:aria-label="`${object.name} ${object.type}`"
:data-object-key="selectionKey(object)"
@click="showDetail(object)"
@keydown.tab="onRowTab($event, object, 'name')"
>{{ object.name }}</Button
>
<span class="shrink-0 text-xs text-muted-foreground">{{ object.type }}</span>
<span role="img" :aria-label="rowStatusLabel(object)" :title="rowStatusLabel(object)" class="inline-flex h-5 w-5 shrink-0 items-center justify-center" :class="rowStatus(object) === 'failed' ? 'text-destructive' : 'text-muted-foreground'">
<Loader2 v-if="rowStatus(object) === 'running'" class="h-4 w-4 animate-spin" aria-hidden="true" />
<Clock v-else-if="rowStatus(object) === 'pending' || rowStatus(object) === 'not-run'" class="h-4 w-4" aria-hidden="true" />
<CircleX v-else-if="rowStatus(object) === 'failed'" class="h-4 w-4" aria-hidden="true" />
<CircleHelp v-else-if="rowStatus(object) === 'unknown'" class="h-4 w-4" aria-hidden="true" />
<CircleMinus v-else-if="rowStatus(object) === 'unsupported'" class="h-4 w-4" aria-hidden="true" />
<Circle v-else-if="rowStatus(object) === 'invalid'" class="h-4 w-4" aria-hidden="true" />
<AlertTriangle v-else class="h-4 w-4" aria-hidden="true" />
</span>
</div>
</DynamicScrollerItem>
</template>
</DynamicScroller>
<p v-if="truncated && fullReadState !== 'complete'" class="shrink-0 border-t px-3 py-2 text-xs text-muted-foreground">{{ t("processList.oracleInvalidObjects.truncated") }}</p>
</section>
<section v-else-if="currentView === 'detail' && selected" class="flex min-h-0 flex-1 flex-col overflow-hidden">
<div class="flex shrink-0 items-start justify-between gap-3 border-b px-4 py-3">
<div class="min-w-0">
<div class="break-all text-sm font-semibold">{{ selected.owner }}.{{ selected.name }}</div>
<div class="mt-1 text-xs text-muted-foreground">{{ selected.type }} · {{ t("processList.oracleInvalidObjects.objectId", { id: selected.objectId }) }}</div>
<div v-if="triggerContext && triggerSnapshot" class="mt-1 flex flex-wrap gap-x-4 gap-y-1 text-sm">
<span>{{ t("eventTrigger.enabled") }}: {{ triggerSnapshot.metadata.reads.enabled?.state === "available" && typeof triggerSnapshot.raw.trigger?.enabled === "boolean" ? t(triggerSnapshot.raw.trigger.enabled ? "objects.enabled" : "objects.disabled") : t("oracleTrigger.unknown") }}</span>
<span>{{ t("objects.validity") }}: {{ triggerSnapshot.metadata.reads.validity?.state === "available" && typeof triggerSnapshot.raw.trigger?.valid === "boolean" ? (triggerSnapshot.raw.trigger.valid ? "VALID" : "INVALID") : t("oracleTrigger.unknown") }}</span>
</div>
</div>
<Button v-if="oracleInvalidObjectSourceKind(selected.type)" variant="outline" size="sm" class="h-7 shrink-0 gap-1.5 text-xs" :disabled="compiling" @click="emit('open-source', selected)"><Wrench class="h-3.5 w-3.5" />{{ t("processList.oracleInvalidObjects.openSource") }}</Button>
</div>
<div class="min-h-0 flex-1 overflow-auto px-4 py-3">
<div class="mb-2 text-xs font-medium">{{ t("processList.oracleInvalidObjects.errorsTitle") }}</div>
<div v-if="errorLoadError" class="rounded border border-destructive/40 bg-destructive/10 p-3 text-xs text-destructive">{{ errorLoadError }}</div>
<p v-if="!errorLoadError && errorsTruncated" class="mb-2 rounded border bg-muted/30 p-2 text-xs text-muted-foreground">{{ t("processList.oracleInvalidObjects.errorsTruncated") }}</p>
<p v-if="loadError" role="alert" class="mb-2 text-sm text-destructive">{{ loadError }}</p>
<p v-if="!errorLoadError && !errorsTruncated && diagnosticErrors.length === 0 && !compiling" class="py-4 text-xs text-muted-foreground">{{ t("processList.oracleInvalidObjects.noErrors") }}</p>
<div v-if="!errorLoadError && diagnosticErrors.length > 0" class="overflow-auto rounded border">
<table class="w-full border-collapse text-xs">
<thead class="sticky top-0 bg-muted/60">
<tr>
<th class="px-2 py-1.5 text-left">{{ t("processList.oracleInvalidObjects.line") }}</th>
<th class="px-2 py-1.5 text-left">{{ t("processList.oracleInvalidObjects.position") }}</th>
<th class="px-2 py-1.5 text-left">{{ t("processList.oracleInvalidObjects.message") }}</th>
</tr>
</thead>
<tbody>
<tr v-for="(error, index) in diagnosticErrors" :key="error.sequence ?? index" class="border-t align-top">
<td class="whitespace-nowrap px-2 py-1.5 font-mono">
<Button v-if="triggerContext && error.line && error.position" variant="link" size="sm" class="h-auto p-0 font-mono" :aria-label="t('editor.locateError', { line: error.line, column: error.position })" :disabled="compiling" @click="openErrorSource(error)">{{ error.line }}</Button
><span v-else>{{ error.line ?? "?" }}</span>
</td>
<td class="whitespace-nowrap px-2 py-1.5 font-mono">{{ error.position ?? "?" }}</td>
<td class="break-words px-2 py-1.5 font-mono">{{ error.text }}</td>
</tr>
</tbody>
</table>
</div>
<p v-if="unsupportedReason" class="mt-3 flex items-start gap-2 rounded border bg-muted/30 p-3 text-xs text-muted-foreground">
<AlertTriangle class="mt-0.5 h-3.5 w-3.5 shrink-0" />{{ t(unsupportedReason === "unsupported-on-engine" ? "processList.oracleInvalidObjects.unsupportedOnEngine" : "processList.oracleInvalidObjects.unsupportedType") }}
</p>
<details v-if="selected && !unsupportedReason" class="mt-3 text-xs">
<summary class="cursor-pointer text-muted-foreground">{{ t("processList.oracleInvalidObjects.batchSqlDetails") }}</summary>
<pre class="mt-1 max-h-32 overflow-auto whitespace-pre-wrap break-all rounded bg-muted/30 p-2 font-mono">{{ buildOracleCompileSql(compileDatabaseType, selected.owner, selected, compileOptions) }}</pre>
</details>
<p v-if="outcome" class="mt-3 rounded border bg-muted/20 p-3 text-xs" role="status">{{ outcome }}</p>
</div>
<DialogFooter class="mx-0 mb-0 shrink-0 border-t px-4 py-3">
<Button v-if="!triggerContext" variant="outline" @click="returnFromDetail">{{ t("processList.oracleInvalidObjects.batchCurrentList") }}</Button>
<Button v-else variant="outline" :disabled="loading || compiling" @click="loadList()"><RefreshCw class="mr-1.5 size-4" :class="{ 'animate-spin': loading }" />{{ t("oracleTrigger.verifyReadOnly") }}</Button>
<Button variant="outline" :disabled="compiling" @click="close">{{ t("common.close") }}</Button>
<Button variant="destructive" :disabled="!!unsupportedReason || compiling || !!loadError || !singleTargetPresent" @click="compileSingle"><Loader2 v-if="compiling" class="mr-1.5 h-3.5 w-3.5 animate-spin" />{{ t("processList.oracleInvalidObjects.compile") }}</Button>
</DialogFooter>
</section>
</DialogContent>
</Dialog>
</template>