@matdata/yasgui 5.10.0 → 5.11.0

package/src/queryManagement/backends/GitlabProviderClient.ts

@@ -0,0 +1,327 @@
+import type { GitWorkspaceConfig, FolderEntry, ReadResult, VersionInfo, WriteQueryOptions } from "../types";
+import { BaseGitProviderClient } from "./BaseGitProviderClient";
+import { WorkspaceBackendError } from "./errors";
+import { parseGitRemote } from "./gitRemote";
+
+type GitlabProject = {
+  default_branch?: string;
+};
+
+type GitlabTreeItem = {
+  type: "tree" | "blob";
+  name: string;
+  path: string;
+};
+
+type GitlabFileResponse = {
+  content?: string;
+  encoding?: "base64";
+  last_commit_id?: string;
+};
+
+type GitlabCommit = {
+  id: string;
+  created_at?: string;
+  author_name?: string;
+  message?: string;
+};
+
+function inferApiBase(config: GitWorkspaceConfig, host: string): string {
+  const configured = (config as any).apiBaseUrl as string | undefined;
+  if (configured?.trim()) return configured.trim().replace(/\/+$/g, "");
+  if (host === "gitlab.com") return "https://gitlab.com/api/v4";
+  return `https://${host}/api/v4`;
+}
+
+export class GitlabProviderClient extends BaseGitProviderClient {
+  public static canHandle(config: GitWorkspaceConfig): boolean {
+    const provider = (config as any).provider as string | undefined;
+    if (provider && provider !== "auto") return provider === "gitlab";
+
+    try {
+      const { host } = parseGitRemote(config.remoteUrl);
+      return host === "gitlab.com" || host.includes("gitlab");
+    } catch {
+      return false;
+    }
+  }
+
+  private async request<T>(
+    apiBase: string,
+    config: GitWorkspaceConfig,
+    path: string,
+    init?: RequestInit,
+  ): Promise<{ status: number; json?: T }> {
+    const headers: Record<string, string> = {
+      Accept: "application/json",
+      "Content-Type": "application/json",
+    };
+
+    const token = config.auth.token?.trim();
+    if (token) headers["PRIVATE-TOKEN"] = token;
+
+    const res = await fetch(`${apiBase}${path}`, {
+      ...init,
+      // Avoid stale results after create/delete/rename.
+      cache: "no-store",
+      headers: {
+        ...headers,
+        ...(init?.headers as any),
+      },
+    });
+
+    const status = res.status;
+    const contentType = res.headers.get("content-type") || "";
+    if (contentType.includes("application/json")) {
+      const text = await res.text();
+      if (text.trim()) {
+        try {
+          const json = JSON.parse(text) as T;
+          return { status, json };
+        } catch {
+          // Invalid JSON, return status only
+          return { status };
+        }
+      }
+    }
+
+    return { status };
+  }
+
+  private getProjectId(config: GitWorkspaceConfig): string {
+    const { repoPath } = parseGitRemote(config.remoteUrl);
+    // GitLab uses the full namespace path, URL-encoded.
+    return encodeURIComponent(repoPath);
+  }
+
+  private async getBranch(config: GitWorkspaceConfig, apiBase: string): Promise<string> {
+    const configured = config.branch?.trim();
+    if (configured) return configured;
+
+    const projectId = this.getProjectId(config);
+    const { status, json } = await this.request<GitlabProject>(apiBase, config, `/projects/${projectId}`);
+    this.ensureOk(status, "Failed to resolve repository default branch.");
+
+    const branch = json?.default_branch?.trim();
+    if (!branch) throw new WorkspaceBackendError("UNKNOWN", "Could not determine default branch.");
+    return branch;
+  }
+
+  async validateAccess(config: GitWorkspaceConfig): Promise<void> {
+    const { host } = parseGitRemote(config.remoteUrl);
+    const apiBase = inferApiBase(config, host);
+    const projectId = this.getProjectId(config);
+
+    const { status } = await this.request(apiBase, config, `/projects/${projectId}`);
+    this.ensureOk(status, "Could not access GitLab project with the provided token.");
+  }
+
+  async listFolder(config: GitWorkspaceConfig, folderId?: string): Promise<FolderEntry[]> {
+    const { host } = parseGitRemote(config.remoteUrl);
+    const apiBase = inferApiBase(config, host);
+
+    const relPath = folderId?.trim() || "";
+    const fullPath = this.joinPath(config.rootPath, relPath);
+
+    const projectId = this.getProjectId(config);
+    const branch = await this.getBranch(config, apiBase);
+
+    const qsBase = new URLSearchParams();
+    qsBase.set("ref", branch);
+    qsBase.set("per_page", "100");
+    if (fullPath) qsBase.set("path", fullPath);
+
+    // Paginate to avoid silently missing items.
+    const items: GitlabTreeItem[] = [];
+    for (let page = 1; page <= 50; page++) {
+      const qs = new URLSearchParams(qsBase);
+      qs.set("page", String(page));
+
+      const { status, json } = await this.request<GitlabTreeItem[]>(
+        apiBase,
+        config,
+        `/projects/${projectId}/repository/tree?${qs.toString()}`,
+      );
+
+      if (status === 404) return [];
+      this.ensureOk(status, "Failed to list folder contents.");
+
+      const batch = Array.isArray(json) ? json : [];
+      items.push(...batch);
+      if (batch.length < 100) break;
+    }
+
+    const entries: FolderEntry[] = [];
+    for (const item of items) {
+      if (item.type === "tree") {
+        const id = relPath ? this.joinPath(relPath, item.name) : item.name;
+        entries.push({ kind: "folder", id, label: item.name, parentId: relPath || undefined });
+        continue;
+      }
+
+      if (item.type === "blob") {
+        if (!/\.sparql$/i.test(item.name)) continue;
+        const id = relPath ? this.joinPath(relPath, item.name) : item.name;
+        const label = item.name.replace(/\.sparql$/i, "");
+        entries.push({ kind: "query", id, label, parentId: relPath || undefined });
+      }
+    }
+
+    entries.sort((a, b) => {
+      if (a.kind !== b.kind) return a.kind === "folder" ? -1 : 1;
+      return a.label.toLowerCase().localeCompare(b.label.toLowerCase());
+    });
+
+    return entries;
+  }
+
+  private async readFileAtRef(
+    config: GitWorkspaceConfig,
+    apiBase: string,
+    queryId: string,
+    ref?: string,
+  ): Promise<{ text: string; lastCommitId?: string }> {
+    const projectId = this.getProjectId(config);
+    const filePath = this.joinPath(config.rootPath, queryId);
+
+    const branch = ref || (await this.getBranch(config, apiBase));
+
+    const { status, json } = await this.request<GitlabFileResponse>(
+      apiBase,
+      config,
+      `/projects/${projectId}/repository/files/${encodeURIComponent(filePath)}?ref=${encodeURIComponent(branch)}`,
+    );
+
+    this.ensureOk(status, "Failed to read query.");
+
+    const content = json?.content;
+    if (!content) throw new WorkspaceBackendError("NOT_FOUND", "Query not found");
+
+    const text = json?.encoding === "base64" ? this.base64DecodeUtf8(content) : content;
+    return { text, lastCommitId: json?.last_commit_id };
+  }
+
+  async readQuery(config: GitWorkspaceConfig, queryId: string): Promise<ReadResult> {
+    const { host } = parseGitRemote(config.remoteUrl);
+    const apiBase = inferApiBase(config, host);
+    const { text, lastCommitId } = await this.readFileAtRef(config, apiBase, queryId);
+    return { queryText: text, versionTag: lastCommitId };
+  }
+
+  async writeQuery(
+    config: GitWorkspaceConfig,
+    queryId: string,
+    queryText: string,
+    options?: WriteQueryOptions,
+  ): Promise<void> {
+    const { host } = parseGitRemote(config.remoteUrl);
+    const apiBase = inferApiBase(config, host);
+
+    const projectId = this.getProjectId(config);
+    const filePath = this.joinPath(config.rootPath, queryId);
+    const branch = await this.getBranch(config, apiBase);
+
+    // Check existence + optimistic concurrency.
+    let exists = true;
+    let lastCommitId: string | undefined;
+    try {
+      const res = await this.readFileAtRef(config, apiBase, queryId);
+      lastCommitId = res.lastCommitId;
+    } catch (e) {
+      const err = e as any;
+      exists = false;
+      if (err?.code && err.code !== "NOT_FOUND") throw e;
+    }
+
+    if (options?.expectedVersionTag && lastCommitId && options.expectedVersionTag !== lastCommitId) {
+      throw new WorkspaceBackendError(
+        "CONFLICT",
+        "The file changed remotely since it was last opened. Please reload the managed query and try saving again.",
+      );
+    }
+
+    const message = this.getCommitMessage(queryId, options, !exists);
+    const body: any = {
+      branch,
+      content: this.base64EncodeUtf8(queryText),
+      encoding: "base64",
+      commit_message: message,
+    };
+
+    const method = exists ? "PUT" : "POST";
+    const { status } = await this.request(
+      apiBase,
+      config,
+      `/projects/${projectId}/repository/files/${encodeURIComponent(filePath)}`,
+      {
+        method,
+        body: JSON.stringify(body),
+      },
+    );
+
+    this.ensureOk(status, "Failed to save query to GitLab workspace.");
+  }
+
+  async listVersions(config: GitWorkspaceConfig, queryId: string): Promise<VersionInfo[]> {
+    const { host } = parseGitRemote(config.remoteUrl);
+    const apiBase = inferApiBase(config, host);
+
+    const projectId = this.getProjectId(config);
+    const filePath = this.joinPath(config.rootPath, queryId);
+    const branch = await this.getBranch(config, apiBase);
+
+    const qs = new URLSearchParams();
+    qs.set("ref_name", branch);
+    qs.set("path", filePath);
+    qs.set("per_page", "30");
+
+    const { status, json } = await this.request<GitlabCommit[]>(
+      apiBase,
+      config,
+      `/projects/${projectId}/repository/commits?${qs.toString()}`,
+    );
+
+    this.ensureOk(status, "Failed to list query versions.");
+
+    const commits = Array.isArray(json) ? json : [];
+    return commits
+      .map((c) => {
+        const createdAt = c.created_at || new Date().toISOString();
+        return { id: c.id, createdAt, author: c.author_name, message: c.message } satisfies VersionInfo;
+      })
+      .filter((v) => !!v.id);
+  }
+
+  async readVersion(config: GitWorkspaceConfig, queryId: string, versionId: string): Promise<ReadResult> {
+    const { host } = parseGitRemote(config.remoteUrl);
+    const apiBase = inferApiBase(config, host);
+
+    const { text, lastCommitId } = await this.readFileAtRef(config, apiBase, queryId, versionId);
+    // Use the provider's optimistic-concurrency tag for this file content.
+    return { queryText: text, versionTag: lastCommitId };
+  }
+
+  async deleteQuery(config: GitWorkspaceConfig, queryId: string): Promise<void> {
+    const { host } = parseGitRemote(config.remoteUrl);
+    const apiBase = inferApiBase(config, host);
+
+    const projectId = this.getProjectId(config);
+    const filePath = this.joinPath(config.rootPath, queryId);
+    const branch = await this.getBranch(config, apiBase);
+
+    const body: any = {
+      branch,
+      commit_message: this.getDeleteMessage(queryId),
+    };
+
+    const { status } = await this.request(
+      apiBase,
+      config,
+      `/projects/${projectId}/repository/files/${encodeURIComponent(filePath)}`,
+      { method: "DELETE", body: JSON.stringify(body) },
+    );
+
+    if (status === 404) return;
+    this.ensureOk(status, "Failed to delete query from GitLab workspace.");
+  }
+}

package/src/queryManagement/backends/InMemoryWorkspaceBackend.ts

@@ -0,0 +1,175 @@
+import type { FolderEntry, ReadResult, VersionInfo, WriteQueryOptions, WorkspaceConfigBase } from "../types";
+import { normalizeQueryText } from "../textHash";
+import type { WorkspaceBackend } from "./WorkspaceBackend";
+import { WorkspaceBackendError } from "./errors";
+
+type InMemoryWorkspaceConfig = Pick<WorkspaceConfigBase, "id" | "label"> & {
+  type: "memory";
+};
+
+type StoredVersion = {
+  id: string;
+  createdAt: string;
+  queryText: string;
+};
+
+function normalizeFolderId(folderId?: string): string {
+  if (!folderId) return "";
+  return folderId.replace(/^\/+|\/+$/g, "");
+}
+
+function splitPath(path: string): string[] {
+  return path.split("/").filter(Boolean);
+}
+
+function basename(path: string): string {
+  const parts = splitPath(path);
+  return parts[parts.length - 1] || "";
+}
+
+function dirname(path: string): string {
+  const parts = splitPath(path);
+  parts.pop();
+  return parts.join("/");
+}
+
+function nowIso(): string {
+  return new Date().toISOString();
+}
+
+export default class InMemoryWorkspaceBackend implements WorkspaceBackend {
+  public readonly type = "git" as const;
+
+  private versionsByQueryId = new Map<string, StoredVersion[]>();
+
+  constructor(private _config?: InMemoryWorkspaceConfig) {}
+
+  async validateAccess(): Promise<void> {
+    return;
+  }
+
+  async listFolder(folderId?: string): Promise<FolderEntry[]> {
+    const folder = normalizeFolderId(folderId);
+
+    const folders = new Map<string, FolderEntry>();
+    const queries: FolderEntry[] = [];
+
+    for (const queryId of this.versionsByQueryId.keys()) {
+      const queryDir = dirname(queryId);
+      if (folder === "") {
+        const top = splitPath(queryDir)[0];
+        if (top) {
+          folders.set(top, { kind: "folder", id: top, label: top, parentId: undefined });
+          continue;
+        }
+        queries.push({
+          kind: "query",
+          id: queryId,
+          label: basename(queryId).replace(/\.sparql$/i, ""),
+          parentId: undefined,
+        });
+        continue;
+      }
+
+      if (queryDir === folder) {
+        queries.push({
+          kind: "query",
+          id: queryId,
+          label: basename(queryId).replace(/\.sparql$/i, ""),
+          parentId: folder,
+        });
+        continue;
+      }
+
+      if (queryDir.startsWith(folder + "/")) {
+        const rest = queryDir.slice(folder.length + 1);
+        const child = splitPath(rest)[0];
+        if (child) {
+          const childId = folder + "/" + child;
+          folders.set(childId, { kind: "folder", id: childId, label: child, parentId: folder });
+        }
+      }
+    }
+
+    const out = [...folders.values(), ...queries];
+    out.sort((a, b) => a.label.localeCompare(b.label));
+    return out;
+  }
+
+  async searchByName(query: string): Promise<FolderEntry[]> {
+    const q = query.trim().toLowerCase();
+    if (!q) return [];
+    const hits: FolderEntry[] = [];
+    for (const queryId of this.versionsByQueryId.keys()) {
+      const label = basename(queryId).replace(/\.sparql$/i, "");
+      if (label.toLowerCase().includes(q)) {
+        hits.push({ kind: "query", id: queryId, label, parentId: dirname(queryId) || undefined });
+      }
+    }
+    hits.sort((a, b) => a.label.localeCompare(b.label));
+    return hits;
+  }
+
+  async readQuery(queryId: string): Promise<ReadResult> {
+    const versions = this.versionsByQueryId.get(queryId);
+    if (!versions || versions.length === 0) throw new WorkspaceBackendError("NOT_FOUND", "Query not found");
+    const latest = versions[versions.length - 1];
+    return { queryText: latest.queryText, versionTag: latest.id };
+  }
+
+  async writeQuery(queryId: string, queryText: string, options?: WriteQueryOptions): Promise<void> {
+    const versions = this.versionsByQueryId.get(queryId) || [];
+
+    const latest = versions[versions.length - 1];
+    if (options?.expectedVersionTag && latest && options.expectedVersionTag !== latest.id) {
+      throw new WorkspaceBackendError("CONFLICT", "Version tag mismatch");
+    }
+
+    if (latest && normalizeQueryText(latest.queryText) === normalizeQueryText(queryText)) {
+      this.versionsByQueryId.set(queryId, versions);
+      return;
+    }
+
+    const nextId = `v${versions.length + 1}`;
+    versions.push({ id: nextId, createdAt: nowIso(), queryText });
+    this.versionsByQueryId.set(queryId, versions);
+  }
+
+  async listVersions(queryId: string): Promise<VersionInfo[]> {
+    const versions = this.versionsByQueryId.get(queryId);
+    if (!versions || versions.length === 0) return [];
+    return [...versions]
+      .slice()
+      .reverse()
+      .map((v) => ({ id: v.id, createdAt: v.createdAt }));
+  }
+
+  async readVersion(queryId: string, versionId: string): Promise<ReadResult> {
+    const versions = this.versionsByQueryId.get(queryId);
+    if (!versions || versions.length === 0) throw new WorkspaceBackendError("NOT_FOUND", "Query not found");
+    const found = versions.find((v) => v.id === versionId);
+    if (!found) throw new WorkspaceBackendError("NOT_FOUND", "Version not found");
+    return { queryText: found.queryText, versionTag: found.id };
+  }
+
+  async renameQuery(queryId: string, newLabel: string): Promise<void> {
+    const trimmed = newLabel.trim();
+    if (!trimmed) throw new WorkspaceBackendError("UNKNOWN", "New name is required");
+
+    const versions = this.versionsByQueryId.get(queryId);
+    if (!versions || versions.length === 0) throw new WorkspaceBackendError("NOT_FOUND", "Query not found");
+
+    const newId = dirname(queryId) ? `${dirname(queryId)}/${trimmed}.sparql` : `${trimmed}.sparql`;
+    if (newId === queryId) return;
+    if (this.versionsByQueryId.has(newId))
+      throw new WorkspaceBackendError("CONFLICT", "A query with this name already exists");
+
+    this.versionsByQueryId.delete(queryId);
+    this.versionsByQueryId.set(newId, versions);
+  }
+
+  async deleteQuery(queryId: string): Promise<void> {
+    if (!this.versionsByQueryId.has(queryId)) throw new WorkspaceBackendError("NOT_FOUND", "Query not found");
+    this.versionsByQueryId.delete(queryId);
+  }
+}