wip

Author: singaraiona

apps/dashboard/public/rayforce.js

@@ -208,7 +208,25 @@
 
   class RayError extends RayObject {
     get isError() { return true; }
-    get message() { return this.toString(); }
+    
+    // Get error message directly from WASM (no allocation, always works)
+    get message() {
+      return this._sdk._getErrorMessage(this._ptr) || 'Unknown error';
+    }
+    
+    // Get structured error info as a plain JS object (may fail if OOM)
+    get info() {
+      try {
+        const infoPtr = this._sdk._getErrorInfo(this._ptr);
+        if (infoPtr === 0) return { code: 'unknown', message: this.message };
+        const infoObj = this._sdk._wrapPtr(infoPtr);
+        if (!infoObj || infoObj.isNull) return { code: 'unknown', message: this.message };
+        return infoObj.toJS();
+      } catch (e) {
+        return { code: 'unknown', message: this.message };
+      }
+    }
+    
     toJS() { throw new Error(this.message); }
   }
 
@@ -402,13 +420,33 @@
       const names = this.columnNames();
       const count = this.rowCount;
       const rows = [];
+      
+      // Cache column references to avoid repeated lookups
+      const cols = names.map(name => this.col(name));
+      
       for (let i = 0; i < count; i++) {
         const row = {};
-        for (const name of names) {
-          row[name] = this.col(name).at(i);
-          if (typeof row[name] === 'bigint') {
-            const n = Number(row[name]);
-            row[name] = Number.isSafeInteger(n) ? n : row[name];
+        for (let c = 0; c < names.length; c++) {
+          const col = cols[c];
+          if (!col || col.isNull) {
+            row[names[c]] = null;
+            continue;
+          }
+          
+          try {
+            let val = col.at(i);
+            // If at() returns a RayObject (e.g. from List), convert to JS
+            if (val instanceof RayObject) {
+              val = val.toJS();
+            }
+            // Handle BigInt values
+            if (typeof val === 'bigint') {
+              const n = Number(val);
+              val = Number.isSafeInteger(n) ? n : val;
+            }
+            row[names[c]] = val;
+          } catch (e) {
+            row[names[c]] = null;
           }
         }
         rows.push(row);
@@ -578,6 +616,8 @@
       this._isObjVector = w.cwrap('is_obj_vector', 'number', ['number']);
       this._isObjNull = w.cwrap('is_obj_null', 'number', ['number']);
       this._isObjError = w.cwrap('is_obj_error', 'number', ['number']);
+      this._getErrorInfo = w.cwrap('get_error_info', 'number', ['number']);
+      this._getErrorMessage = w.cwrap('get_error_message', 'string', ['number']);
       this._getObjRc = w.cwrap('get_obj_rc', 'number', ['number']);
 
       this._getDataPtr = w.cwrap('get_data_ptr', 'number', ['number']);
@@ -843,9 +883,13 @@
     }
 
     set(name, value) {
+      // Create symbol object (binary_set expects -TYPE_SYMBOL object pointer)
       const sym = this.symbol(name);
       const val = value instanceof RayObject ? value : this._toRayObject(value);
+      // binary_set internally clones the value, so we just pass the pointer
       this._globalSet(sym._ptr, val._ptr);
+      // Drop the symbol wrapper after use
+      sym.drop();
     }
 
     get(name) { return this.eval(name); }
@@ -863,7 +907,8 @@
       try {
         this._wasm.stringToUTF8(content, stringOnHeap, lengthBytes);
         // Pass pointer and length (excluding null terminator)
-        return new Table(this, this._readCSV(stringOnHeap, lengthBytes - 1));
+        // Use _wrapPtr to properly detect errors vs tables
+        return this._wrapPtr(this._readCSV(stringOnHeap, lengthBytes - 1));
       } finally {
         this._wasm._free(stringOnHeap);
       }

apps/dashboard/public/rayforce.umd.js

@@ -179,6 +179,22 @@ interface EmscriptenModule {
   ccall: (name: string, returnType: string, argTypes: string[], args: unknown[]) => unknown;
 }
 
+/** Structured error information from Rayforce */
+interface ErrorInfo {
+  code: string;
+  message?: string;
+  expected?: string;
+  got?: string;
+  need?: number;
+  have?: number;
+  index?: number;
+  bound?: number;
+  name?: string;
+  type?: string;
+  limit?: number;
+  raw?: string;
+}
+
 interface RayObject {
   ptr: number;
   type: number;
@@ -192,6 +208,11 @@ interface RayObject {
   drop(): void;
 }
 
+interface RayError extends RayObject {
+  info: ErrorInfo;
+  message: string;
+}
+
 interface Vector extends RayObject {
   typedArray: ArrayBufferView;
   at(idx: number): unknown;
@@ -747,26 +768,40 @@ export class RayforceClient {
       throw new Error('SDK not loaded');
     }
 
-    logInfo('Rayforce', `Loading CSV into table '${name}' (${content.length} bytes)`);
+    logInfo('Rayforce', `Loading CSV into table '${name}' (${content.length} bytes, ${(content.length / (1024 * 1024)).toFixed(1)} MB)`);
 
     // 1. Parse CSV into Table object
     // Note: read_csv returns a Table object associated with the WASM heap
     const table = this.sdk.read_csv(content);
+    
+    logDebug('Rayforce', `read_csv returned: type=${table.type}, isNull=${table.isNull}, isError=${table.isError}, ptr=${table.ptr}`);
 
     if (table.isError) {
-      const err = table.toString();
+      // Use structured error info for clean display
+      const errObj = table as unknown as RayError;
+      const errMsg = errObj.message || table.toString();
+      logError('Rayforce', `CSV parse error: ${errMsg}`);
       table.drop();
-      throw new Error(`CSV parse error: ${err}`);
+      throw new Error(errMsg);
+    }
+    
+    if (table.isNull) {
+      logError('Rayforce', `read_csv returned null`);
+      throw new Error('CSV parse returned null');
     }
 
+    // Get table info before setting
+    const rowCount = (table as Table).rowCount;
+    const columns = (table as Table).columnNames();
+    logInfo('Rayforce', `Parsed table: ${rowCount} rows, ${columns.length} columns (${columns.join(', ')})`);
+
     // 2. Register table as a variable
     // This allows SQL/queries to reference it by name
     this.sdk.set(name, table);
+    logDebug('Rayforce', `Called set('${name}', table)`);
 
     // 3. Drop our reference (the variable 'name' now holds a reference)
-    // Actually, set() might copy or increment ref count.
-    // Usually SDK.set takes ownership or we should drop our handle if we don't need it.
-    // Based on typical Rayforce pattern, we should drop the local handle.
+    // binary_set clones the value, so dropping our reference is safe
     table.drop();
 
     logInfo('Rayforce', `CSV loaded successfully as '${name}'`);
@@ -1299,7 +1334,10 @@ export class RayforceClient {
     }
 
     if (obj.isError) {
-      return { type: 'error', data: obj.toString() };
+      // Use structured error info for clean display
+      const errObj = obj as unknown as RayError;
+      const errMsg = errObj.message || obj.toString();
+      return { type: 'error', data: errMsg };
     }
 
     const type = Math.abs(obj.type);
@@ -1309,10 +1347,43 @@ export class RayforceClient {
       const table = obj as Table;
       const columns = table.columnNames();
       const rowCount = table.rowCount;
+      
+      logDebug('Rayforce', `wrapRayObject TABLE: columns=${columns.length}, rowCount=${rowCount}`);
+      
+      // For display, only convert first N rows (large tables would be too slow)
+      const MAX_DISPLAY_ROWS = 1000;
+      let rows: Record<string, unknown>[] = [];
+      
+      if (rowCount <= MAX_DISPLAY_ROWS) {
+        // Small table - convert all rows
+        try {
+          const startTime = performance.now();
+          rows = table.toRows();
+          logDebug('Rayforce', `toRows() returned ${rows.length} rows in ${(performance.now() - startTime).toFixed(1)}ms`);
+        } catch (err) {
+          logError('Rayforce', `toRows() failed: ${err}`);
+        }
+      } else {
+        // Large table - only get first N rows for display
+        logDebug('Rayforce', `Large table (${rowCount} rows), showing first ${MAX_DISPLAY_ROWS} for display`);
+        try {
+          const startTime = performance.now();
+          for (let i = 0; i < MAX_DISPLAY_ROWS && i < rowCount; i++) {
+            const rowObj = table.row(i);
+            if (rowObj && !rowObj.isNull) {
+              rows.push(rowObj.toJS() as Record<string, unknown>);
+            }
+          }
+          logDebug('Rayforce', `Extracted ${rows.length} display rows in ${(performance.now() - startTime).toFixed(1)}ms`);
+        } catch (err) {
+          logError('Rayforce', `Row extraction failed: ${err}`);
+        }
+      }
 
       return {
         type: 'table',
         rayObject: obj,
+        data: rows,
         columns,
         rowCount,
         // Zero-copy column access
@@ -1321,7 +1392,7 @@ export class RayforceClient {
           if (!col) return null;
           return col.typedArray || null;
         },
-        // Lazy JS conversion
+        // Full conversion - use with caution for large tables
         toJS: () => table.toRows(),
       };
     }