@invect/ui 0.0.1

package/src/api/node-data.api.ts

@@ -0,0 +1,167 @@
+// Node data / testing React Query hooks
+import { useQuery, useMutation } from '@tanstack/react-query';
+import { useApiClient } from '../contexts/ApiContext';
+import { queryKeys, getErrorMessage } from './query-keys';
+import { type SubmitSQLQueryRequest, type SubmitPromptRequest } from '@invect/core/types';
+import { BatchProvider } from '@invect/core/types';
+
+// Available Databases Query
+export function useListQueryDatabases() {
+  const apiClient = useApiClient();
+  return useQuery({
+    queryKey: ['databases', 'available'],
+    queryFn: () => apiClient.getAvailableDatabases(),
+    staleTime: 5 * 60 * 1000, // 5 minutes - databases don't change often
+  });
+}
+
+// Database Query Mutation
+export function useExecuteSqlQuery() {
+  const apiClient = useApiClient();
+  return useMutation({
+    mutationFn: (request: SubmitSQLQueryRequest) => apiClient.executeSqlQuery(request),
+    onError: (error) => {
+      console.error('Error executing query:', getErrorMessage(error));
+    },
+  });
+}
+
+// JS Expression Testing (for data mapper)
+export function useTestJsExpression() {
+  const apiClient = useApiClient();
+
+  return useMutation({
+    mutationFn: (request: { expression: string; context: Record<string, unknown> }) =>
+      apiClient.testJsExpression(request),
+    onError: (error) => {
+      console.error('Error testing JS expression:', getErrorMessage(error));
+    },
+  });
+}
+
+// Data Mapper Testing
+export function useTestMapper() {
+  const apiClient = useApiClient();
+
+  return useMutation({
+    mutationFn: (request: {
+      expression: string;
+      incomingData: Record<string, unknown>;
+      mode?: 'auto' | 'iterate' | 'reshape';
+    }) => apiClient.testMapper(request),
+    onError: (error) => {
+      console.error('Error testing mapper:', getErrorMessage(error));
+    },
+  });
+}
+
+export function useResolveNodeDefinition() {
+  const apiClient = useApiClient();
+
+  return useMutation({
+    mutationFn: (request: {
+      nodeType: string;
+      params: Record<string, unknown>;
+      nodeId?: string | null;
+      flowId?: string | null;
+      changeField?: string;
+      changeValue?: unknown;
+    }) =>
+      apiClient.resolveNodeDefinition(request.nodeType, {
+        nodeId: request.nodeId,
+        flowId: request.flowId,
+        params: request.params,
+        changeField: request.changeField,
+        changeValue: request.changeValue,
+      }),
+  });
+}
+
+/**
+ * Hook for loading dynamic field options via the loadOptions system.
+ */
+export function useLoadFieldOptions(
+  actionId: string,
+  fieldName: string,
+  dependencyValues: Record<string, unknown>,
+  options?: { enabled?: boolean },
+) {
+  const apiClient = useApiClient();
+  const depsKey = JSON.stringify(dependencyValues);
+
+  return useQuery({
+    queryKey: queryKeys.fieldOptions(actionId, fieldName, depsKey),
+    queryFn: () => apiClient.loadFieldOptions(actionId, fieldName, dependencyValues),
+    enabled: options?.enabled ?? true,
+    staleTime: 1000 * 60 * 5, // 5 minutes
+    retry: 1,
+  });
+}
+
+// Models Query
+export function useListAvailableModels(options?: {
+  credentialId?: string;
+  provider?: string;
+  enabled?: boolean;
+}) {
+  const apiClient = useApiClient();
+  return useQuery({
+    queryKey: [...queryKeys.models, options?.credentialId ?? options?.provider ?? 'all'],
+    queryFn: () =>
+      apiClient.getModels({ credentialId: options?.credentialId, provider: options?.provider }),
+    enabled: options?.enabled ?? true,
+    staleTime: 1000 * 60 * 30, // 30 minutes (models don't change often)
+    retry: (failureCount, error) => {
+      if (failureCount >= 2) {
+        return false;
+      }
+      if (error instanceof Error && error.message.includes('4')) {
+        return false;
+      }
+      return true;
+    },
+  });
+}
+
+// Model Testing Mutation
+export function useExecuteModelPrompt() {
+  const apiClient = useApiClient();
+
+  return useMutation({
+    mutationFn: (testData: {
+      prompt: string;
+      model: string;
+      maxTokens?: number;
+      temperature?: number;
+      outputSchema?: string;
+    }) =>
+      apiClient.testModelPrompt({
+        ...testData,
+        provider: BatchProvider.OPENAI,
+        useBatchProcessing: false,
+      } as SubmitPromptRequest),
+    onError: (error) => {
+      console.error('Error testing model prompt:', getErrorMessage(error));
+    },
+  });
+}
+
+// Node Definitions Query
+export function useAvailableNodes() {
+  const apiClient = useApiClient();
+
+  return useQuery({
+    queryKey: queryKeys.availableNodes,
+    queryFn: () => apiClient.getAvailableNodes(),
+    staleTime: 1000 * 60 * 60, // 1 hour - node definitions rarely change
+    retry: (failureCount, error) => {
+      if (failureCount >= 2) {
+        return false;
+      }
+      if (error instanceof Error && error.message.includes('4')) {
+        return false;
+      }
+      return true;
+    },
+  });
+}

package/src/api/query-keys.ts

@@ -0,0 +1,44 @@
+import type { CredentialFilters } from './types';
+
+export const queryKeys = {
+  flows: ['flows'] as const,
+  flow: (id: string) => ['flows', id] as const,
+  flowVersions: (flowId: string) => ['flows', flowId, 'versions'] as const,
+  executions: (flowId: string) => ['executions', flowId] as const,
+  flowRun: (id: string) => ['executions', id] as const,
+  allExecutions: (
+    flowId?: string,
+    status?: string,
+    page?: number,
+    limit?: number,
+    sortBy?: string,
+    sortOrder?: 'asc' | 'desc',
+  ) => ['executions', 'all', flowId, status, page, limit, sortBy, sortOrder] as const,
+  nodeExecutions: (flowRunId: string) => ['node-executions', flowRunId] as const,
+  models: ['models'] as const,
+  reactFlow: (flowId: string, version?: string, flowRunId?: string) =>
+    ['flows', flowId, 'react-flow', version, flowRunId] as const,
+  credentials: (filters?: CredentialFilters) =>
+    ['credentials', filters ? JSON.stringify(filters) : 'all'] as const,
+  credential: (id: string) => ['credentials', id] as const,
+  credentialUsage: (id: string) => ['credentials', id, 'usage'] as const,
+  agentTools: ['agent', 'tools'] as const,
+  fieldOptions: (actionId: string, fieldName: string, deps: string) =>
+    ['field-options', actionId, fieldName, deps] as const,
+  availableNodes: ['available-nodes'] as const,
+  triggers: (flowId: string) => ['flows', flowId, 'triggers'] as const,
+  trigger: (triggerId: string) => ['triggers', triggerId] as const,
+  dashboardStats: ['dashboard', 'stats'] as const,
+};
+
+// Enhanced error handling
+export function getErrorMessage(error: unknown): string {
+  // Import ValidationError dynamically to avoid circular deps
+  if (error instanceof Error && error.name === 'ValidationError') {
+    return error.message;
+  }
+  if (error instanceof Error) {
+    return error.message;
+  }
+  return 'An unexpected error occurred';
+}

package/src/api/triggers.api.ts

@@ -0,0 +1,120 @@
+// Trigger-related React Query hooks
+import { useQuery, useMutation, useQueryClient } from '@tanstack/react-query';
+import { useApiClient } from '../contexts/ApiContext';
+import { queryKeys, getErrorMessage } from './query-keys';
+import type { CreateTriggerInput, UpdateTriggerInput } from './types';
+
+/**
+ * Fetch all trigger registrations for a flow.
+ */
+export function useFlowTriggers(flowId: string) {
+  const apiClient = useApiClient();
+
+  return useQuery({
+    queryKey: queryKeys.triggers(flowId),
+    queryFn: () => apiClient.listTriggersForFlow(flowId),
+    enabled: !!flowId,
+    staleTime: 1000 * 30, // 30 seconds
+  });
+}
+
+/**
+ * Fetch a single trigger by ID.
+ */
+export function useTrigger(triggerId: string) {
+  const apiClient = useApiClient();
+
+  return useQuery({
+    queryKey: queryKeys.trigger(triggerId),
+    queryFn: () => apiClient.getTrigger(triggerId),
+    enabled: !!triggerId,
+  });
+}
+
+/**
+ * Create a trigger registration.
+ */
+export function useCreateTrigger() {
+  const apiClient = useApiClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ flowId, input }: { flowId: string; input: CreateTriggerInput }) =>
+      apiClient.createTrigger(flowId, input),
+    onSuccess: (_, { flowId }) => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.triggers(flowId) });
+    },
+    onError: (error) => {
+      console.error('Error creating trigger:', getErrorMessage(error));
+    },
+  });
+}
+
+/**
+ * Update a trigger registration.
+ */
+export function useUpdateTrigger() {
+  const apiClient = useApiClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({
+      triggerId,
+      input,
+    }: {
+      triggerId: string;
+      flowId: string;
+      input: UpdateTriggerInput;
+    }) => apiClient.updateTrigger(triggerId, input),
+    onSuccess: (_, { triggerId, flowId }) => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.trigger(triggerId) });
+      queryClient.invalidateQueries({ queryKey: queryKeys.triggers(flowId) });
+    },
+    onError: (error) => {
+      console.error('Error updating trigger:', getErrorMessage(error));
+    },
+  });
+}
+
+/**
+ * Delete a trigger registration.
+ */
+export function useDeleteTrigger() {
+  const apiClient = useApiClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({ triggerId }: { triggerId: string; flowId: string }) =>
+      apiClient.deleteTrigger(triggerId),
+    onSuccess: (_, { flowId }) => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.triggers(flowId) });
+    },
+    onError: (error) => {
+      console.error('Error deleting trigger:', getErrorMessage(error));
+    },
+  });
+}
+
+/**
+ * Sync trigger registrations from the flow definition.
+ */
+export function useSyncTriggers() {
+  const apiClient = useApiClient();
+  const queryClient = useQueryClient();
+
+  return useMutation({
+    mutationFn: ({
+      flowId,
+      definition,
+    }: {
+      flowId: string;
+      definition: { nodes: Array<{ id: string; type: string; params?: Record<string, unknown> }> };
+    }) => apiClient.syncTriggersForFlow(flowId, definition),
+    onSuccess: (_, { flowId }) => {
+      queryClient.invalidateQueries({ queryKey: queryKeys.triggers(flowId) });
+    },
+    onError: (error) => {
+      console.error('Error syncing triggers:', getErrorMessage(error));
+    },
+  });
+}

package/src/api/types.ts

@@ -0,0 +1,212 @@
+// API client types for communicating with the Invect backend
+
+import type { FlowValidationResult } from '@invect/core/types';
+import type { NodeDefinition } from '../types/node-definition.types';
+
+// Re-export core types used throughout the API layer
+export type {
+  Flow,
+  FlowVersion,
+  FlowRun,
+  NodeExecution,
+  FlowEdge,
+  CreateFlowRequest,
+  CreateFlowVersionRequest,
+  FlowValidationResult,
+  FlowValidationError,
+  PaginatedResponse,
+  SubmitPromptRequest,
+  SubmitSQLQueryRequest,
+  SQLQueryResult,
+  QueryOptions,
+  InvectDatabaseConfig,
+  InvectDefinition,
+  Model,
+  ReactFlowData,
+  AgentToolDefinition,
+  NodeConfigUpdateResponse,
+  DashboardStats,
+  FlowRunResult,
+  FlowInputs,
+  ExecuteFlowOptions,
+  UpdateFlowInput,
+} from '@invect/core/types';
+
+export type { NodeDefinition };
+
+// Custom error class for validation errors
+export class ValidationError extends Error {
+  public validationResult: FlowValidationResult;
+
+  constructor(message: string, validationResult: FlowValidationResult) {
+    super(message);
+    this.name = 'ValidationError';
+    this.validationResult = validationResult;
+  }
+}
+
+// Options for React Flow data endpoint
+export interface ReactFlowDataOptions {
+  /** Flow version to render, or 'latest' for most recent version */
+  version?: string | 'latest';
+  /** Flow run ID to include execution status */
+  flowRunId?: string;
+}
+
+export type CredentialAuthType =
+  | 'apiKey'
+  | 'bearer'
+  | 'basic'
+  | 'oauth2'
+  | 'custom'
+  | 'awsSigV4'
+  | 'jwt'
+  | 'connectionString';
+
+export type CredentialType = 'http-api' | 'database' | 'llm';
+
+export interface CredentialConfig {
+  apiKey?: string;
+  location?: 'header' | 'query';
+  paramName?: string;
+  token?: string;
+  username?: string;
+  password?: string;
+  accessToken?: string;
+  refreshToken?: string;
+  tokenType?: string;
+  scope?: string;
+  clientId?: string;
+  clientSecret?: string;
+  /** OAuth2 provider ID (e.g., "google", "github") */
+  oauth2Provider?: string;
+  /** Authorization URL (for custom OAuth2 providers) */
+  authorizationUrl?: string;
+  /** Token URL (for custom OAuth2 providers) */
+  tokenUrl?: string;
+  headers?: Record<string, string>;
+  accessKeyId?: string;
+  secretAccessKey?: string;
+  region?: string;
+  service?: string;
+  algorithm?: string;
+  secret?: string;
+  connectionString?: string;
+  expiresAt?: string;
+  apiUrl?: string;
+  baseUrl?: string;
+  endpoint?: string;
+  [key: string]: unknown;
+}
+
+// OAuth2 Provider Definition
+export interface OAuth2ProviderDefinition {
+  id: string;
+  name: string;
+  description: string;
+  icon?: string;
+  authorizationUrl: string;
+  tokenUrl: string;
+  defaultScopes: string[];
+  additionalAuthParams?: Record<string, string>;
+  supportsRefresh: boolean;
+  docsUrl?: string;
+  category: 'google' | 'microsoft' | 'github' | 'slack' | 'other';
+}
+
+// OAuth2 Start Flow Result
+export interface OAuth2StartResult {
+  authorizationUrl: string;
+  state: string;
+}
+
+export interface Credential {
+  id: string;
+  name: string;
+  type: CredentialType;
+  authType: CredentialAuthType;
+  config?: CredentialConfig;
+  description?: string;
+  isActive: boolean;
+  userId: string;
+  workspaceId?: string;
+  isShared: boolean;
+  metadata?: Record<string, unknown>;
+  lastUsedAt?: string;
+  expiresAt?: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CreateCredentialInput {
+  name: string;
+  type: CredentialType;
+  authType: CredentialAuthType;
+  config: CredentialConfig;
+  description?: string;
+  workspaceId?: string;
+  isShared?: boolean;
+  metadata?: Record<string, unknown>;
+  expiresAt?: string;
+}
+
+export interface UpdateCredentialInput {
+  name?: string;
+  type?: CredentialType;
+  authType?: CredentialAuthType;
+  config?: CredentialConfig;
+  description?: string;
+  isActive?: boolean;
+  isShared?: boolean;
+  metadata?: Record<string, unknown>;
+  expiresAt?: string;
+}
+
+export interface CredentialFilters {
+  type?: CredentialType;
+  authType?: CredentialAuthType;
+  isActive?: boolean;
+  includeShared?: boolean;
+}
+
+export interface CredentialUsage {
+  flowsCount: number;
+  nodesCount: number;
+  lastUsedAt: string | null;
+}
+
+// Trigger Types
+export type TriggerType = 'manual' | 'webhook' | 'cron';
+
+export interface FlowTriggerRegistration {
+  id: string;
+  flowId: string;
+  nodeId: string;
+  type: TriggerType;
+  isEnabled: boolean;
+  webhookPath?: string | null;
+  webhookSecret?: string | null;
+  cronExpression?: string | null;
+  cronTimezone?: string | null;
+  lastTriggeredAt?: string | null;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface CreateTriggerInput {
+  nodeId: string;
+  type: TriggerType;
+  isEnabled?: boolean;
+  webhookPath?: string;
+  webhookSecret?: string;
+  cronExpression?: string;
+  cronTimezone?: string;
+}
+
+export interface UpdateTriggerInput {
+  isEnabled?: boolean;
+  webhookPath?: string;
+  webhookSecret?: string;
+  cronExpression?: string;
+  cronTimezone?: string;
+}