Skip to content

armgit / dbx

Public Imported from GitHub
0

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。

49.7 KB
Raw Blame
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 {
  isDefaultQuery?: boolean;
  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;
  /** Explicit destination folder used by SQL-library paste. */
  folderId?: 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 persistFile(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);
  }

  // Serialize content and metadata writes for a file, including deletion. A
  // rename/usage update must never write an older SQL snapshot over autosave.
  const fileWrites = new Map<string, Promise<unknown>>();
  const deletingFiles = new Set<string>();
  function enqueueFileWrite<T>(id: string, write: () => Promise<T>): Promise<T> {
    const pending = (fileWrites.get(id) ?? Promise.resolve()).catch(() => undefined).then(write);
    fileWrites.set(id, pending);
    const cleanup = () => {
      if (fileWrites.get(id) === pending) fileWrites.delete(id);
    };
    void pending.then(cleanup, cleanup);
    return pending;
  }

  function persistFile(file: SavedSqlFile, mode: "all" | "metadata" | "content" = "all"): Promise<SavedSqlFile> {
    return enqueueFileWrite(file.id, async () => {
      if (deletingFiles.has(file.id)) throw new Error("SQL file is being deleted");
      const current = getFile(file.id);
      if (mode === "content" && (!current || !current.isDefaultQuery)) throw new Error("Default query no longer exists");
      if (mode === "content") {
        await api.saveDefaultQueryContent(file.id, file.sql, file.updatedAt);
        return { ...current!, sql: file.sql, sqlLoaded: true, updatedAt: file.updatedAt };
      }
      const candidate = mode === "metadata" ? { ...file, sqlLoaded: false } : file;
      const saved = normalizeSavedSqlFile(await api.saveSavedSqlFile(candidate));
      if (mode === "metadata") return { ...saved, sql: current?.sql ?? file.sql, sqlLoaded: current?.sqlLoaded ?? file.sqlLoaded };
      return saved;
    });
  }

  const defaultQueryCreates = new Map<string, Promise<SavedSqlFile>>();

  function getDefaultQuery(scope: SavedSqlExecutionTargetInput) {
    const key = savedSqlDatabaseScopeKey(scope);
    return files.value.find((file) => file.isDefaultQuery && savedSqlDatabaseScopeKey(file) === key);
  }

  async function ensureDefaultQuery(scope: SavedSqlExecutionTargetInput): Promise<SavedSqlFile> {
    await initFromStorage();
    // The default query is database-scoped. A schema selected in the sidebar
    // must not become sticky state for the shared database default.
    const defaultScope = { ...scope, schema: undefined };
    const key = savedSqlDatabaseScopeKey(defaultScope);
    const pending = defaultQueryCreates.get(key);
    if (pending) return pending;
    const create = (async () => {
      const existing = getDefaultQuery(defaultScope);
      if (existing) {
        const loaded = await api.loadSavedSqlFile(existing.id);
        if (loaded) {
          const normalized = normalizeSavedSqlFile(loaded);
          const file =
            normalized.schema === undefined
              ? { ...normalized, sqlLoaded: true }
              : await saveFile({
                  id: normalized.id,
                  isDefaultQuery: true,
                  connectionId: normalized.connectionId,
                  folderId: normalized.folderId,
                  name: normalized.name,
                  database: normalized.database,
                  catalog: normalized.catalog,
                  schema: undefined,
                  sql: normalized.sql,
                });
          files.value = files.value.map((item) => (item.id === file.id ? file : item));
          bumpVersion({ tree: true });
          return file;
        }
        files.value = files.value.filter((file) => file.id !== existing.id);
      }
      try {
        return await saveFile({
          ...defaultScope,
          folderId: undefined,
          name: nextAvailableSqlName("default.sql", takenFileNames({ ...defaultScope, folderId: undefined })),
          sql: "",
          isDefaultQuery: true,
        });
      } catch (error) {
        // The unique scope constraint also protects creation from another window.
        const library = await api.loadSavedSqlLibrary();
        const winner = library.files.find((file) => file.isDefaultQuery && savedSqlDatabaseScopeKey(file) === key);
        if (!winner) throw error;
        files.value = [...files.value.filter((file) => file.id !== winner.id), normalizeSavedSqlFile(winner)];
        bumpVersion({ tree: true });
        const loaded = await ensureFileContent(winner.id);
        if (!loaded) throw error;
        return loaded;
      }
    })();
    defaultQueryCreates.set(key, create);
    try {
      return await create;
    } finally {
      if (defaultQueryCreates.get(key) === create) defaultQueryCreates.delete(key);
    }
  }

  async function saveDefaultQueryContent(id: string, sql: string): Promise<void> {
    await initFromStorage();
    const file = getFile(id);
    if (!file?.isDefaultQuery) throw new Error("Default query no longer exists");
    const saved = await persistFile({ ...file, sql, updatedAt: nowIso() }, "content");
    files.value = files.value.map((item) => (item.id === id ? { ...item, sql: saved.sql, sqlLoaded: true, updatedAt: saved.updatedAt } : item));
    bumpVersion();
    await syncToLocalDirectory();
  }

  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 removedFiles = files.value.filter((file) => !!file.folderId && removedIds.has(file.folderId));
    const removesFiles = removedFiles.length > 0;
    for (const file of removedFiles) deletingFiles.add(file.id);
    await Promise.allSettled(removedFiles.map((file) => fileWrites.get(file.id)));
    try {
      await api.deleteSavedSqlFolder(id);
    } catch (error) {
      for (const file of removedFiles) deletingFiles.delete(file.id);
      throw error;
    }
    const { useQueryStore } = await import("@/stores/queryStore");
    const queryStore = useQueryStore();
    for (const tab of queryStore.tabs) {
      if (removedFiles.some((file) => file.id === tab.savedSqlId) && tab.isDefaultQuery) {
        tab.isDefaultQuery = false;
        queryStore.closeTab(tab.id, { force: true });
      }
    }
    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(),
          isDefaultQuery: input.isDefaultQuery === true,
          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 persistFile(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) };
    if (existing.isDefaultQuery && savedSqlDatabaseScopeKey(existing) !== savedSqlDatabaseScopeKey(normalizedTarget)) {
      return copyFilesToDatabase([id], normalizedTarget).then((copies) => copies[0]);
    }
    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 persistFile(candidate, "metadata"));
          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 persistFile(candidate, "metadata"));
      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 requestedFolder = normalizedTarget.folderId ? folders.value.find((folder) => folder.id === normalizedTarget.folderId) : undefined;
      const folderId = requestedFolder?.connectionId === normalizedTarget.connectionId ? requestedFolder.id : 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 persistFile(
        {
          ...existing,
          openCount: (existing.openCount ?? 0) + 1,
          openedAt: nowIso(),
        },
        "metadata",
      );
      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) {
    deletingFiles.add(id);
    try {
      await enqueueFileWrite(id, () => api.deleteSavedSqlFile(id));
    } catch (error) {
      deletingFiles.delete(id);
      throw error;
    }
    files.value = files.value.filter((file) => file.id !== id);
    bumpVersion({ tree: true });

    // 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) {
      tab.isDefaultQuery = false;
      queryStore.closeTab(tab.id, { force: true });
    }
    forgetSavedSqlEditorPosition(id);
    await syncToLocalDirectory();
  }

  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) => persistFile(file, "metadata")));
      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,
    getDefaultQuery,
    ensureDefaultQuery,
    saveDefaultQueryContent,
    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,
  };
});