Files
dbx/apps/desktop/src/stores/savedSqlStore.ts
T

1081 lines
43 KiB
TypeScript

import { defineStore } from "pinia";
import { computed, ref } from "vue";
import { uuid } from "@/lib/common/utils";
import * as api from "@/lib/backend/api";
import { forgetSavedSqlEditorPosition } from "@/lib/app/savedSqlEditorPosition";
import { ensureSqlExtension, nextAvailableSqlName } from "@/lib/savedSql/savedSqlFileName";
import { nextSavedSqlCopyName } from "@/lib/savedSql/savedSqlClipboard";
import { savedSqlBatchReassignment, type SavedSqlBatchTargetSelection } from "@/lib/savedSql/savedSqlBatchTarget";
import { savedSqlDatabaseScopeKey } from "@/lib/savedSql/savedSqlDatabaseTree";
import { normalizeSqlExecutionTarget, sqlExecutionTargetCapabilities } from "@/lib/database/sqlExecutionTargetCapabilities";
import { isTauriRuntime } from "@/lib/backend/tauriRuntime";
import { useSettingsStore } from "@/stores/settingsStore";
import type { SavedSqlFile, SavedSqlFolder, SavedSqlLibrary } from "@/types/database";
const LEGACY_STORAGE_KEY = "dbx-saved-sql-library";
interface SavedSqlState {
folders: SavedSqlFolder[];
files: SavedSqlFile[];
}
interface SaveFileInput {
id?: string;
connectionId: string;
folderId?: string;
name: string;
database: string;
catalog?: string;
schema?: string;
sql: string;
}
interface SavedSqlExecutionTargetInput {
connectionId: string;
database: string;
catalog?: string;
schema?: string;
}
interface SavedSqlExecutionTargetUpdateOptions {
folderId?: string;
metadataOnly?: boolean;
orderIndex?: number;
updateFolder?: boolean;
syncLocalDirectory?: boolean;
}
interface PersistedSavedSqlFileTarget extends SavedSqlExecutionTargetInput {
folderId?: string;
orderIndex?: number;
updatedAt: string;
}
export interface SavedSqlBatchTargetFailure {
fileId: string;
fileName: string;
error: unknown;
}
export interface SavedSqlBatchTargetResult {
succeeded: SavedSqlFile[];
updated: SavedSqlFile[];
failures: SavedSqlBatchTargetFailure[];
}
interface SavedSqlNameScope {
id: string;
connectionId: string;
catalog?: string;
database: string;
folderId?: string;
name: string;
}
/** Where a saved SQL name has to be unique: one folder of one database scope. */
interface SavedSqlNameScopeInput {
connectionId: string;
catalog?: string;
database: string;
folderId?: string;
}
interface PendingSavedSqlName {
owners: Map<string, number>;
}
export class SavedSqlNameConflictError extends Error {
readonly code = "SAVED_SQL_NAME_CONFLICT";
/**
* The next free name in the same scope, so a caller that generated the
* colliding name can retry automatically instead of dead-ending the user on
* an error. Absent when the caller supplied the name itself and silently
* saving under a different one would be wrong.
*/
constructor(
readonly fileName: string,
readonly suggestedName?: string,
) {
super(`SQL "${fileName}" already exists in this location.`);
this.name = "SavedSqlNameConflictError";
}
}
function nowIso() {
return new Date().toISOString();
}
function sortFoldersByOrder(items: SavedSqlFolder[]) {
return [...items].sort((a, b) => {
const orderDiff = (a.orderIndex ?? 0) - (b.orderIndex ?? 0);
if (orderDiff !== 0) return orderDiff;
return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
});
}
function sortFilesByOrder(items: SavedSqlFile[]) {
return [...items].sort((a, b) => {
const orderDiff = (a.orderIndex ?? 0) - (b.orderIndex ?? 0);
if (orderDiff !== 0) return orderDiff;
return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
});
}
export type SavedSqlFileSortMode = "name-asc" | "name-desc" | "updated-desc" | "updated-asc";
export type SavedSqlFolderSortMode = "name-asc" | "name-desc";
function sortFilesByCriteria(items: SavedSqlFile[], mode: SavedSqlFileSortMode): SavedSqlFile[] {
return [...items].sort((a, b) => {
switch (mode) {
case "name-asc":
return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
case "name-desc":
return b.name.localeCompare(a.name, undefined, { numeric: true, sensitivity: "base" });
case "updated-desc": {
const timeDiff = b.updatedAt.localeCompare(a.updatedAt);
if (timeDiff !== 0) return timeDiff;
return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
}
case "updated-asc": {
const timeDiff = a.updatedAt.localeCompare(b.updatedAt);
if (timeDiff !== 0) return timeDiff;
return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
}
}
});
}
function reindexFolders(items: SavedSqlFolder[]) {
return items.map((folder, index) => ({ ...folder, orderIndex: index }));
}
function reindexFiles(items: SavedSqlFile[], folderId?: string) {
return items.map((file, index) => ({
...file,
folderId,
orderIndex: index,
}));
}
function maxOrderIndex(values: Array<{ orderIndex?: number }>) {
return values.reduce((max, item) => Math.max(max, item.orderIndex ?? -1), -1);
}
function normalizedCatalog(catalog: string | null | undefined): string | undefined {
return catalog || undefined;
}
function normalizeSavedSqlFile(file: SavedSqlFile): SavedSqlFile {
return { ...file, catalog: normalizedCatalog(file.catalog) };
}
function savedSqlNameKey(name: string): string {
return ensureSqlExtension(name).toLocaleLowerCase();
}
function savedSqlNameScopeKey(file: Pick<SavedSqlNameScope, "connectionId" | "catalog" | "database" | "folderId">): string {
return JSON.stringify(["library-folder", savedSqlDatabaseScopeKey(file), file.folderId || null]);
}
function savedSqlNameIdentity(file: SavedSqlNameScope): string {
return JSON.stringify([savedSqlNameScopeKey(file), savedSqlNameKey(file.name)]);
}
function savedSqlTreeIdentity(file: SavedSqlFile): string {
return JSON.stringify([file.id, file.connectionId, normalizedCatalog(file.catalog) ?? null, file.database, file.schema ?? null, file.name]);
}
function folderDepth(items: SavedSqlFolder[], folderId: string) {
const byId = new Map(items.map((folder) => [folder.id, folder]));
const seen = new Set<string>();
let depth = 0;
let current = byId.get(folderId);
while (current?.parentFolderId && !seen.has(current.parentFolderId)) {
seen.add(current.parentFolderId);
depth++;
current = byId.get(current.parentFolderId);
}
return depth;
}
function loadLegacyState(): SavedSqlState {
try {
const raw = localStorage.getItem(LEGACY_STORAGE_KEY);
if (!raw) return { folders: [], files: [] };
const parsed = JSON.parse(raw) as Partial<SavedSqlState>;
return {
folders: Array.isArray(parsed.folders) ? parsed.folders.filter((item) => item?.id && item?.connectionId) : [],
files: Array.isArray(parsed.files) ? parsed.files.filter((item) => item?.id && item?.connectionId) : [],
};
} catch {
return { folders: [], files: [] };
}
}
export const useSavedSqlStore = defineStore("savedSql", () => {
const folders = ref<SavedSqlFolder[]>([]);
const files = ref<SavedSqlFile[]>([]);
const isLoaded = ref(false);
const loadState = ref<"idle" | "loading" | "loaded" | "failed">("idle");
let pendingSync: Promise<void> | null = null;
let initFromStoragePromise: Promise<void> | null = null;
const pendingFolderCreates = new Map<string, Promise<SavedSqlFolder>>();
const fileTargetRevisions = new Map<string, number>();
const pendingFileTargetSaves = new Map<string, Promise<SavedSqlFile | undefined>>();
const persistedFileTargets = new Map<string, PersistedSavedSqlFileTarget>();
const persistedFileTargetNameReleases = new Map<string, () => void>();
const pendingNamesByScope = new Map<string, Map<string, PendingSavedSqlName>>();
const version = ref(0);
const treeVersion = ref(0);
function bumpVersion(options: { tree?: boolean } = {}) {
version.value++;
if (options.tree) treeVersion.value++;
}
function applyLibrary(library: SavedSqlLibrary) {
folders.value = library.folders;
files.value = library.files.map((file) => ({ ...normalizeSavedSqlFile(file), sqlLoaded: file.sqlLoaded ?? Boolean(file.sql) }));
bumpVersion({ tree: true });
}
async function migrateLegacyLocalStorage() {
const legacy = loadLegacyState();
if (legacy.folders.length === 0 && legacy.files.length === 0) return;
for (const folder of legacy.folders) {
await api.saveSavedSqlFolder(folder);
}
for (const file of legacy.files) {
await api.saveSavedSqlFile(file);
}
localStorage.removeItem(LEGACY_STORAGE_KEY);
}
async function initFromStorage() {
if (isLoaded.value) return;
if (!initFromStoragePromise) {
loadState.value = "loading";
initFromStoragePromise = (async () => {
await migrateLegacyLocalStorage();
applyLibrary(await api.loadSavedSqlLibrary());
isLoaded.value = true;
loadState.value = "loaded";
})()
.catch((error) => {
loadState.value = "failed";
throw error;
})
.finally(() => {
initFromStoragePromise = null;
});
}
await initFromStoragePromise;
}
function listFolders(connectionId: string) {
return listChildFolders(connectionId);
}
function listChildFolders(connectionId: string, parentFolderId?: string) {
return sortFoldersByOrder(folders.value.filter((folder) => folder.connectionId === connectionId && (folder.parentFolderId || "") === (parentFolderId || "")));
}
function listFiles(connectionId: string, folderId?: string) {
return sortFilesByOrder(files.value.filter((file) => file.connectionId === connectionId && (file.folderId || "") === (folderId || "")));
}
function folderCreateKey(connectionId: string, name: string, parentFolderId?: string) {
return JSON.stringify([connectionId, parentFolderId || "", name]);
}
function getFile(id: string) {
return files.value.find((file) => file.id === id);
}
function reserveFileName(file: SavedSqlNameScope, options: { allowExisting?: boolean } = {}): () => void {
const scopeKey = savedSqlNameScopeKey(file);
const nameKey = savedSqlNameKey(file.name);
if (!options.allowExisting) {
const persistedConflict = files.value.some((candidate) => candidate.id !== file.id && savedSqlNameScopeKey(candidate) === scopeKey && savedSqlNameKey(candidate.name) === nameKey);
if (persistedConflict) throw savedSqlNameConflict(file);
}
let pendingNames = pendingNamesByScope.get(scopeKey);
if (!pendingNames) {
pendingNames = new Map<string, PendingSavedSqlName>();
pendingNamesByScope.set(scopeKey, pendingNames);
}
const pending = pendingNames.get(nameKey);
if (!options.allowExisting && pending && [...pending.owners.keys()].some((ownerId) => ownerId !== file.id)) throw savedSqlNameConflict(file);
if (pending) pending.owners.set(file.id, (pending.owners.get(file.id) ?? 0) + 1);
else pendingNames.set(nameKey, { owners: new Map([[file.id, 1]]) });
let released = false;
return () => {
if (released) return;
released = true;
const currentNames = pendingNamesByScope.get(scopeKey);
const current = currentNames?.get(nameKey);
const count = current?.owners.get(file.id);
if (!current || count === undefined) return;
if (count > 1) current.owners.set(file.id, count - 1);
else current.owners.delete(file.id);
if (current.owners.size === 0) currentNames?.delete(nameKey);
if (currentNames?.size === 0) pendingNamesByScope.delete(scopeKey);
};
}
function pendingFileNames(scopeKey: string): string[] {
return [...(pendingNamesByScope.get(scopeKey)?.keys() ?? [])];
}
/**
* A conflict that tells the caller where to go next. The suggestion is
* resolved against the same scope `reserveFileName` just rejected, including
* names reserved by saves that are still in flight, so it is free at the
* moment of the conflict. A concurrent writer can still take it in between,
* which is why callers retry rather than assume the name is reserved.
*/
function savedSqlNameConflict(file: SavedSqlNameScope): SavedSqlNameConflictError {
return new SavedSqlNameConflictError(file.name, nextAvailableSqlName(file.name, takenFileNames(file)));
}
/** Names already occupied in one library scope, including in-flight saves. */
function takenFileNames(scope: SavedSqlNameScopeInput): Set<string> {
const scopeKey = savedSqlNameScopeKey(scope);
return new Set([...files.value.filter((file) => savedSqlNameScopeKey(file) === scopeKey).map((file) => file.name), ...pendingFileNames(scopeKey)]);
}
async function ensureFileContent(id: string) {
const existing = getFile(id);
if (!existing) return undefined;
if (existing.sqlLoaded !== false) return existing;
const loaded = await api.loadSavedSqlFile(id);
if (!loaded) return existing;
const hydrated = { ...normalizeSavedSqlFile(loaded), sqlLoaded: true };
files.value = files.value.map((file) => (file.id === id ? hydrated : file));
bumpVersion();
return hydrated;
}
async function createFolder(connectionId: string, name: string, parentFolderId?: string) {
const key = folderCreateKey(connectionId, name, parentFolderId);
const pending = pendingFolderCreates.get(key);
if (pending) return pending;
const createPromise = (async () => {
const timestamp = nowIso();
const folder: SavedSqlFolder = {
id: uuid(),
connectionId,
parentFolderId: parentFolderId || undefined,
name,
orderIndex: maxOrderIndex(folders.value.filter((item) => item.connectionId === connectionId && (item.parentFolderId || "") === (parentFolderId || ""))) + 1,
createdAt: timestamp,
updatedAt: timestamp,
};
const saved = await api.saveSavedSqlFolder(folder);
folders.value = [...folders.value.filter((item) => item.id !== saved.id), saved];
bumpVersion();
await syncToLocalDirectory();
return saved;
})();
pendingFolderCreates.set(key, createPromise);
try {
return await createPromise;
} finally {
if (pendingFolderCreates.get(key) === createPromise) {
pendingFolderCreates.delete(key);
}
}
}
async function renameFolder(id: string, name: string) {
const existing = folders.value.find((folder) => folder.id === id);
if (!existing) return;
const saved = await api.saveSavedSqlFolder({ ...existing, name, updatedAt: nowIso() });
folders.value = folders.value.map((folder) => (folder.id === id ? saved : folder));
bumpVersion();
await syncToLocalDirectory();
}
async function deleteFolder(id: string) {
const removedIds = descendantFolderIds(id);
const removesFiles = files.value.some((file) => !!file.folderId && removedIds.has(file.folderId));
await api.deleteSavedSqlFolder(id);
folders.value = folders.value.filter((folder) => !removedIds.has(folder.id));
files.value = files.value.filter((file) => !file.folderId || !removedIds.has(file.folderId));
bumpVersion({ tree: removesFiles });
await syncToLocalDirectory();
}
async function saveFile(input: SaveFileInput) {
const timestamp = nowIso();
const existing = input.id ? getFile(input.id) : undefined;
const catalog = normalizedCatalog(input.catalog);
const hasFolderIdInput = Object.prototype.hasOwnProperty.call(input, "folderId");
const file: SavedSqlFile = existing
? {
...existing,
// Partial metadata updates should not move files out of their folder.
// Callers that intentionally move to root pass `folderId: undefined`.
folderId: hasFolderIdInput ? input.folderId || undefined : existing.folderId,
name: input.name,
database: input.database,
schema: input.schema,
sql: input.sql,
sqlLoaded: true,
connectionId: input.connectionId,
catalog,
updatedAt: timestamp,
}
: {
id: uuid(),
connectionId: input.connectionId,
catalog,
folderId: input.folderId || undefined,
name: input.name,
database: input.database,
schema: input.schema,
sql: input.sql,
sqlLoaded: true,
orderIndex: maxOrderIndex(files.value.filter((file) => file.connectionId === input.connectionId && (file.folderId || "") === (input.folderId || undefined || ""))) + 1,
createdAt: timestamp,
updatedAt: timestamp,
};
const nameIdentityChanged = !existing || savedSqlNameIdentity(existing) !== savedSqlNameIdentity(file);
const releaseName = nameIdentityChanged ? reserveFileName(file) : undefined;
try {
const saved = normalizeSavedSqlFile(await api.saveSavedSqlFile(file));
files.value = [...files.value.filter((item) => item.id !== saved.id), { ...saved, sqlLoaded: true }];
bumpVersion({ tree: !existing || savedSqlTreeIdentity(existing) !== savedSqlTreeIdentity(saved) });
await syncToLocalDirectory();
return saved;
} finally {
releaseName?.();
}
}
function setPersistedFileTarget(file: SavedSqlFile) {
const releaseName = reserveFileName(file, { allowExisting: true });
persistedFileTargetNameReleases.get(file.id)?.();
persistedFileTargetNameReleases.set(file.id, releaseName);
persistedFileTargets.set(file.id, {
connectionId: file.connectionId,
catalog: normalizedCatalog(file.catalog),
database: file.database,
schema: file.schema,
folderId: file.folderId,
orderIndex: file.orderIndex,
updatedAt: file.updatedAt,
});
}
function updateFileExecutionTarget(id: string, target: SavedSqlExecutionTargetInput, options: SavedSqlExecutionTargetUpdateOptions = {}): Promise<SavedSqlFile | undefined> {
const existing = getFile(id);
if (!existing) return Promise.resolve(undefined);
const normalizedTarget = { ...target, catalog: normalizedCatalog(target.catalog) };
const folderId = options.updateFolder ? options.folderId || undefined : existing.folderId;
const orderIndex = options.updateFolder ? options.orderIndex : existing.orderIndex;
if (
existing.connectionId === normalizedTarget.connectionId &&
normalizedCatalog(existing.catalog) === normalizedTarget.catalog &&
existing.database === normalizedTarget.database &&
existing.schema === normalizedTarget.schema &&
existing.folderId === folderId &&
existing.orderIndex === orderIndex
) {
return Promise.resolve(existing);
}
if (!persistedFileTargets.has(id)) {
setPersistedFileTarget(existing);
}
const revision = (fileTargetRevisions.get(id) ?? 0) + 1;
fileTargetRevisions.set(id, revision);
files.value = files.value.map((file) => (file.id === id ? { ...file, ...normalizedTarget, folderId, orderIndex, updatedAt: nowIso() } : file));
bumpVersion({ tree: true });
const previousSave = pendingFileTargetSaves.get(id) ?? Promise.resolve(undefined);
const save = previousSave
.catch(() => undefined)
.then(async () => {
if (fileTargetRevisions.get(id) !== revision) return getFile(id);
let releaseName: (() => void) | undefined;
try {
const currentFile = options.metadataOnly ? getFile(id) : await ensureFileContent(id);
if (!currentFile || fileTargetRevisions.get(id) !== revision) return currentFile;
const candidate: SavedSqlFile = {
...currentFile,
...normalizedTarget,
folderId,
orderIndex,
updatedAt: nowIso(),
};
files.value = files.value.map((file) => (file.id === id ? candidate : file));
bumpVersion();
const persistedTarget = persistedFileTargets.get(id);
const persistedNameIdentity = persistedTarget
? savedSqlNameIdentity({
...candidate,
connectionId: persistedTarget.connectionId,
catalog: persistedTarget.catalog,
database: persistedTarget.database,
folderId: persistedTarget.folderId,
})
: savedSqlNameIdentity(candidate);
if (persistedNameIdentity !== savedSqlNameIdentity(candidate)) releaseName = reserveFileName(candidate);
const saved = normalizeSavedSqlFile(await api.saveSavedSqlFile(candidate));
setPersistedFileTarget(saved);
if (fileTargetRevisions.get(id) !== revision) return getFile(id);
const latest = getFile(id);
const persisted = { ...saved, sql: latest?.sql ?? saved.sql, sqlLoaded: latest?.sqlLoaded ?? true };
files.value = files.value.map((file) => (file.id === id ? persisted : file));
bumpVersion();
if (options.syncLocalDirectory !== false) await syncToLocalDirectory();
return persisted;
} catch (error) {
if (fileTargetRevisions.get(id) === revision) {
const persistedTarget = persistedFileTargets.get(id);
if (persistedTarget) files.value = files.value.map((file) => (file.id === id ? { ...file, ...persistedTarget } : file));
bumpVersion({ tree: true });
}
throw error;
} finally {
releaseName?.();
}
});
pendingFileTargetSaves.set(id, save);
const cleanup = () => {
if (pendingFileTargetSaves.get(id) !== save) return;
pendingFileTargetSaves.delete(id);
persistedFileTargets.delete(id);
persistedFileTargetNameReleases.get(id)?.();
persistedFileTargetNameReleases.delete(id);
};
void save.then(cleanup, cleanup);
return save;
}
async function updateFilesExecutionTarget(fileIds: readonly string[], target: SavedSqlBatchTargetSelection): Promise<SavedSqlBatchTargetResult> {
const uniqueFileIds = [...new Set(fileIds)];
if (uniqueFileIds.length === 0 || !target.connectionId) return { succeeded: [], updated: [], failures: [] };
const { useConnectionStore } = await import("@/stores/connectionStore");
const targetConnection = useConnectionStore().getConfig(target.connectionId);
const targetCapabilities = sqlExecutionTargetCapabilities(targetConnection);
if (!targetConnection || !targetCapabilities || (targetCapabilities.databaseRequired && !target.database)) return { succeeded: [], updated: [], failures: [] };
const normalizedTarget = normalizeSqlExecutionTarget(targetConnection, target);
const selectedFiles = uniqueFileIds.map((id) => getFile(id)).filter((file): file is SavedSqlFile => Boolean(file));
if (selectedFiles.length === 0) return { succeeded: [], updated: [], failures: [] };
let nextUnfiledOrder = maxOrderIndex(files.value.filter((file) => !file.folderId)) + 1;
const succeeded: SavedSqlFile[] = [];
const updated: SavedSqlFile[] = [];
const failures: SavedSqlBatchTargetFailure[] = [];
for (const file of selectedFiles) {
const folder = file.folderId ? folders.value.find((candidate) => candidate.id === file.folderId) : undefined;
const reassignment = savedSqlBatchReassignment(file, folder, normalizedTarget);
const leavesFolder = !!file.folderId && !reassignment.folderId;
const orderIndex = leavesFolder ? nextUnfiledOrder++ : file.orderIndex;
const targetChanged =
file.connectionId !== reassignment.target.connectionId ||
normalizedCatalog(file.catalog) !== normalizedCatalog(reassignment.target.catalog) ||
file.database !== reassignment.target.database ||
file.schema !== reassignment.target.schema ||
file.folderId !== reassignment.folderId ||
file.orderIndex !== orderIndex;
try {
const saved = await updateFileExecutionTarget(file.id, reassignment.target, {
folderId: reassignment.folderId,
metadataOnly: true,
orderIndex,
updateFolder: true,
syncLocalDirectory: false,
});
if (!saved) continue;
succeeded.push(saved);
if (targetChanged) updated.push(saved);
} catch (error) {
failures.push({ fileId: file.id, fileName: file.name, error });
}
}
if (succeeded.length > 0) {
const { useQueryStore } = await import("@/stores/queryStore");
useQueryStore().syncSavedSqlExecutionTargets(succeeded);
}
if (updated.length > 0) {
try {
await syncToLocalDirectory();
} catch (error) {
console.warn("[DBX][saved-sql:sync:error]", error);
}
}
return { succeeded, updated, failures };
}
async function renameFile(id: string, name: string) {
const existing = getFile(id);
if (!existing) return;
const normalizedName = ensureSqlExtension(name);
if (normalizedName === existing.name) return existing;
const candidate = { ...existing, name: normalizedName, updatedAt: nowIso() };
const releaseName = reserveFileName(candidate);
try {
const saved = normalizeSavedSqlFile(await api.saveSavedSqlFile(candidate));
files.value = files.value.map((file) => (file.id === id ? { ...saved, sql: file.sql, sqlLoaded: file.sqlLoaded } : file));
bumpVersion({ tree: true });
const { useQueryStore } = await import("@/stores/queryStore");
const queryStore = useQueryStore();
for (const tab of queryStore.tabs) {
if (tab.savedSqlId === id) {
tab.title = saved.name;
tab.customTitle = true;
}
}
await syncToLocalDirectory();
return saved;
} finally {
releaseName();
}
}
async function copyFilesToDatabase(fileIds: readonly string[], target: SavedSqlExecutionTargetInput): Promise<SavedSqlFile[]> {
const uniqueFileIds = [...new Set(fileIds)];
const normalizedTarget = { ...target, catalog: normalizedCatalog(target.catalog) };
const copies: SavedSqlFile[] = [];
for (const fileId of uniqueFileIds) {
const source = await ensureFileContent(fileId);
if (!source) continue;
const sourceFolder = source.folderId ? folders.value.find((folder) => folder.id === source.folderId) : undefined;
const folderId = sourceFolder?.connectionId === normalizedTarget.connectionId ? source.folderId : undefined;
const copyScope = { ...normalizedTarget, folderId };
const name = nextSavedSqlCopyName(source.name, takenFileNames(copyScope));
const keepSourceScope = savedSqlDatabaseScopeKey(source) === savedSqlDatabaseScopeKey(normalizedTarget);
const saved = await saveFile({
connectionId: normalizedTarget.connectionId,
catalog: normalizedTarget.catalog,
folderId,
name,
database: normalizedTarget.database,
schema: keepSourceScope ? source.schema : normalizedTarget.schema,
sql: source.sql,
});
copies.push({ ...saved, sqlLoaded: true });
}
return copies;
}
async function recordFileUsage(id: string) {
const existing = getFile(id);
if (!existing) return;
try {
const saved = await api.saveSavedSqlFile({
...existing,
openCount: (existing.openCount ?? 0) + 1,
openedAt: nowIso(),
});
files.value = files.value.map((file) => (file.id === id ? { ...saved, sql: file.sql, sqlLoaded: file.sqlLoaded } : file));
bumpVersion();
return saved;
} catch (error) {
console.warn("[DBX][saved-sql:usage:error]", error);
return existing;
}
}
async function deleteFile(id: string) {
await api.deleteSavedSqlFile(id);
files.value = files.value.filter((file) => file.id !== id);
bumpVersion({ tree: true });
await syncToLocalDirectory();
// Close all tabs that reference this saved SQL file
const { useQueryStore } = await import("@/stores/queryStore");
const queryStore = useQueryStore();
const tabsToClose = queryStore.tabs.filter((tab) => tab.savedSqlId === id);
for (const tab of tabsToClose) {
queryStore.closeTab(tab.id, { force: true });
}
forgetSavedSqlEditorPosition(id);
}
async function persistFolders(nextFolders: SavedSqlFolder[]) {
const reindexed = nextFolders.map((folder) => ({ ...folder, updatedAt: folder.updatedAt || nowIso() }));
await Promise.all(reindexed.map((folder) => api.saveSavedSqlFolder(folder)));
folders.value = reindexed;
bumpVersion();
await syncToLocalDirectory();
}
async function persistFiles(nextFiles: SavedSqlFile[]) {
const previousTreeIdentities = new Map(files.value.map((file) => [file.id, savedSqlTreeIdentity(file)]));
const previousNameIdentities = new Map(files.value.map((file) => [file.id, savedSqlNameIdentity(file)]));
const releaseNames: Array<() => void> = [];
try {
for (const file of nextFiles) {
if (previousNameIdentities.get(file.id) !== savedSqlNameIdentity(file)) releaseNames.push(reserveFileName(file));
}
const savedFiles = await Promise.all(nextFiles.map((file) => api.saveSavedSqlFile(file)));
files.value = savedFiles.map((saved) => {
const existing = files.value.find((file) => file.id === saved.id);
return { ...normalizeSavedSqlFile(saved), sql: existing?.sql ?? saved.sql, sqlLoaded: existing?.sqlLoaded ?? saved.sqlLoaded };
});
const treeChanged = files.value.length !== previousTreeIdentities.size || files.value.some((file) => previousTreeIdentities.get(file.id) !== savedSqlTreeIdentity(file));
bumpVersion({ tree: treeChanged });
await syncToLocalDirectory();
} finally {
for (const releaseName of releaseNames) releaseName();
}
}
async function ensureAllFilesLoaded() {
if (!files.value.some((file) => file.sqlLoaded === false)) return;
try {
const loadedFiles = await api.loadSavedSqlFilesForSync();
const loadedById = new Map(loadedFiles.map((file) => [file.id, file]));
files.value = files.value.map((file) => {
if (file.sqlLoaded !== false) return file;
const loaded = loadedById.get(file.id);
return loaded ? { ...file, sql: loaded.sql, sqlLoaded: true } : file;
});
bumpVersion();
} catch {
const unloaded = files.value.filter((file) => file.sqlLoaded === false);
await Promise.allSettled(unloaded.map((file) => ensureFileContent(file.id)));
}
}
async function syncEntries() {
await ensureAllFilesLoaded();
const folderById = new Map(folders.value.map((folder) => [folder.id, folder]));
const folderPath = (folderId?: string): string | undefined => {
if (!folderId) return undefined;
const parts: string[] = [];
const seen = new Set<string>();
let current = folderById.get(folderId);
while (current && !seen.has(current.id)) {
seen.add(current.id);
parts.unshift(current.name);
current = current.parentFolderId ? folderById.get(current.parentFolderId) : undefined;
}
return parts.join("/");
};
const unloadedFile = files.value.find((file) => file.sqlLoaded === false);
if (unloadedFile) throw new Error(`Saved SQL file '${unloadedFile.id}' could not be loaded for directory sync.`);
return sortFilesByOrder(files.value).map((file) => ({
folderName: folderPath(file.folderId),
fileName: file.name,
sql: file.sql,
}));
}
async function syncToLocalDirectory() {
if (!isTauriRuntime()) return;
const settingsStore = useSettingsStore();
const targetDir = settingsStore.desktopSettings.saved_sql_sync_dir?.trim();
if (!targetDir) return;
const entries = await syncEntries();
const syncPromise = pendingSync?.catch(() => {}).then(() => api.syncSavedSqlDirectory({ targetDir, entries })) ?? api.syncSavedSqlDirectory({ targetDir, entries });
pendingSync = syncPromise;
try {
await syncPromise;
} catch (error) {
console.warn("[DBX][saved-sql:sync:error]", error);
} finally {
if (pendingSync === syncPromise) {
pendingSync = null;
}
}
}
async function reorderFolders(draggedId: string, targetId: string, position: "before" | "after") {
const dragged = folders.value.find((folder) => folder.id === draggedId);
const target = folders.value.find((folder) => folder.id === targetId);
if (!dragged || !target || dragged.id === target.id) return;
if (descendantFolderIds(draggedId).has(targetId)) return;
const timestamp = nowIso();
const targetParentFolderId = target.parentFolderId || undefined;
const previousParentFolderId = dragged.parentFolderId || undefined;
const ordered = sortFoldersByOrder(folders.value.filter((folder) => (folder.parentFolderId || "") === (targetParentFolderId || "")));
const remaining = ordered.filter((folder) => folder.id !== draggedId);
const targetIndex = remaining.findIndex((folder) => folder.id === targetId);
const insertIndex = position === "before" ? targetIndex : targetIndex + 1;
remaining.splice(insertIndex, 0, { ...dragged, parentFolderId: targetParentFolderId, updatedAt: timestamp });
const updatedTargetGroup = reindexFolders(remaining).map((folder) => ({
...folder,
parentFolderId: targetParentFolderId,
updatedAt: timestamp,
}));
const updatedSourceGroup =
previousParentFolderId === targetParentFolderId
? []
: reindexFolders(sortFoldersByOrder(folders.value.filter((folder) => folder.id !== draggedId && (folder.parentFolderId || "") === (previousParentFolderId || "")))).map((folder) => ({
...folder,
updatedAt: timestamp,
}));
const untouched = folders.value.filter((folder) => folder.id !== draggedId && (folder.parentFolderId || "") !== (targetParentFolderId || "") && (folder.parentFolderId || "") !== (previousParentFolderId || ""));
await persistFolders([...untouched, ...updatedSourceGroup, ...updatedTargetGroup]);
}
function descendantFolderIds(folderId: string) {
const ids = new Set<string>([folderId]);
let changed = true;
while (changed) {
changed = false;
for (const folder of folders.value) {
if (folder.parentFolderId && ids.has(folder.parentFolderId) && !ids.has(folder.id)) {
ids.add(folder.id);
changed = true;
}
}
}
return ids;
}
async function moveFolderToFolder(folderId: string, parentFolderId?: string) {
const target = folders.value.find((folder) => folder.id === folderId);
if (!target) return;
const nextParentFolderId = parentFolderId || undefined;
if ((target.parentFolderId || undefined) === nextParentFolderId) return;
if (nextParentFolderId && descendantFolderIds(folderId).has(nextParentFolderId)) return;
const timestamp = nowIso();
const previousParentFolderId = target.parentFolderId || undefined;
const sourceGroup = reindexFolders(sortFoldersByOrder(folders.value.filter((folder) => folder.id !== folderId && (folder.parentFolderId || "") === (previousParentFolderId || "")))).map((folder) => ({ ...folder, updatedAt: timestamp }));
const destinationGroup = reindexFolders([...sortFoldersByOrder(folders.value.filter((folder) => folder.id !== folderId && (folder.parentFolderId || "") === (nextParentFolderId || ""))), { ...target, parentFolderId: nextParentFolderId, updatedAt: timestamp }]).map((folder) => ({
...folder,
parentFolderId: nextParentFolderId,
updatedAt: timestamp,
}));
const untouched = folders.value.filter((folder) => folder.id !== folderId && (folder.parentFolderId || "") !== (previousParentFolderId || "") && (folder.parentFolderId || "") !== (nextParentFolderId || ""));
await persistFolders([...untouched, ...sourceGroup, ...destinationGroup]);
}
async function moveFileToFolder(fileId: string, folderId?: string) {
const target = files.value.find((file) => file.id === fileId);
if (!target) return;
const targetFolderId = folderId || undefined;
if ((target.folderId || undefined) === targetFolderId) return;
const timestamp = nowIso();
const sourceGroup = sortFilesByOrder(files.value.filter((file) => (file.folderId || "") === (target.folderId || ""))).filter((file) => file.id !== fileId);
const destinationGroup = sortFilesByOrder(files.value.filter((file) => file.id !== fileId && (file.folderId || "") === (targetFolderId || "")));
const movedFile: SavedSqlFile = {
...target,
folderId: targetFolderId,
updatedAt: timestamp,
};
const nextSource = reindexFiles(sourceGroup, target.folderId || undefined).map((file) => ({
...file,
updatedAt: timestamp,
}));
const nextDestination = reindexFiles([...destinationGroup, movedFile], targetFolderId).map((file) => ({
...file,
updatedAt: timestamp,
}));
const untouched = files.value.filter((file) => file.id !== fileId && (file.folderId || "") !== (target.folderId || "") && (file.folderId || "") !== (targetFolderId || ""));
await persistFiles([...untouched, ...nextSource, ...nextDestination]);
}
async function moveFilesToFolder(fileIds: string[], folderId?: string) {
const uniqueIds = [...new Set(fileIds)];
if (uniqueIds.length === 0) return;
const targetFolderId = folderId || undefined;
const movingFiles = uniqueIds.map((id) => files.value.find((file) => file.id === id)).filter((file): file is SavedSqlFile => Boolean(file));
const filesToMove = movingFiles.filter((file) => (file.folderId || undefined) !== targetFolderId);
if (filesToMove.length === 0) return;
const moveIdSet = new Set(filesToMove.map((file) => file.id));
const timestamp = nowIso();
const affectedFolderIds = new Set<string>(filesToMove.map((file) => file.folderId || ""));
affectedFolderIds.add(targetFolderId || "");
const movedFiles = filesToMove.map((file) => ({
...file,
folderId: targetFolderId,
updatedAt: timestamp,
}));
// Reindex each touched folder separately so moving a batch out of one
// folder never rewrites unrelated siblings into the destination folder.
const nextAffectedFiles = Array.from(affectedFolderIds).flatMap((groupId) => {
const normalizedGroupId = groupId || undefined;
const remaining = sortFilesByOrder(files.value.filter((file) => (file.folderId || "") === groupId && !moveIdSet.has(file.id)));
const group = groupId === (targetFolderId || "") ? [...remaining, ...movedFiles] : remaining;
return reindexFiles(group, normalizedGroupId).map((file) => ({
...file,
updatedAt: timestamp,
}));
});
const untouched = files.value.filter((file) => !affectedFolderIds.has(file.folderId || "") && !moveIdSet.has(file.id));
await persistFiles([...untouched, ...nextAffectedFiles]);
}
async function reorderFiles(draggedId: string, targetId: string, position: "before" | "after") {
const dragged = files.value.find((file) => file.id === draggedId);
const target = files.value.find((file) => file.id === targetId);
if (!dragged || !target || dragged.id === target.id) return;
const targetFolderId = target.folderId || undefined;
const groupFiles = sortFilesByOrder(files.value.filter((file) => (file.folderId || "") === (targetFolderId || "")));
const remainingGroup = groupFiles.filter((file) => file.id !== draggedId);
const draggedNext: SavedSqlFile = {
...dragged,
folderId: targetFolderId,
updatedAt: nowIso(),
};
const targetIndex = remainingGroup.findIndex((file) => file.id === targetId);
const insertIndex = position === "before" ? targetIndex : targetIndex + 1;
remainingGroup.splice(insertIndex, 0, draggedNext);
const updatedGroup = reindexFiles(remainingGroup, targetFolderId).map((file) => ({
...file,
updatedAt: draggedNext.updatedAt,
}));
const previousGroupId = dragged.folderId || undefined;
const sourceGroup = previousGroupId === targetFolderId ? [] : reindexFiles(sortFilesByOrder(files.value.filter((file) => file.id !== draggedId && (file.folderId || "") === (previousGroupId || ""))), previousGroupId).map((file) => ({ ...file, updatedAt: draggedNext.updatedAt }));
const untouched = files.value.filter((file) => file.id !== draggedId && (file.folderId || "") !== (targetFolderId || "") && (file.folderId || "") !== (previousGroupId || ""));
await persistFiles([...untouched, ...sourceGroup, ...updatedGroup]);
}
const allFolders = computed(() => sortFoldersByOrder(folders.value));
const allFoldersTreeOrder = computed(() =>
[...folders.value].sort((a, b) => {
const depthDiff = folderDepth(folders.value, a.id) - folderDepth(folders.value, b.id);
if (depthDiff !== 0) return depthDiff;
const orderDiff = (a.orderIndex ?? 0) - (b.orderIndex ?? 0);
if (orderDiff !== 0) return orderDiff;
return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
}),
);
const allFiles = computed(() => sortFilesByOrder(files.value));
function filesInFolder(folderId: string) {
return allFiles.value.filter((f) => f.folderId === folderId);
}
function filesWithoutFolder() {
return allFiles.value.filter((f) => !f.folderId);
}
async function sortFolderFiles(folderId: string | undefined, mode: SavedSqlFileSortMode) {
const targetFolderId = folderId || undefined;
const groupFiles = files.value.filter((file) => (file.folderId || undefined) === targetFolderId);
if (groupFiles.length <= 1) return;
const sortedGroup = sortFilesByCriteria(groupFiles, mode);
const reindexed = reindexFiles(sortedGroup, targetFolderId);
const untouched = files.value.filter((file) => (file.folderId || undefined) !== targetFolderId);
await persistFiles([...untouched, ...reindexed]);
}
async function sortFolderChildren(parentFolderId: string | undefined, mode: SavedSqlFolderSortMode) {
const targetParentId = parentFolderId || undefined;
const groupFolders = folders.value.filter((folder) => (folder.parentFolderId || undefined) === targetParentId);
if (groupFolders.length <= 1) return;
const sortedGroup = [...groupFolders].sort((a, b) => {
if (mode === "name-asc") {
return a.name.localeCompare(b.name, undefined, { numeric: true, sensitivity: "base" });
}
return b.name.localeCompare(a.name, undefined, { numeric: true, sensitivity: "base" });
});
const reindexed = reindexFolders(sortedGroup).map((folder) => ({
...folder,
parentFolderId: targetParentId,
}));
const untouched = folders.value.filter((folder) => (folder.parentFolderId || undefined) !== targetParentId);
await persistFolders([...untouched, ...reindexed]);
}
async function sortAllFolderFiles(mode: SavedSqlFileSortMode) {
const folderIds = new Set<string | undefined>([undefined, ...folders.value.map((f) => f.id)]);
const nextFiles: SavedSqlFile[] = [];
for (const fId of folderIds) {
const groupFiles = files.value.filter((file) => (file.folderId || undefined) === fId);
if (groupFiles.length <= 1) {
nextFiles.push(...groupFiles);
} else {
const sorted = sortFilesByCriteria(groupFiles, mode);
nextFiles.push(...reindexFiles(sorted, fId));
}
}
await persistFiles(nextFiles);
}
return {
folders,
files,
isLoaded,
loadState,
version,
treeVersion,
initFromStorage,
listFolders,
listChildFolders,
listFiles,
getFile,
ensureFileContent,
ensureAllFilesLoaded,
createFolder,
renameFolder,
deleteFolder,
saveFile,
updateFileExecutionTarget,
updateFilesExecutionTarget,
renameFile,
copyFilesToDatabase,
recordFileUsage,
deleteFile,
reorderFolders,
moveFolderToFolder,
reorderFiles,
moveFileToFolder,
moveFilesToFolder,
sortFolderFiles,
sortFolderChildren,
sortAllFolderFiles,
syncToLocalDirectory,
allFolders,
allFoldersTreeOrder,
allFiles,
filesInFolder,
filesWithoutFolder,
};
});