@object-ui/data-objectstack 0.3.0 → 0.5.0

package/src/index.ts

@@ -9,6 +9,49 @@
 import { ObjectStackClient, type QueryOptions as ObjectStackQueryOptions } from '@objectstack/client';
 import type { DataSource, QueryParams, QueryResult } from '@object-ui/types';
 import { convertFiltersToAST } from '@object-ui/core';
+import { MetadataCache } from './cache/MetadataCache';
+import {
+  ObjectStackError,
+  MetadataNotFoundError,
+  BulkOperationError,
+  ConnectionError,
+  createErrorFromResponse,
+} from './errors';
+
+/**
+ * Connection state for monitoring
+ */
+export type ConnectionState = 'disconnected' | 'connecting' | 'connected' | 'reconnecting' | 'error';
+
+/**
+ * Connection state change event
+ */
+export interface ConnectionStateEvent {
+  state: ConnectionState;
+  timestamp: number;
+  error?: Error;
+}
+
+/**
+ * Batch operation progress event
+ */
+export interface BatchProgressEvent {
+  operation: 'create' | 'update' | 'delete';
+  total: number;
+  completed: number;
+  failed: number;
+  percentage: number;
+}
+
+/**
+ * Event listener type for connection state changes
+ */
+export type ConnectionStateListener = (event: ConnectionStateEvent) => void;
+
+/**
+ * Event listener type for batch operation progress
+ */
+export type BatchProgressListener = (event: BatchProgressEvent) => void;
 
 /**
  * ObjectStack Data Source Adapter
@@ -23,7 +66,14 @@ import { convertFiltersToAST } from '@object-ui/core';
  * 
  * const dataSource = new ObjectStackAdapter({
  *   baseUrl: 'https://api.example.com',
- *   token: 'your-api-token'
+ *   token: 'your-api-token',
+ *   autoReconnect: true,
+ *   maxReconnectAttempts: 5
+ * });
+ * 
+ * // Monitor connection state
+ * dataSource.onConnectionStateChange((event) => {
+ *   console.log('Connection state:', event.state);
  * });
  * 
  * const users = await dataSource.find('users', {
@@ -32,16 +82,35 @@ import { convertFiltersToAST } from '@object-ui/core';
  * });
  * ```
  */
-export class ObjectStackAdapter<T = any> implements DataSource<T> {
+export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
   private client: ObjectStackClient;
   private connected: boolean = false;
+  private metadataCache: MetadataCache;
+  private connectionState: ConnectionState = 'disconnected';
+  private connectionStateListeners: ConnectionStateListener[] = [];
+  private batchProgressListeners: BatchProgressListener[] = [];
+  private autoReconnect: boolean;
+  private maxReconnectAttempts: number;
+  private reconnectDelay: number;
+  private reconnectAttempts: number = 0;
 
   constructor(config: {
     baseUrl: string;
     token?: string;
     fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+    cache?: {
+      maxSize?: number;
+      ttl?: number;
+    };
+    autoReconnect?: boolean;
+    maxReconnectAttempts?: number;
+    reconnectDelay?: number;
   }) {
     this.client = new ObjectStackClient(config);
+    this.metadataCache = new MetadataCache(config.cache);
+    this.autoReconnect = config.autoReconnect ?? true;
+    this.maxReconnectAttempts = config.maxReconnectAttempts ?? 3;
+    this.reconnectDelay = config.reconnectDelay ?? 1000;
   }
 
   /**
@@ -50,11 +119,127 @@ export class ObjectStackAdapter<T = any> implements DataSource<T> {
    */
   async connect(): Promise<void> {
     if (!this.connected) {
-      await this.client.connect();
-      this.connected = true;
+      this.setConnectionState('connecting');
+      
+      try {
+        await this.client.connect();
+        this.connected = true;
+        this.reconnectAttempts = 0;
+        this.setConnectionState('connected');
+      } catch (error: unknown) {
+        const errorMessage = error instanceof Error ? error.message : 'Failed to connect to ObjectStack server';
+        const connectionError = new ConnectionError(
+          errorMessage,
+          undefined,
+          { originalError: error }
+        );
+        
+        this.setConnectionState('error', connectionError);
+        
+        // Attempt auto-reconnect if enabled
+        if (this.autoReconnect && this.reconnectAttempts < this.maxReconnectAttempts) {
+          await this.attemptReconnect();
+        } else {
+          throw connectionError;
+        }
+      }
     }
   }
 
+  /**
+   * Attempt to reconnect to the server with exponential backoff
+   */
+  private async attemptReconnect(): Promise<void> {
+    this.reconnectAttempts++;
+    this.setConnectionState('reconnecting');
+    
+    // Exponential backoff: delay * 2^(attempts-1)
+    const delay = this.reconnectDelay * Math.pow(2, this.reconnectAttempts - 1);
+    
+    await new Promise(resolve => setTimeout(resolve, delay));
+    
+    this.connected = false;
+    await this.connect();
+  }
+
+  /**
+   * Get the current connection state
+   */
+  getConnectionState(): ConnectionState {
+    return this.connectionState;
+  }
+
+  /**
+   * Check if the adapter is currently connected
+   */
+  isConnected(): boolean {
+    return this.connected && this.connectionState === 'connected';
+  }
+
+  /**
+   * Register a listener for connection state changes
+   */
+  onConnectionStateChange(listener: ConnectionStateListener): () => void {
+    this.connectionStateListeners.push(listener);
+    
+    // Return unsubscribe function
+    return () => {
+      const index = this.connectionStateListeners.indexOf(listener);
+      if (index > -1) {
+        this.connectionStateListeners.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Register a listener for batch operation progress
+   */
+  onBatchProgress(listener: BatchProgressListener): () => void {
+    this.batchProgressListeners.push(listener);
+    
+    // Return unsubscribe function
+    return () => {
+      const index = this.batchProgressListeners.indexOf(listener);
+      if (index > -1) {
+        this.batchProgressListeners.splice(index, 1);
+      }
+    };
+  }
+
+  /**
+   * Set connection state and notify listeners
+   */
+  private setConnectionState(state: ConnectionState, error?: Error): void {
+    this.connectionState = state;
+    
+    const event: ConnectionStateEvent = {
+      state,
+      timestamp: Date.now(),
+      error,
+    };
+    
+    this.connectionStateListeners.forEach(listener => {
+      try {
+        listener(event);
+      } catch (err) {
+        console.error('Error in connection state listener:', err);
+      }
+    });
+  }
+
+  /**
+   * Emit batch progress event to listeners
+   */
+  private emitBatchProgress(event: BatchProgressEvent): void {
+    this.batchProgressListeners.forEach(listener => {
+      try {
+        listener(event);
+      } catch (err) {
+        console.error('Error in batch progress listener:', err);
+      }
+    });
+  }
+
   /**
    * Find multiple records with query parameters.
    * Converts OData-style params to ObjectStack query options.
@@ -63,14 +248,27 @@ export class ObjectStackAdapter<T = any> implements DataSource<T> {
     await this.connect();
 
     const queryOptions = this.convertQueryParams(params);
-    const result = await this.client.data.find<T>(resource, queryOptions);
+    const result: unknown = await this.client.data.find<T>(resource, queryOptions);
+
+    // Handle legacy/raw array response (e.g. from some mock servers or non-OData endpoints)
+    if (Array.isArray(result)) {
+      return {
+        data: result,
+        total: result.length,
+        page: 1,
+        pageSize: result.length,
+        hasMore: false,
+      };
+    }
 
+    const resultObj = result as { value?: T[]; count?: number };
     return {
-      data: result.value,
-      total: result.count,
-      page: params?.$skip ? Math.floor(params.$skip / (params.$top || 20)) + 1 : 1,
+      data: resultObj.value || [],
+      total: resultObj.count || (resultObj.value ? resultObj.value.length : 0),
+      // Calculate page number safely
+      page: params?.$skip && params.$top ? Math.floor(params.$skip / params.$top) + 1 : 1,
       pageSize: params?.$top,
-      hasMore: result.value.length === params?.$top,
+      hasMore: params?.$top ? (resultObj.value?.length || 0) === params.$top : false,
     };
   }
 
@@ -83,9 +281,9 @@ export class ObjectStackAdapter<T = any> implements DataSource<T> {
     try {
       const record = await this.client.data.get<T>(resource, String(id));
       return record;
-    } catch (error) {
+    } catch (error: unknown) {
       // If record not found, return null instead of throwing
-      if ((error as any)?.status === 404) {
+      if ((error as Record<string, unknown>)?.status === 404) {
         return null;
       }
       throw error;
@@ -118,31 +316,166 @@ export class ObjectStackAdapter<T = any> implements DataSource<T> {
   }
 
   /**
-   * Bulk operations (optional implementation).
+   * Bulk operations with optimized batch processing and error handling.
+   * Emits progress events for tracking operation status.
+   * 
+   * @param resource - Resource name
+   * @param operation - Operation type (create, update, delete)
+   * @param data - Array of records to process
+   * @returns Promise resolving to array of results
    */
   async bulk(resource: string, operation: 'create' | 'update' | 'delete', data: Partial<T>[]): Promise<T[]> {
     await this.connect();
 
-    switch (operation) {
-      case 'create':
-        return this.client.data.createMany<T>(resource, data);
-      case 'delete': {
-        const ids = data.map(item => (item as any).id).filter(Boolean);
-        await this.client.data.deleteMany(resource, ids);
-        return [];
+    if (!data || data.length === 0) {
+      return [];
+    }
+
+    const total = data.length;
+    let completed = 0;
+    let failed = 0;
+
+    const emitProgress = () => {
+      this.emitBatchProgress({
+        operation,
+        total,
+        completed,
+        failed,
+        percentage: total > 0 ? (completed + failed) / total * 100 : 0,
+      });
+    };
+
+    try {
+      switch (operation) {
+        case 'create': {
+          emitProgress();
+          const created = await this.client.data.createMany<T>(resource, data);
+          completed = created.length;
+          failed = total - completed;
+          emitProgress();
+          return created;
+        }
+        
+        case 'delete': {
+          const ids = data.map(item => (item as Record<string, unknown>).id).filter(Boolean) as string[];
+          
+          if (ids.length === 0) {
+            // Track which items are missing IDs
+            const errors = data.map((_, index) => ({
+              index,
+              error: `Missing ID for item at index ${index}`
+            }));
+            
+            failed = data.length;
+            emitProgress();
+            
+            throw new BulkOperationError('delete', 0, data.length, errors);
+          }
+          
+          emitProgress();
+          await this.client.data.deleteMany(resource, ids);
+          completed = ids.length;
+          failed = total - completed;
+          emitProgress();
+          return [] as T[];
+        }
+        
+        case 'update': {
+          // Check if client supports updateMany
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          if (typeof (this.client.data as any).updateMany === 'function') {
+            try {
+              emitProgress();
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              const updateMany = (this.client.data as any).updateMany;
+              const updated = await updateMany(resource, data) as T[];
+              completed = updated.length;
+              failed = total - completed;
+              emitProgress();
+              return updated;
+            } catch {
+              // If updateMany is not supported, fall back to individual updates
+              // Silently fallback without logging
+            }
+          }
+          
+          // Fallback: Process updates individually with detailed error tracking and progress
+          const results: T[] = [];
+          const errors: Array<{ index: number; error: unknown }> = [];
+          
+          for (let i = 0; i < data.length; i++) {
+            const item = data[i];
+            const id = (item as Record<string, unknown>).id;
+            
+            if (!id) {
+              errors.push({ index: i, error: 'Missing ID' });
+              failed++;
+              emitProgress();
+              continue;
+            }
+            
+            try {
+              const result = await this.client.data.update<T>(resource, String(id), item);
+              results.push(result);
+              completed++;
+              emitProgress();
+            } catch (error: unknown) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
+              errors.push({ index: i, error: errorMessage });
+              failed++;
+              emitProgress();
+            }
+          }
+          
+          // If there were any errors, throw BulkOperationError
+          if (errors.length > 0) {
+            throw new BulkOperationError(
+              'update',
+              results.length,
+              errors.length,
+              errors,
+              { resource, totalRecords: data.length }
+            );
+          }
+          
+          return results;
+        }
+        
+        default:
+          throw new ObjectStackError(
+            `Unsupported bulk operation: ${operation}`,
+            'UNSUPPORTED_OPERATION',
+            400
+          );
       }
-      case 'update': {
-        // For update, we need to handle each record individually
-        // or use the batch update if all records get the same changes
-        const results = await Promise.all(
-          data.map(item => 
-            this.client.data.update<T>(resource, String((item as any).id), item)
-          )
-        );
-        return results;
+    } catch (error: unknown) {
+      // Emit final progress with failure
+      emitProgress();
+      
+      // If it's already a BulkOperationError, re-throw it
+      if (error instanceof BulkOperationError) {
+        throw error;
+      }
+      
+      // If it's already an ObjectStackError, re-throw it
+      if (error instanceof ObjectStackError) {
+        throw error;
       }
-      default:
-        throw new Error(`Unsupported bulk operation: ${operation}`);
+      
+      // Wrap other errors in BulkOperationError with proper error tracking
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      const errors = data.map((_, index) => ({
+        index,
+        error: errorMessage
+      }));
+      
+      throw new BulkOperationError(
+        operation,
+        0,
+        data.length,
+        errors,
+        { resource, originalError: error }
+      );
     }
   }
 
@@ -162,15 +495,32 @@ export class ObjectStackAdapter<T = any> implements DataSource<T> {
 
     // Filtering - convert to ObjectStack FilterNode AST format
     if (params.$filter) {
-      options.filters = convertFiltersToAST(params.$filter);
+      if (Array.isArray(params.$filter)) {
+        // Assume active AST format if it's already an array
+        options.filters = params.$filter;
+      } else {
+        options.filters = convertFiltersToAST(params.$filter);
+      }
     }
 
     // Sorting - convert to ObjectStack format
     if (params.$orderby) {
-      const sortArray = Object.entries(params.$orderby).map(([field, order]) => {
-        return order === 'desc' ? `-${field}` : field;
-      });
-      options.sort = sortArray;
+      if (Array.isArray(params.$orderby)) {
+        // Handle array format ['name', '-age'] or [{ field: 'name', order: 'asc' }]
+        options.sort = params.$orderby.map(item => {
+          if (typeof item === 'string') return item;
+          // Handle object format { field: 'name', order: 'desc' }
+          const field = item.field;
+          const order = item.order || 'asc';
+          return order === 'desc' ? `-${field}` : field;
+        });
+      } else {
+        // Handle Record format { name: 'asc', age: 'desc' }
+        const sortArray = Object.entries(params.$orderby).map(([field, order]) => {
+          return order === 'desc' ? `-${field}` : field;
+        });
+        options.sort = sortArray;
+      }
     }
 
     // Pagination
@@ -187,19 +537,41 @@ export class ObjectStackAdapter<T = any> implements DataSource<T> {
 
   /**
    * Get object schema/metadata from ObjectStack.
+   * Uses caching to improve performance for repeated requests.
    * 
    * @param objectName - Object name
    * @returns Promise resolving to the object schema
    */
-  async getObjectSchema(objectName: string): Promise<any> {
+  async getObjectSchema(objectName: string): Promise<unknown> {
     await this.connect();
     
     try {
-      const schema = await this.client.meta.getObject(objectName);
+      // Use cache with automatic fetching
+      const schema = await this.metadataCache.get(objectName, async () => {
+        const result: any = await this.client.meta.getObject(objectName);
+        
+        // Unwrap 'item' property if present (common API response wrapper)
+        if (result && result.item) {
+          return result.item;
+        }
+
+        return result;
+      });
+      
       return schema;
-    } catch (error) {
-      console.error(`Failed to fetch schema for ${objectName}:`, error);
-      throw error;
+    } catch (error: unknown) {
+      // Check if it's a 404 error
+      const errorObj = error as Record<string, unknown>;
+      if (errorObj?.status === 404 || errorObj?.statusCode === 404) {
+        throw new MetadataNotFoundError(objectName, { originalError: error });
+      }
+      
+      // For other errors, wrap in ObjectStackError if not already
+      if (error instanceof ObjectStackError) {
+        throw error;
+      }
+      
+      throw createErrorFromResponse(errorObj, `getObjectSchema(${objectName})`);
     }
   }
 
@@ -209,6 +581,29 @@ export class ObjectStackAdapter<T = any> implements DataSource<T> {
   getClient(): ObjectStackClient {
     return this.client;
   }
+
+  /**
+   * Get cache statistics for monitoring performance.
+   */
+  getCacheStats() {
+    return this.metadataCache.getStats();
+  }
+
+  /**
+   * Invalidate metadata cache entries.
+   * 
+   * @param key - Optional key to invalidate. If omitted, invalidates all entries.
+   */
+  invalidateCache(key?: string): void {
+    this.metadataCache.invalidate(key);
+  }
+
+  /**
+   * Clear all cache entries and statistics.
+   */
+  clearCache(): void {
+    this.metadataCache.clear();
+  }
 }
 
 /**
@@ -218,14 +613,40 @@ export class ObjectStackAdapter<T = any> implements DataSource<T> {
  * ```typescript
  * const dataSource = createObjectStackAdapter({
  *   baseUrl: process.env.API_URL,
- *   token: process.env.API_TOKEN
+ *   token: process.env.API_TOKEN,
+ *   cache: { maxSize: 100, ttl: 300000 },
+ *   autoReconnect: true,
+ *   maxReconnectAttempts: 5
  * });
  * ```
  */
-export function createObjectStackAdapter<T = any>(config: {
+export function createObjectStackAdapter<T = unknown>(config: {
   baseUrl: string;
   token?: string;
   fetch?: (input: RequestInfo | URL, init?: RequestInit) => Promise<Response>;
+  cache?: {
+    maxSize?: number;
+    ttl?: number;
+  };
+  autoReconnect?: boolean;
+  maxReconnectAttempts?: number;
+  reconnectDelay?: number;
 }): DataSource<T> {
   return new ObjectStackAdapter<T>(config);
 }
+
+// Export error classes for error handling
+export {
+  ObjectStackError,
+  MetadataNotFoundError,
+  BulkOperationError,
+  ConnectionError,
+  AuthenticationError,
+  ValidationError,
+  createErrorFromResponse,
+  isObjectStackError,
+  isErrorType,
+} from './errors';
+
+// Export cache types
+export type { CacheStats } from './cache/MetadataCache';