@inkeep/agents-manage-ui 0.1.0

package/src/lib/api/graph-full-client.ts

@@ -0,0 +1,109 @@
+/**
+ * API Client for Graph Full Operations
+ *
+ * This module provides HTTP client functions to communicate with the
+ * inkeep-chat backend GraphFull REST API endpoints.
+ */
+
+import { ApiError } from '../types/errors';
+import type {
+  CreateGraphResponse,
+  FullGraphDefinition,
+  GetGraphResponse,
+  Graph,
+  UpdateGraphResponse,
+} from '../types/graph-full';
+import type { ListResponse } from '../types/response';
+import { makeManagementApiRequest } from './api-config';
+import { validateProjectId, validateTenantId } from './resource-validation';
+
+export async function fetchGraphs(
+  tenantId: string,
+  projectId: string
+): Promise<ListResponse<Graph>> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  return makeManagementApiRequest<ListResponse<Graph>>(
+    `tenants/${tenantId}/crud/projects/${projectId}/agent-graphs`
+  );
+}
+
+/**
+ * Create a new full graph
+ */
+export async function createFullGraph(
+  tenantId: string,
+  projectId: string,
+  graphData: FullGraphDefinition
+): Promise<CreateGraphResponse> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  return makeManagementApiRequest<CreateGraphResponse>(
+    `tenants/${tenantId}/crud/projects/${projectId}/graph`,
+    {
+      method: 'POST',
+      body: JSON.stringify(graphData),
+    }
+  );
+}
+
+/**
+ * Get a full graph by ID
+ */
+export async function getFullGraph(
+  tenantId: string,
+  projectId: string,
+  graphId: string
+): Promise<GetGraphResponse> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  return makeManagementApiRequest<GetGraphResponse>(
+    `tenants/${tenantId}/crud/projects/${projectId}/graph/${graphId}`,
+    {
+      method: 'GET',
+    }
+  );
+}
+
+/**
+ * Update or create a full graph (upsert)
+ */
+export async function updateFullGraph(
+  tenantId: string,
+  projectId: string,
+  graphId: string,
+  graphData: FullGraphDefinition
+): Promise<UpdateGraphResponse> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  return makeManagementApiRequest<UpdateGraphResponse>(
+    `tenants/${tenantId}/crud/projects/${projectId}/graph/${graphId}`,
+    {
+      method: 'PUT',
+      body: JSON.stringify(graphData),
+    }
+  );
+}
+
+/**
+ * Delete a full graph
+ */
+export async function deleteFullGraph(
+  tenantId: string,
+  projectId: string,
+  graphId: string
+): Promise<void> {
+  validateTenantId(tenantId);
+  validateProjectId(projectId);
+
+  await makeManagementApiRequest(`tenants/${tenantId}/crud/projects/${projectId}/graph/${graphId}`, {
+    method: 'DELETE',
+  });
+}
+
+// Export the error class for use in server actions
+export { ApiError };

package/src/lib/api/projects.ts

@@ -0,0 +1,104 @@
+'use server';
+
+import type { Project } from '../types/project';
+import type { ListResponse, SingleResponse } from '../types/response';
+import type { ProjectFormData } from '@/components/projects/form/validation';
+import { makeManagementApiRequest } from './api-config';
+import { validateTenantId } from './resource-validation';
+
+export async function fetchProjects(tenantId: string): Promise<ListResponse<Project>> {
+  validateTenantId(tenantId);
+
+  const response = await makeManagementApiRequest<ListResponse<any>>(
+    `tenants/${tenantId}/crud/projects`
+  );
+
+  // Map backend 'id' field to 'projectId' for frontend consistency
+  if (response.data) {
+    response.data = response.data.map((project: any) => ({
+      ...project,
+      projectId: project.id,
+    }));
+  }
+
+  return response as ListResponse<Project>;
+}
+
+export async function fetchProject(
+  tenantId: string,
+  projectId: string
+): Promise<SingleResponse<Project>> {
+  validateTenantId(tenantId);
+
+  const response = await makeManagementApiRequest<SingleResponse<any>>(
+    `tenants/${tenantId}/crud/projects/${projectId}`
+  );
+
+  // Map backend 'id' field to 'projectId' for frontend consistency
+  if (response.data) {
+    response.data = {
+      ...response.data,
+      projectId: response.data.id,
+    };
+  }
+
+  return response as SingleResponse<Project>;
+}
+
+export async function createProject(
+  tenantId: string,
+  project: ProjectFormData
+): Promise<SingleResponse<Project>> {
+  validateTenantId(tenantId);
+
+  const response = await makeManagementApiRequest<SingleResponse<any>>(
+    `tenants/${tenantId}/crud/projects`,
+    {
+      method: 'POST',
+      body: JSON.stringify(project),
+    }
+  );
+
+  // Map backend 'id' field to 'projectId' for frontend consistency
+  if (response.data) {
+    response.data = {
+      ...response.data,
+      projectId: response.data.id,
+    };
+  }
+
+  return response as SingleResponse<Project>;
+}
+
+export async function updateProject(
+  tenantId: string,
+  projectId: string,
+  project: ProjectFormData
+): Promise<SingleResponse<Project>> {
+  validateTenantId(tenantId);
+
+  const response = await makeManagementApiRequest<SingleResponse<any>>(
+    `tenants/${tenantId}/crud/projects/${projectId}`,
+    {
+      method: 'PATCH',
+      body: JSON.stringify(project),
+    }
+  );
+  // Map backend 'id' field to 'projectId' for frontend consistency
+  if (response.data) {
+    response.data = {
+      ...response.data,
+      projectId: response.data.id,
+    };
+  }
+
+  return response as SingleResponse<Project>;
+}
+
+export async function deleteProject(tenantId: string, projectId: string): Promise<void> {
+  validateTenantId(tenantId);
+
+  await makeManagementApiRequest<void>(`tenants/${tenantId}/crud/projects/${projectId}`, {
+    method: 'DELETE',
+  });
+}

package/src/lib/api/resource-validation.ts

@@ -0,0 +1,109 @@
+/**
+ * Resource ID validation utility
+ *
+ * Provides centralized validation for all resource IDs (tenant, project, etc.)
+ * Follows the same pattern as backend resourceIdSchema validation
+ */
+
+export class ResourceValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ResourceValidationError';
+  }
+}
+
+export interface ResourceValidationOptions {
+  /** Display name for error messages (e.g., "Tenant ID", "Project ID") */
+  resourceName: string;
+  /** Minimum allowed length (default: 1) */
+  minLength?: number;
+  /** Maximum allowed length (default: 255) */
+  maxLength?: number;
+  /** Custom regex pattern (default: URL-safe pattern) */
+  pattern?: RegExp;
+}
+
+/**
+ * Generic resource ID validation function
+ */
+export function validateResourceId(id: string, options: ResourceValidationOptions): void {
+  const { resourceName, minLength = 1, maxLength = 255, pattern = /^[a-zA-Z0-9_-]+$/ } = options;
+
+  if (!id) {
+    throw new ResourceValidationError(`${resourceName} is required`);
+  }
+
+  if (typeof id !== 'string') {
+    throw new ResourceValidationError(`${resourceName} must be a string`);
+  }
+
+  if (id.trim() !== id) {
+    throw new ResourceValidationError(`${resourceName} cannot have leading/trailing whitespace`);
+  }
+
+  if (!pattern.test(id)) {
+    throw new ResourceValidationError(
+      `${resourceName} contains invalid characters. Only alphanumeric, underscore, and dash allowed`
+    );
+  }
+
+  if (id.length < minLength || id.length > maxLength) {
+    throw new ResourceValidationError(
+      `${resourceName} must be between ${minLength} and ${maxLength} characters`
+    );
+  }
+}
+
+/**
+ * Safe validation that returns boolean instead of throwing
+ */
+export function isValidResourceId(id: string, options: ResourceValidationOptions): boolean {
+  try {
+    validateResourceId(id, options);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// Convenience functions for common resource types
+
+/**
+ * Validates tenant ID with specific constraints
+ */
+export function validateTenantId(tenantId: string): void {
+  validateResourceId(tenantId, {
+    resourceName: 'Tenant ID',
+    maxLength: 50, // Tenant IDs have a shorter max length
+  });
+}
+
+/**
+ * Validates project ID with specific constraints
+ */
+export function validateProjectId(projectId: string): void {
+  validateResourceId(projectId, {
+    resourceName: 'Project ID',
+    maxLength: 255, // Projects can have longer IDs
+  });
+}
+
+/**
+ * Safe tenant ID validation
+ */
+export function isValidTenantId(tenantId: string): boolean {
+  return isValidResourceId(tenantId, {
+    resourceName: 'Tenant ID',
+    maxLength: 50,
+  });
+}
+
+/**
+ * Safe project ID validation
+ */
+export function isValidProjectId(projectId: string): boolean {
+  return isValidResourceId(projectId, {
+    resourceName: 'Project ID',
+    maxLength: 255,
+  });
+}

package/src/lib/api/signoz-sql.ts

@@ -0,0 +1,175 @@
+import axios from 'axios';
+import axiosRetry from 'axios-retry';
+
+// Configure axios retry
+axiosRetry(axios, { 
+  retries: 3,
+  retryDelay: axiosRetry.exponentialDelay,
+});
+
+// Attribute key constants
+const ATTRIBUTE_KEYS = {
+  CONVERSATION_ID: 'conversation.id',
+} as const;
+
+/**
+ * Using for all span attributes (not possible via Trace API)
+ */
+
+export type SpanRow = {
+  trace_id: string;
+  span_id: string;
+  timestamp: string;
+  name: string;
+  parent_span_id: string | null;
+  attributes_string_json: string;
+  attributes_number_json: string;
+  attributes_bool_json: string;
+  resources_string_json: string;
+};
+
+/**
+ * Fetch all span attributes for given trace IDs using optimized SQL query
+ */
+export async function fetchAllSpanAttributes_SQL(
+  conversationId: string,
+  sigNozUrl: string,
+  apiKey: string
+): Promise<
+  Array<{
+    spanId: string;
+    traceId: string;
+    timestamp: string;
+    data: Record<string, any>;
+  }>
+> {
+  console.log(`🔍 DEBUG - fetchAllSpanAttributes_SQL called with:`, {
+    conversationId,
+    sigNozUrl,
+  });
+
+  const results: Array<{
+    spanId: string;
+    traceId: string;
+    timestamp: string;
+    data: Record<string, any>;
+  }> = [];
+
+  const LIMIT = 1000;
+  let offset = 0;
+  const tableName = 'distributed_signoz_index_v3';
+
+  console.log(`🔍 DEBUG - Using table: ${tableName}, LIMIT: ${LIMIT}`);
+
+  const basePayload = {
+    start: new Date('2020-01-01T00:00:00Z').getTime(),
+    end: Date.now(),
+    step: 60,
+    variables: {
+      conversation_id: conversationId,
+      limit: LIMIT,
+      offset: 0,
+    },
+    compositeQuery: {
+      queryType: 'clickhouse_sql',
+      panelType: 'table',
+      chQueries: {
+        A: {
+          query: `
+            SELECT
+              trace_id, span_id, parent_span_id,
+              timestamp,
+              name,
+              toJSONString(attributes_string) AS attributes_string_json,
+              toJSONString(attributes_number) AS attributes_number_json,
+              toJSONString(attributes_bool)   AS attributes_bool_json,
+              toJSONString(resources_string)  AS resources_string_json
+            FROM signoz_traces.${tableName}
+            WHERE attributes_string['${ATTRIBUTE_KEYS.CONVERSATION_ID}'] = {{.conversation_id}}
+              AND timestamp BETWEEN {{.start_datetime}} AND {{.end_datetime}}
+              AND ts_bucket_start BETWEEN {{.start_timestamp}} - 1800 AND {{.end_timestamp}}
+            ORDER BY timestamp DESC
+            LIMIT {{.limit}} OFFSET {{.offset}}
+          `,
+        },
+      },
+    },
+  };
+
+  while (true) {
+    const payload = JSON.parse(JSON.stringify(basePayload));
+    payload.variables.offset = offset;
+    const signozEndpoint = `${sigNozUrl}/api/v4/query_range`;
+    try {
+      const response = await axios.post(signozEndpoint, payload, {
+        headers: {
+          'Content-Type': 'application/json',
+          'SIGNOZ-API-KEY': apiKey,
+        },
+        timeout: 30000,
+      });
+
+      console.log(`🔍 DEBUG - Page response status: ${response.status} ${response.statusText}`);
+
+      const json = response.data;
+      console.log(`🔍 DEBUG - Page response JSON:`, JSON.stringify(json, null, 2));
+
+      const result = json?.data?.result?.[0];
+      let rows: SpanRow[] = [];
+      rows = result.series
+        .map((s: any) => ({
+          trace_id: s.labels?.trace_id,
+          span_id: s.labels?.span_id,
+          parent_span_id: s.labels?.parent_span_id,
+          timestamp: s.labels?.timestamp,
+          name: s.labels?.name,
+          attributes_string_json: s.labels?.attributes_string_json,
+          attributes_number_json: s.labels?.attributes_number_json,
+          attributes_bool_json: s.labels?.attributes_bool_json,
+          resources_string_json: s.labels?.resources_string_json,
+        }))
+        .filter((r: any) => r.trace_id && r.span_id); // Filter out incomplete rows
+
+      if (!rows.length) {
+        break;
+      }
+
+      for (const r of rows) {
+        // Build the span.data bag from the projected JSON maps
+        const attrsString = JSON.parse(r.attributes_string_json || '{}');
+        const attrsNum = JSON.parse(r.attributes_number_json || '{}');
+        const attrsBool = JSON.parse(r.attributes_bool_json || '{}');
+        const resString = JSON.parse(r.resources_string_json || '{}');
+
+        results.push({
+          spanId: r.span_id,
+          traceId: r.trace_id,
+          timestamp: r.timestamp,
+          data: {
+            // Essential span identification fields
+            name: r.name,
+            spanID: r.span_id,
+            traceID: r.trace_id,
+            parentSpanID: r.parent_span_id,
+            // All actual attributes from OpenTelemetry
+            ...attrsString,
+            ...attrsNum,
+            ...attrsBool,
+            ...resString,
+          },
+        });
+      }
+
+      offset += LIMIT;
+      if (rows.length < LIMIT) {
+        console.log(`🔍 DEBUG - Last page (${rows.length} < ${LIMIT}), breaking pagination`);
+        break;
+      }
+    } catch (error) {
+      console.error(`❌ Error fetching spans at offset ${offset}:`, error);
+      break;
+    }
+  }
+
+  return results;
+}