@treeseed/sdk 0.10.27 → 0.11.0

package/dist/treedx/errors.d.ts

@@ -0,0 +1,13 @@
+import type { TreeDxErrorCode } from './types.ts';
+export declare class TreeDxApiError extends Error {
+    readonly status: number;
+    readonly code: TreeDxErrorCode;
+    readonly details: Record<string, unknown>;
+    readonly payload: unknown;
+    constructor(message: string, options: {
+        status: number;
+        code?: TreeDxErrorCode;
+        details?: Record<string, unknown>;
+        payload?: unknown;
+    });
+}

package/dist/treedx/errors.js

@@ -0,0 +1,17 @@
+class TreeDxApiError extends Error {
+  status;
+  code;
+  details;
+  payload;
+  constructor(message, options) {
+    super(message);
+    this.name = "TreeDxApiError";
+    this.status = options.status;
+    this.code = options.code ?? "treedx_api_error";
+    this.details = options.details ?? {};
+    this.payload = options.payload;
+  }
+}
+export {
+  TreeDxApiError
+};

package/dist/treedx/federated-client.d.ts

@@ -0,0 +1,27 @@
+import { TreeDxClient } from './client.ts';
+import { TreeDxRegistryClient, type TreeDxRegistryClientOptions } from './registry-client.ts';
+import type { TreeDxFederatedContextRequest, TreeDxFederatedContextResult, TreeDxFederatedGraphRequest, TreeDxFederatedGraphResult, TreeDxFederatedQueryRequest, TreeDxFederatedQueryResult, TreeDxFederatedSearchRequest, TreeDxFederatedSearchResult, TreeDxFederationQueryPlan, TreeDxFederationQueryPlanRequest } from './types.ts';
+export interface TreeDxFederatedClientOptions {
+    registry: TreeDxRegistryClientOptions | TreeDxRegistryClient;
+    token?: string;
+    fetch?: typeof fetch;
+    nodeBaseUrls?: Record<string, string>;
+}
+export declare class TreeDxFederatedClient {
+    private readonly registry;
+    private readonly token?;
+    private readonly fetchImpl?;
+    private readonly nodeBaseUrls;
+    constructor(options: TreeDxFederatedClientOptions);
+    resolveRepository(repoId: string): Promise<TreeDxClient>;
+    resolveRepositoryForRead(repoId: string): Promise<TreeDxClient>;
+    resolveRepositoryForWrite(repoId: string): Promise<TreeDxClient>;
+    planQuery(input: TreeDxFederationQueryPlanRequest): Promise<TreeDxFederationQueryPlan>;
+    query(input: TreeDxFederatedQueryRequest): Promise<TreeDxFederatedQueryResult>;
+    search(input: TreeDxFederatedSearchRequest): Promise<TreeDxFederatedSearchResult>;
+    federatedSearch(input: TreeDxFederatedSearchRequest): Promise<TreeDxFederatedSearchResult>;
+    federatedQuery(input: TreeDxFederatedQueryRequest): Promise<TreeDxFederatedQueryResult>;
+    federatedContext(input: TreeDxFederatedContextRequest): Promise<TreeDxFederatedContextResult>;
+    federatedGraph(input: TreeDxFederatedGraphRequest): Promise<TreeDxFederatedGraphResult>;
+    private clientForPlacement;
+}

package/dist/treedx/federated-client.js

@@ -0,0 +1,158 @@
+import { TreeDxClient } from "./client.js";
+import { TreeDxApiError } from "./errors.js";
+import { TreeDxRegistryClient } from "./registry-client.js";
+function placementRepoId(placement, fallback) {
+  return placement.repositoryId ?? placement.repoId ?? fallback;
+}
+class TreeDxFederatedClient {
+  registry;
+  token;
+  fetchImpl;
+  nodeBaseUrls;
+  constructor(options) {
+    this.registry = options.registry instanceof TreeDxRegistryClient ? options.registry : new TreeDxRegistryClient(options.registry);
+    this.token = options.token;
+    this.fetchImpl = options.fetch;
+    this.nodeBaseUrls = options.nodeBaseUrls ?? {};
+  }
+  async resolveRepository(repoId) {
+    return this.resolveRepositoryForWrite(repoId);
+  }
+  async resolveRepositoryForRead(repoId) {
+    return this.clientForPlacement(await this.registry.resolveRepository(repoId), repoId);
+  }
+  async resolveRepositoryForWrite(repoId) {
+    return this.clientForPlacement(await this.registry.resolveRepository(repoId), repoId);
+  }
+  async planQuery(input) {
+    return this.registry.client.planFederatedQuery(input);
+  }
+  async query(input) {
+    const repoIds = input.repoIds ?? (input.repoId ? [input.repoId] : []);
+    if (repoIds.length !== 1) {
+      return this.federatedQuery({ ...input, repoIds });
+    }
+    const repoId = repoIds[0];
+    try {
+      const client = await this.resolveRepositoryForRead(repoId);
+      const result = await client.queryRepository({ ...input, repoId });
+      return singleQueryResult(repoId, input.type, result);
+    } catch (error) {
+      if (input.includeErrors && error instanceof TreeDxApiError) {
+        return {
+          type: input.type,
+          results: [],
+          page: { limit: input.limit ?? 20, hasMore: false, cursor: null },
+          diagnostics: singleDiagnostics(repoId, 1),
+          errors: [{ repoId, code: error.code, message: error.message, status: error.status }]
+        };
+      }
+      throw error;
+    }
+  }
+  async search(input) {
+    const repoIds = input.repoIds ?? (input.repoId ? [input.repoId] : []);
+    if (repoIds.length !== 1) {
+      return this.federatedSearch({ ...input, repoIds });
+    }
+    const repoId = repoIds[0];
+    try {
+      const client = await this.resolveRepositoryForRead(repoId);
+      const result = await client.searchRepositoryFiles({ ...input, repoId });
+      return singleSearchResult(repoId, input.query, result);
+    } catch (error) {
+      if (input.includeErrors && error instanceof TreeDxApiError) {
+        return {
+          query: input.query,
+          results: [],
+          page: { limit: input.limit ?? 20, hasMore: false, cursor: null },
+          diagnostics: singleDiagnostics(repoId, 1),
+          errors: [{ repoId, code: error.code, message: error.message, status: error.status }]
+        };
+      }
+      throw error;
+    }
+  }
+  async federatedSearch(input) {
+    return this.registry.client.federatedSearch(input);
+  }
+  async federatedQuery(input) {
+    return this.registry.client.federatedQuery(input);
+  }
+  async federatedContext(input) {
+    return this.registry.client.federatedContext(input);
+  }
+  async federatedGraph(input) {
+    return this.registry.client.federatedGraph(input);
+  }
+  async clientForPlacement(placement, fallbackRepoId) {
+    const nodeId = placement.primaryNodeId;
+    let baseUrl = this.nodeBaseUrls[nodeId];
+    if (!baseUrl) {
+      const nodes = await this.registry.listNodes();
+      baseUrl = nodes.find((node) => node.id === nodeId)?.baseUrl;
+    }
+    if (!baseUrl) {
+      throw new TreeDxApiError(`TreeDX node "${nodeId}" is not configured.`, {
+        status: 404,
+        code: "node_not_configured",
+        details: { nodeId }
+      });
+    }
+    return new TreeDxClient({
+      baseUrl,
+      token: this.token,
+      fetch: this.fetchImpl,
+      repoId: placementRepoId(placement, fallbackRepoId)
+    });
+  }
+}
+function singleDiagnostics(repoId, partialFailureCount = 0) {
+  return {
+    requestedRepoCount: 1,
+    executedRepoCount: partialFailureCount === 0 ? 1 : 0,
+    rejectedRepoCount: 0,
+    partialFailureCount,
+    routing: [
+      {
+        repoId,
+        source: "remote",
+        status: partialFailureCount === 0 ? "ok" : "partial_failure"
+      }
+    ]
+  };
+}
+function resultItems(result, repoId) {
+  const ref = typeof result.ref === "string" ? result.ref : "refs/heads/main";
+  const items = Array.isArray(result.results) ? result.results : [];
+  return items.map((item) => ({
+    ...typeof item === "object" && item !== null ? item : { value: item },
+    repoId,
+    ref,
+    source: "remote"
+  }));
+}
+function resultPage(result, limit = 20) {
+  return typeof result.page === "object" && result.page !== null ? result.page : { limit, hasMore: false, cursor: null };
+}
+function singleQueryResult(repoId, type, result) {
+  return {
+    type: typeof result.type === "string" ? result.type : type,
+    results: resultItems(result, repoId),
+    page: resultPage(result),
+    diagnostics: singleDiagnostics(repoId),
+    errors: []
+  };
+}
+function singleSearchResult(repoId, query, result) {
+  return {
+    query,
+    results: resultItems(result, repoId),
+    page: resultPage(result),
+    diagnostics: singleDiagnostics(repoId),
+    errors: []
+  };
+}
+export {
+  TreeDxFederatedClient
+};