@robosystems/client 0.2.48 → 0.3.0

package/sdk-extensions/config.js

@@ -1,152 +0,0 @@
-'use client';
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.setSDKExtensionsConfig = setSDKExtensionsConfig;
-exports.getSDKExtensionsConfig = getSDKExtensionsConfig;
-exports.resetSDKExtensionsConfig = resetSDKExtensionsConfig;
-exports.extractJWTFromHeader = extractJWTFromHeader;
-exports.isValidJWT = isValidJWT;
-exports.extractTokenFromSDKClient = extractTokenFromSDKClient;
-exports.configureWithJWT = configureWithJWT;
-exports.getEnvironmentConfig = getEnvironmentConfig;
-// Default configuration
-const defaultConfig = {
-    baseUrl: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
-    credentials: 'include',
-    token: undefined, // Will be set from environment or programmatically
-    timeout: 30000,
-    maxRetries: 3,
-    retryDelay: 1000,
-};
-// Global configuration singleton
-let globalConfig = { ...defaultConfig };
-/**
- * Set global configuration for SDK extensions
- * @param config Partial configuration to merge with defaults
- */
-function setSDKExtensionsConfig(config) {
-    globalConfig = {
-        ...globalConfig,
-        ...config,
-    };
-}
-/**
- * Get current SDK extensions configuration
- * @returns Current configuration
- */
-function getSDKExtensionsConfig() {
-    return { ...globalConfig };
-}
-/**
- * Reset configuration to defaults
- */
-function resetSDKExtensionsConfig() {
-    globalConfig = { ...defaultConfig };
-}
-/**
- * Extract JWT token from Authorization header
- * @param authHeader Authorization header value
- * @returns JWT token or undefined
- */
-function extractJWTFromHeader(authHeader) {
-    if (!authHeader)
-        return undefined;
-    const headerValue = Array.isArray(authHeader) ? authHeader[0] : authHeader;
-    if (typeof headerValue === 'string' && headerValue.startsWith('Bearer ')) {
-        return headerValue.substring(7);
-    }
-    return undefined;
-}
-/**
- * Validate JWT token format (basic validation)
- * @param token JWT token to validate
- * @returns true if token appears valid
- */
-function isValidJWT(token) {
-    if (!token || typeof token !== 'string')
-        return false;
-    try {
-        const parts = token.split('.');
-        // JWT should have exactly 3 parts: header.payload.signature
-        return parts.length === 3 && parts.every((part) => part.length > 0);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * Extract JWT token from SDK client configuration
- * Centralizes the logic for extracting tokens from the client
- * @returns JWT token or undefined
- */
-function extractTokenFromSDKClient() {
-    // Import dynamically to avoid circular dependency
-    const { client } = require('../sdk/client.gen');
-    const sdkConfig = getSDKExtensionsConfig();
-    // Priority 1: Use explicitly configured token
-    if (sdkConfig.token) {
-        return sdkConfig.token;
-    }
-    // Priority 2: Extract from SDK client headers
-    const clientConfig = client.getConfig();
-    if (clientConfig.headers) {
-        if (typeof clientConfig.headers === 'object' && !Array.isArray(clientConfig.headers)) {
-            const headers = clientConfig.headers;
-            const token = extractJWTFromHeader(headers.Authorization);
-            if (isValidJWT(token)) {
-                return token;
-            }
-        }
-    }
-    return undefined;
-}
-/**
- * Configure SDK extensions for JWT authentication
- * @param token JWT token
- * @param config Additional configuration options
- */
-function configureWithJWT(token, config) {
-    if (!isValidJWT(token)) {
-        console.warn('Warning: Provided JWT token does not appear to be valid');
-    }
-    setSDKExtensionsConfig({
-        ...config,
-        token,
-        // When using JWT, typically don't need cookies
-        credentials: config?.credentials || 'omit',
-    });
-}
-/**
- * Get configuration for a specific environment
- * @param env Environment name (production, staging, development)
- * @returns Environment-specific configuration
- */
-function getEnvironmentConfig(env = 'development') {
-    const baseConfigs = {
-        production: {
-            baseUrl: process.env.NEXT_PUBLIC_API_URL || 'https://api.robosystems.ai',
-            credentials: 'include',
-            timeout: 60000,
-            maxRetries: 5,
-            retryDelay: 2000,
-        },
-        staging: {
-            baseUrl: process.env.NEXT_PUBLIC_API_URL || 'https://staging-api.robosystems.ai',
-            credentials: 'include',
-            timeout: 45000,
-            maxRetries: 3,
-            retryDelay: 1500,
-        },
-        development: {
-            baseUrl: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
-            credentials: 'include',
-            timeout: 30000,
-            maxRetries: 3,
-            retryDelay: 1000,
-        },
-    };
-    return {
-        ...defaultConfig,
-        ...baseConfigs[env],
-    };
-}

package/sdk-extensions/config.test.ts

@@ -1,199 +0,0 @@
-import { beforeEach, describe, expect, it } from 'vitest'
-import {
-  configureWithJWT,
-  extractJWTFromHeader,
-  getEnvironmentConfig,
-  getSDKExtensionsConfig,
-  isValidJWT,
-  resetSDKExtensionsConfig,
-  setSDKExtensionsConfig,
-} from './config'
-
-describe('config', () => {
-  beforeEach(() => {
-    resetSDKExtensionsConfig()
-  })
-
-  describe('setSDKExtensionsConfig / getSDKExtensionsConfig', () => {
-    it('should set and get configuration', () => {
-      setSDKExtensionsConfig({
-        baseUrl: 'https://api.example.com',
-        token: 'test-token',
-      })
-
-      const config = getSDKExtensionsConfig()
-      expect(config.baseUrl).toBe('https://api.example.com')
-      expect(config.token).toBe('test-token')
-    })
-
-    it('should merge configuration with defaults', () => {
-      setSDKExtensionsConfig({ token: 'new-token' })
-
-      const config = getSDKExtensionsConfig()
-      expect(config.token).toBe('new-token')
-      expect(config.credentials).toBe('include') // Default value
-    })
-
-    it('should allow partial updates', () => {
-      setSDKExtensionsConfig({ baseUrl: 'https://first.com' })
-      setSDKExtensionsConfig({ token: 'token-123' })
-
-      const config = getSDKExtensionsConfig()
-      expect(config.baseUrl).toBe('https://first.com')
-      expect(config.token).toBe('token-123')
-    })
-  })
-
-  describe('resetSDKExtensionsConfig', () => {
-    it('should reset configuration to defaults', () => {
-      setSDKExtensionsConfig({
-        baseUrl: 'https://custom.com',
-        token: 'custom-token',
-      })
-
-      resetSDKExtensionsConfig()
-
-      const config = getSDKExtensionsConfig()
-      expect(config.baseUrl).toBe('http://localhost:8000')
-      expect(config.token).toBeUndefined()
-      expect(config.credentials).toBe('include')
-    })
-  })
-
-  describe('extractJWTFromHeader', () => {
-    it('should extract JWT from Bearer token', () => {
-      const token = extractJWTFromHeader('Bearer abc.def.ghi')
-      expect(token).toBe('abc.def.ghi')
-    })
-
-    it('should extract JWT from array of headers', () => {
-      const token = extractJWTFromHeader(['Bearer abc.def.ghi'])
-      expect(token).toBe('abc.def.ghi')
-    })
-
-    it('should return undefined for non-Bearer tokens', () => {
-      const token = extractJWTFromHeader('Basic abc123')
-      expect(token).toBeUndefined()
-    })
-
-    it('should return undefined for undefined header', () => {
-      const token = extractJWTFromHeader(undefined)
-      expect(token).toBeUndefined()
-    })
-
-    it('should return undefined for empty string', () => {
-      const token = extractJWTFromHeader('')
-      expect(token).toBeUndefined()
-    })
-
-    it('should handle Bearer without space', () => {
-      const token = extractJWTFromHeader('Bearerabc.def.ghi')
-      expect(token).toBeUndefined()
-    })
-  })
-
-  describe('isValidJWT', () => {
-    it('should validate a proper JWT format', () => {
-      const valid = isValidJWT('eyJhbGc.eyJzdWI.SflKxw')
-      expect(valid).toBe(true)
-    })
-
-    it('should reject tokens with fewer than 3 parts', () => {
-      const valid = isValidJWT('abc.def')
-      expect(valid).toBe(false)
-    })
-
-    it('should reject tokens with more than 3 parts', () => {
-      const valid = isValidJWT('a.b.c.d')
-      expect(valid).toBe(false)
-    })
-
-    it('should reject tokens with empty parts', () => {
-      const valid = isValidJWT('a..c')
-      expect(valid).toBe(false)
-    })
-
-    it('should reject undefined', () => {
-      const valid = isValidJWT(undefined)
-      expect(valid).toBe(false)
-    })
-
-    it('should reject empty string', () => {
-      const valid = isValidJWT('')
-      expect(valid).toBe(false)
-    })
-
-    it('should reject non-string values', () => {
-      const valid = isValidJWT(123 as any)
-      expect(valid).toBe(false)
-    })
-
-    it('should accept JWT with long parts', () => {
-      const longJWT =
-        'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJzdWIiOiIxMjM0NTY3ODkwIiwibmFtZSI6IkpvaG4gRG9lIiwiaWF0IjoxNTE2MjM5MDIyfQ.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c'
-      const valid = isValidJWT(longJWT)
-      expect(valid).toBe(true)
-    })
-  })
-
-  describe('configureWithJWT', () => {
-    it('should configure SDK with JWT token', () => {
-      configureWithJWT('abc.def.ghi')
-
-      const config = getSDKExtensionsConfig()
-      expect(config.token).toBe('abc.def.ghi')
-      expect(config.credentials).toBe('omit') // Default when using JWT
-    })
-
-    it('should allow overriding credentials', () => {
-      configureWithJWT('abc.def.ghi', { credentials: 'include' })
-
-      const config = getSDKExtensionsConfig()
-      expect(config.credentials).toBe('include')
-    })
-
-    it('should merge additional config options', () => {
-      configureWithJWT('abc.def.ghi', {
-        baseUrl: 'https://custom.com',
-        timeout: 60000,
-      })
-
-      const config = getSDKExtensionsConfig()
-      expect(config.token).toBe('abc.def.ghi')
-      expect(config.baseUrl).toBe('https://custom.com')
-      expect(config.timeout).toBe(60000)
-    })
-  })
-
-  describe('getEnvironmentConfig', () => {
-    it('should return development config by default', () => {
-      const config = getEnvironmentConfig()
-      expect(config.baseUrl).toBe('http://localhost:8000')
-      expect(config.credentials).toBe('include')
-      expect(config.timeout).toBe(30000)
-      expect(config.maxRetries).toBe(3)
-    })
-
-    it('should return production config', () => {
-      const config = getEnvironmentConfig('production')
-      expect(config.baseUrl).toBe('https://api.robosystems.ai')
-      expect(config.timeout).toBe(60000)
-      expect(config.maxRetries).toBe(5)
-      expect(config.retryDelay).toBe(2000)
-    })
-
-    it('should return staging config', () => {
-      const config = getEnvironmentConfig('staging')
-      expect(config.baseUrl).toBe('https://staging-api.robosystems.ai')
-      expect(config.timeout).toBe(45000)
-      expect(config.maxRetries).toBe(3)
-      expect(config.retryDelay).toBe(1500)
-    })
-
-    it('should return development config explicitly', () => {
-      const config = getEnvironmentConfig('development')
-      expect(config.baseUrl).toBe('http://localhost:8000')
-      expect(config.timeout).toBe(30000)
-    })
-  })
-})

package/sdk-extensions/config.ts

@@ -1,175 +0,0 @@
-'use client'
-
-/**
- * Configuration for SDK extensions
- * Provides centralized configuration for CORS, credentials, and other settings
- */
-
-export interface SDKExtensionsConfig {
-  baseUrl?: string
-  credentials?: 'include' | 'same-origin' | 'omit'
-  headers?: Record<string, string>
-  token?: string // JWT token for authentication
-  timeout?: number
-  maxRetries?: number
-  retryDelay?: number
-}
-
-// Default configuration
-const defaultConfig: SDKExtensionsConfig = {
-  baseUrl: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
-  credentials: 'include',
-  token: undefined, // Will be set from environment or programmatically
-  timeout: 30000,
-  maxRetries: 3,
-  retryDelay: 1000,
-}
-
-// Global configuration singleton
-let globalConfig: SDKExtensionsConfig = { ...defaultConfig }
-
-/**
- * Set global configuration for SDK extensions
- * @param config Partial configuration to merge with defaults
- */
-export function setSDKExtensionsConfig(config: Partial<SDKExtensionsConfig>) {
-  globalConfig = {
-    ...globalConfig,
-    ...config,
-  }
-}
-
-/**
- * Get current SDK extensions configuration
- * @returns Current configuration
- */
-export function getSDKExtensionsConfig(): SDKExtensionsConfig {
-  return { ...globalConfig }
-}
-
-/**
- * Reset configuration to defaults
- */
-export function resetSDKExtensionsConfig() {
-  globalConfig = { ...defaultConfig }
-}
-
-/**
- * Extract JWT token from Authorization header
- * @param authHeader Authorization header value
- * @returns JWT token or undefined
- */
-export function extractJWTFromHeader(authHeader?: string | string[]): string | undefined {
-  if (!authHeader) return undefined
-
-  const headerValue = Array.isArray(authHeader) ? authHeader[0] : authHeader
-  if (typeof headerValue === 'string' && headerValue.startsWith('Bearer ')) {
-    return headerValue.substring(7)
-  }
-
-  return undefined
-}
-
-/**
- * Validate JWT token format (basic validation)
- * @param token JWT token to validate
- * @returns true if token appears valid
- */
-export function isValidJWT(token: string | undefined): boolean {
-  if (!token || typeof token !== 'string') return false
-
-  try {
-    const parts = token.split('.')
-    // JWT should have exactly 3 parts: header.payload.signature
-    return parts.length === 3 && parts.every((part) => part.length > 0)
-  } catch {
-    return false
-  }
-}
-
-/**
- * Extract JWT token from SDK client configuration
- * Centralizes the logic for extracting tokens from the client
- * @returns JWT token or undefined
- */
-export function extractTokenFromSDKClient(): string | undefined {
-  // Import dynamically to avoid circular dependency
-  const { client } = require('../sdk/client.gen')
-
-  const sdkConfig = getSDKExtensionsConfig()
-
-  // Priority 1: Use explicitly configured token
-  if (sdkConfig.token) {
-    return sdkConfig.token
-  }
-
-  // Priority 2: Extract from SDK client headers
-  const clientConfig = client.getConfig()
-  if (clientConfig.headers) {
-    if (typeof clientConfig.headers === 'object' && !Array.isArray(clientConfig.headers)) {
-      const headers = clientConfig.headers as Record<string, unknown>
-      const token = extractJWTFromHeader(headers.Authorization as string | undefined)
-      if (isValidJWT(token)) {
-        return token
-      }
-    }
-  }
-
-  return undefined
-}
-
-/**
- * Configure SDK extensions for JWT authentication
- * @param token JWT token
- * @param config Additional configuration options
- */
-export function configureWithJWT(token: string, config?: Partial<SDKExtensionsConfig>) {
-  if (!isValidJWT(token)) {
-    console.warn('Warning: Provided JWT token does not appear to be valid')
-  }
-
-  setSDKExtensionsConfig({
-    ...config,
-    token,
-    // When using JWT, typically don't need cookies
-    credentials: config?.credentials || 'omit',
-  })
-}
-
-/**
- * Get configuration for a specific environment
- * @param env Environment name (production, staging, development)
- * @returns Environment-specific configuration
- */
-export function getEnvironmentConfig(
-  env: 'production' | 'staging' | 'development' = 'development'
-): SDKExtensionsConfig {
-  const baseConfigs: Record<string, Partial<SDKExtensionsConfig>> = {
-    production: {
-      baseUrl: process.env.NEXT_PUBLIC_API_URL || 'https://api.robosystems.ai',
-      credentials: 'include',
-      timeout: 60000,
-      maxRetries: 5,
-      retryDelay: 2000,
-    },
-    staging: {
-      baseUrl: process.env.NEXT_PUBLIC_API_URL || 'https://staging-api.robosystems.ai',
-      credentials: 'include',
-      timeout: 45000,
-      maxRetries: 3,
-      retryDelay: 1500,
-    },
-    development: {
-      baseUrl: process.env.NEXT_PUBLIC_API_URL || 'http://localhost:8000',
-      credentials: 'include',
-      timeout: 30000,
-      maxRetries: 3,
-      retryDelay: 1000,
-    },
-  }
-
-  return {
-    ...defaultConfig,
-    ...baseConfigs[env],
-  }
-}

package/sdk-extensions/hooks.d.ts

@@ -1,110 +0,0 @@
-import type { OperationProgress, OperationResult } from './OperationClient';
-import { OperationClient } from './OperationClient';
-import type { QueryOptions, QueryResult } from './QueryClient';
-import { QueryClient } from './QueryClient';
-/**
- * Hook for executing Cypher queries with loading states and error handling
- *
- * @example
- * ```tsx
- * const { execute, loading, error, data } = useQuery('graph_123')
- *
- * const handleSearch = async () => {
- *   const result = await execute('MATCH (n:Company) RETURN n LIMIT 10')
- *   console.log(result.data)
- * }
- * ```
- */
-export declare function useQuery(graphId: string): {
-    execute: (query: string, parameters?: Record<string, any>, options?: QueryOptions) => Promise<QueryResult | null>;
-    query: (cypher: string, parameters?: Record<string, any>) => Promise<any[]>;
-    loading: boolean;
-    error: Error;
-    data: QueryResult;
-    queuePosition: number;
-};
-/**
- * Hook for streaming large query results
- *
- * @example
- * ```tsx
- * const { stream, isStreaming, error, cancel } = useStreamingQuery('graph_123')
- *
- * const handleStream = async () => {
- *   const iterator = stream('MATCH (n) RETURN n')
- *   for await (const batch of iterator) {
- *     console.log('Received batch:', batch)
- *   }
- * }
- * ```
- */
-export declare function useStreamingQuery(graphId: string): {
-    stream: (query: string, parameters?: Record<string, any>, chunkSize?: number) => AsyncIterableIterator<any[]>;
-    isStreaming: boolean;
-    error: Error;
-    rowsReceived: number;
-    cancel: () => void;
-};
-/**
- * Hook for monitoring long-running operations
- *
- * @example
- * ```tsx
- * const { monitor, status, progress, error, result } = useOperation<BackupResult>()
- *
- * const handleBackup = async () => {
- *   const { operation_id } = await createBackup({ ... })
- *   const result = await monitor(operation_id)
- *   console.log('Backup completed:', result)
- * }
- * ```
- */
-export declare function useOperation<T = any>(operationId?: string): {
-    monitor: (id: string, timeout?: number) => Promise<OperationResult<T> | null>;
-    cancel: (id: string) => Promise<void>;
-    status: "error" | "idle" | "running" | "completed";
-    progress: OperationProgress;
-    error: Error;
-    result: OperationResult<T>;
-};
-/**
- * Hook for monitoring multiple operations concurrently
- *
- * @example
- * ```tsx
- * const { monitorAll, results, allCompleted, hasErrors } = useMultipleOperations()
- *
- * const handleMultiple = async () => {
- *   const operations = await Promise.all([
- *     createBackup(...),
- *     createExport(...),
- *   ])
- *
- *   const results = await monitorAll(operations.map(op => op.operation_id))
- * }
- * ```
- */
-export declare function useMultipleOperations<T = any>(): {
-    monitorAll: (operationIds: string[]) => Promise<Map<string, OperationResult<T>>>;
-    results: Map<string, OperationResult<T>>;
-    errors: Map<string, Error>;
-    loading: boolean;
-    allCompleted: boolean;
-    hasErrors: boolean;
-};
-/**
- * Hook that provides access to all SDK extension clients
- * Useful when you need direct access to the underlying clients
- *
- * @example
- * ```tsx
- * const clients = useSDKClients()
- *
- * // Direct access to clients
- * const result = await clients.query.query('graph_123', 'MATCH (n) RETURN n')
- * ```
- */
-export declare function useSDKClients(): {
-    query: QueryClient | null;
-    operations: OperationClient | null;
-};