roboto-js 1.0.21 → 1.1.2

package/src/rbt_api.js

@@ -1,6 +1,7 @@
 import axios from 'axios';
 import CryptoJS from 'crypto-js';
 import RbtObject from './rbt_object.js';
+import RbtUser from './rbt_user.js';
 import RbtFile from './rbt_file.js';
 import _ from 'lodash';
 import { openDB } from 'idb';
@@ -22,6 +23,7 @@ export default class RbtApi {
     this.localDb = null;
     this.iac_session = null;
     this.authtoken = authTokenToUse;
+
   }
 
   async initLocalDb(){
@@ -36,6 +38,14 @@ export default class RbtApi {
 
   }
 
+  /**
+     * Logs in a user and stores the authToken.
+     *
+     * @param {Object} params - The login parameters.
+     * @param {string} params.email - The email of the user.
+     * @param {string} params.password - The password of the user.
+     * @returns {Promise<Object>} - The response data from the API.
+     */
   async login(params) {
     try {
        
@@ -66,6 +76,81 @@ export default class RbtApi {
     }
   }
 
+  async logout() {
+    try {
+      // Call logout endpoint if necessary. Here, I assume there's a '/user_service/logoutUser' endpoint.
+      // This is optional and depends on how your backend is set up.
+      const response = await this.axios.post('/user_service/logoutUser');
+
+      if (response.data.ok === false) {
+        return this._handleError(response);
+      }
+
+      // Clear the iac_session and remove the auth token from axios headers
+      this.iac_session = null;
+      if (this.axios.defaults.headers.common['authtoken']) {
+        delete this.axios.defaults.headers.common['authtoken'];
+      }
+
+      // Clear localStorage if it's being used
+      if (typeof localStorage !== 'undefined') {
+        localStorage.removeItem('authtoken');
+      }
+
+      // Return some kind of success response or the response from the server
+      return response.data;
+    } catch (e) {
+      this._handleError(e);
+    }
+  }
+
+  async loadCurrentUser(){
+
+    // TODO - get the actual user from the session
+    let params = { id: 'superuser_tom' };
+
+    try {
+      
+      const response = await this.axios.post('/user_service/loadUser', [params]);
+      let userData = response?.data?.user;
+
+      let User = new RbtUser({ id: userData.id }, this.axios);
+      User.setData(userData);
+      return User;
+
+      //const record = response.data;
+//
+      //if(dataHash){
+      //  record.data = dataHash;
+      //}
+      //return new RbtObject(record, this.axios);
+    } catch (e) {
+      return this._handleError(e);
+    }
+
+  }
+
+  async refreshAuthToken(authtoken){
+
+    try {
+
+      const response = await this.axios.post('/user_service/refreshAuthToken', [authtoken]);
+      return response.data;
+
+    } catch (e) {
+
+      this._handleError(e);
+    }
+  }
+
+
+  /**
+   * Registers a new user.
+   *
+   * @param {Object} dataHash - The data for the new user.
+   * @returns {Promise<RbtObject>} - The newly created user as an RbtObject.
+   *
+   */
   async registerUser(dataHash={}) {
     try {
       const response = await this.axios.post('/user_service/registerUser', [dataHash]);
@@ -76,10 +161,18 @@ export default class RbtApi {
       }
       return new RbtObject(record, this.axios);
     } catch (e) {
+      debugger;
       return this._handleError(e);
     }
   }
 
+  /**
+   * Creates a new file in the system.
+   *
+   * @param {Object} dataHash - The data for the new file.
+   * @returns {Promise<RbtFile>} - The newly created file as an RbtFile.
+   * 
+   */
   async createFile(dataHash){
 
     //return this.create('<@filekit.file>', dataHash);
@@ -98,6 +191,13 @@ export default class RbtApi {
   }
 
 
+  /**
+   * Creates a new object of the given type.
+   *
+   * @param {string} type - The type of object to create.
+   * @param {Object} dataHash - The data for the new object.
+   * @returns {Promise<RbtObject>} - The newly created object as an RbtObject.
+   */
   async create(type, dataHash={}) {
     try {
       const response = await this.axios.post('/object_service/createObject', [type, dataHash]);
@@ -106,19 +206,50 @@ export default class RbtApi {
       if(dataHash){
         record.data = dataHash;
       }
-      return new RbtObject(record, this.axios);
+      return new RbtObject(record, this.axios, { isNew: true });
     } catch (e) {
       return this._handleError(e);
     }
   }
 
+  /**
+   * Queries objects of a given type based on specified parameters.
+   *
+   * @param {string} type - The type of object to query, specified as a doctree.typedef.
+   * @param {Object} params - The query parameters, including optional filters and configurations.
+   * @returns {Promise<Array<RbtObject>>} - An array of queried objects as RbtObjects.
+   *
+   * The `params` object can include the following properties:
+   * - where: A SQL-like where clause string for filtering the results.
+   * - orderBy: An object specifying the ordering of the results. It should include:
+   *    - column: The attribute name to sort by. This must be either a column in the @doctree.model schema or an indexed type attribute.
+   *    - direction: The sort direction, either 'ASC' for ascending or 'DESC' for descending.
+   * - limit: An object to control the pagination of results. It includes:
+   *    - offset: The starting point from where to fetch the results.
+   *    - results: The maximum number of results to return.
+   * - resolveReferences: An array of attribute names whose references should be resolved in the returned objects.
+   * - timeout: A numerical value in milliseconds to set a maximum time limit for the query execution.
+   *
+   * Example usage:
+   *   query("<@testuser>", {
+   *     where: 'email="tom@pospa.com"',
+   *     orderBy: { column: 'timeCreated', direction: 'DESC' },
+   *     limit: { offset: 0, results: 50 },
+   *     resolveReferences: ['translatableContent']
+   *   });
+   *
+   * Note: A default orderBy is applied if none is provided, ordering items by 'timeCreated' in descending order.
+   */
   async query(type, params = {}) {
     try {
       params.type = type;
 
-      // default 
+      // Default ordering and pagination
       const defaultOrderBy = { orderBy: { column: 'timeCreated', direction: 'DESC' } };
-      const mergedParams = { ...defaultOrderBy, ...params };
+      const defaultLimit = { limit: { offset: 0, results: 50 } };
+      
+      // Merge defaults with provided params
+      const mergedParams = { ...defaultOrderBy, ...defaultLimit, ...params };
 
       const response = await this.axios.post('/object_service/queryObjects', [mergedParams]);
       if (response.data.ok === false) {
@@ -127,7 +258,7 @@ export default class RbtApi {
 
       // Process items into RbtObject instances
       if (Array.isArray(response.data.items)) {
-        response.data.items = response.data.items.map(record => new RbtObject(record, this.axios));
+        response.data.items = response.data.items.map(record => new RbtObject(record, this.axios, { isNew: true }));
       }
       return response.data.items;
     } catch (e) {
@@ -135,15 +266,26 @@ export default class RbtApi {
     }
   }
 
-  async load(type, ids){
+  /**
+   * Loads one or multiple objects of a given type by their IDs.
+   *
+   * @param {string} type - The type of object to load.
+   * @param {Array<string>|string} ids - The ID(s) of the object(s) to load.
+   * 
+   * @returns {Promise<RbtObject|RbtObject[]>} - The loaded object(s) as RbtObject(s).
+   */
+  async load(type, ids, params={}){
 
     try{
-      debugger;
+      let mergedParams;
+      
       if(Array.isArray(ids)){
-        return this.query(type, { where: "id IN ("+ids.join(',')+")" });
+        mergedParams = { ...params, where: "id IN (" + ids.join(',') + ")" };
+        return this.query(type, mergedParams);
       }
       else{
-        let res = await this.query(type, { where: "id="+ids});
+        mergedParams = { ...params, where: "id="+ids };
+        let res = await this.query(type, mergedParams);
         return res[0];
       }
     
@@ -153,6 +295,112 @@ export default class RbtApi {
 
   }
 
+  /**
+   * Makes a POST request to a specific endpoint to run a task and handle progress updates.
+   * 
+   * @param {Object} params - The parameters to be sent in the POST request.
+   * @param {Object} callbacks - An object containing callback functions for progress and error handling.
+   * 
+   * The function expects a response in the following format:
+   * {
+   *   ok: boolean, // Indicates if the request was successful or not
+   *   jobId: string, // The job identifier
+   *   status: string // Can be 'RUNNING', 'DONE', or 'ERROR'
+   * }
+   */
+  async runTask(params = {}, callbacks = {}) {
+    const { onProgress, onError, onFinish } = callbacks;
+
+    try {
+      const response = await this.post('http://localhost:3004/runChain', params);
+      // Check if response and response.data are defined
+      if (!response) {
+        throw new Error('Invalid server response');
+      }
+
+      // Validate response structure
+      const { ok, jobId, status, message, output } = response;
+      if (!ok || typeof jobId !== 'string' || typeof status !== 'string') {
+        throw new Error('Invalid response structure');
+      }
+
+      // If the task is still in progress, start polling for updates
+      if (status === 'RUNNING' || status === 'SCHEDULED' || status === 'QUEUED') {
+        this.pollTaskProgress(jobId, callbacks);
+      }
+      if (status === 'ERROR' && onError){
+        // Provide the current progress to the callback function
+        onError(response);
+      }
+      if (status === 'DONE' && onFinish){
+        // Provide the current progress to the callback function
+          console.log('Finish (request) ',response);
+        onFinish(response);
+      }
+
+      return { ok, jobId, status, message, output };
+
+    } catch (e) {
+
+      if (typeof onError === 'function') {
+        onError(e);
+      } else {
+        console.error('Error in runTask:', e);
+      }
+      return { ok: false, jobId: null, status: 'ERROR', error: e.message };
+
+    }
+  }
+
+
+  /**
+   * Polls the progress of a long-running task.
+   * 
+   * @param {string} jobId - The ID of the job to poll for progress.
+   * @param {function} onProgress - Callback function that receives progress updates.
+   * 
+   * The function periodically sends GET requests to check the task's progress
+   * and reports back via the provided callback function. The polling stops when
+   * the task is completed or an error occurs.
+   */
+   async pollTaskProgress(jobId, callbacks) {
+    const { onProgress, onError, onFinish } = callbacks;
+    try {
+      const checkProgress = async () => {
+        const response = await this.get(`http://localhost:3004/pollChainProgress`, { jobId: jobId });
+
+        // If the task is still in progress, start polling for updates
+        if (response.status === 'DONE' && onFinish){
+          // Provide the current progress to the callback function
+          console.log('Finish (progress) ',response);
+          onFinish(response);
+        }
+        if (response.status === 'ERROR' && onError){
+          // Provide the current progress to the callback function
+          onError(response);
+        }
+
+        // Provide the current progress to the callback function
+        if(response.status == 'RUNNING'){
+          onProgress(response);
+        }
+
+        // Continue polling if the status is 'RUNNING'
+        if (['RUNNING'].includes(response.status)) {
+          setTimeout(checkProgress, 1000); // Poll every 2 seconds
+        }
+      };
+
+      checkProgress();
+    } catch (e) {
+      // Handle error based on your application's logic
+      return this._handleError(e);
+    }
+  }
+
+
+
+
   /**
    * Performs a GET request to the specified endpoint.
    * 
@@ -224,18 +472,31 @@ export default class RbtApi {
   }
 
 
-  _handleError(err){
+  setErrorHandler(customErrorHandler) {
+    this.customErrorHandler = customErrorHandler;
+  }
 
-    if(_.isObject(err)){
-      // response object?
-      let msg = _.get(err, 'response.data.message');
-      msg = (msg)? msg: err;
-      throw new Error(msg);
-    }
-    else{
-      // all other errors
-      throw new Error(err);
+  _handleError(err) {
+
+    debugger;
+    // Invoke the custom error handler if provided
+    if (this.customErrorHandler) {
+      let res = this.customErrorHandler(err);
+      if(res) return;
     }
 
+    if (_.isObject(err) && _.get(err, 'response')) {
+      const msg = _.get(err, 'response.data.message', 'Error in API response');
+
+      if(msg.key){
+        throw new Error(msg.key);
+      }
+      else{
+        throw new Error(msg);
+      }
+    } else {
+      throw new Error(err.message || 'Unknown error');
+    }
   }
-}
+
+}

package/src/rbt_object.js

@@ -2,50 +2,67 @@ import _ from 'lodash';
 
 export default class RbtObject {
   
-  constructor(record, axiosInstance) {
+  constructor(record, axiosInstance, options = {}) {
     this._axios = axiosInstance;
     this._internalData = record;
     this.id = record.id;
     this.id_revision = record.id_revision;
+    this.rpcMeta = { 
+      changes: [], 
+      isNew: options.isNew || false 
+    };
+    
     if(record.data){
-      this._data = record.data;
-    }
-    else{
-      this._data = record.dataJson ? JSON.parse(record.dataJson) : {};
+      this._data = this._deepUnpackJson(record.data);
+    } else {
+      this._data = record.dataJson ? this._deepUnpackJson(record.dataJson) : {};
     }
+    
   }
 
   get(path) {
     return _.get(this._data, path);
   }
 
-  set(path, value) {
-    _.set(this._data, path, value);
-  }
-
   getData() {
     return {
       ...this._data
     };
   }
 
+  _addChange(path) {
+    // Ensure no duplicate paths
+    if (!this.rpcMeta.changes.includes(path)) {
+      this.rpcMeta.changes.push(path);
+    }
+  }
+
+  set(path, value) {
+    const currentValue = _.get(this._data, path);
+    if (!_.isEqual(currentValue, value)) {
+      _.set(this._data, path, value);
+      this._addChange(path);
+    }
+  }
+
   setData(newData) {
-    // Ensure the input is an object
     if (typeof newData !== 'object' || newData === null) {
       throw new Error('setData expects an object');
     }
 
-    // Iterate over each key in the newData object
     Object.keys(newData).forEach(key => {
-      // Update the corresponding key in this._data
-      _.set(this._data, key, newData[key]);
+      if (!_.isEqual(_.get(this._data, key), newData[key])) {
+        _.set(this._data, key, newData[key]);
+        this._addChange(key);
+      }
     });
   }
 
   toRecord() {
     return {
       ...this._internalData,
-      dataJson: JSON.stringify(this._data)
+      dataJson: JSON.stringify(this._data),
+      rpcMeta: this.rpcMeta
     };
   }
 
@@ -58,7 +75,7 @@ export default class RbtObject {
     delete clonedData.id_revision;
 
     // Create a new instance of RbtObject with the cloned data
-    const clonedObject = new RbtObject(clonedData, this._axios);
+    const clonedObject = new RbtObject(clonedData, this._axios, { isNew: true });
 
     return clonedObject;
   }
@@ -82,11 +99,14 @@ export default class RbtObject {
       this.id_revision = response.data.id_revision;
       this.type = response.data.type;
 
+      this.rpcMeta.isNew = false;
+      
       return this;
 
     } catch (e) {
       console.log('RbtObject.save.error:');
       console.log(e.response.data);
+      throw e;
     }
   }
 
@@ -109,7 +129,25 @@ export default class RbtObject {
     } catch (e) {
       console.log('RbtObject.delete.error:');
       console.log(e.response.data);
+      throw e;
+    }
+  }
+
+  _deepUnpackJson(value){
+    if (typeof value === 'string') {
+        try {
+            const parsed = JSON.parse(value);
+            return this._deepUnpackJson(parsed); // Recursively parse if the result is a string, object, or array
+        } catch (e) {
+            return value; // Return the original string if parsing fails
+        }
+    } else if (value !== null && typeof value === 'object') {
+        // If it's an object (including arrays), recursively parse each value
+        for (const key in value) {
+            value[key] = this._deepUnpackJson(value[key]);
+        }
     }
+    return value;
   }
 
 }

package/src/rbt_user.js

@@ -0,0 +1,135 @@
+import _ from 'lodash';
+
+export default class RbtUser {
+  
+  constructor(record, axiosInstance, options = {}) {
+    this._axios = axiosInstance;
+    this._internalData = record;
+    this.id = record.id;
+    this.id_revision = record.id_revision;
+    this.rpcMeta = { 
+      changes: [], 
+      isNew: options.isNew || false 
+    };
+
+    if(record.data){
+      this._data = record.data;
+    } else {
+      this._data = record.dataJson ? JSON.parse(record.dataJson) : {};
+    }
+    
+  }
+
+  get(path) {
+    return _.get(this._data, path);
+  }
+
+  getData() {
+    return {
+      ...this._data
+    };
+  }
+
+  _addChange(path) {
+    // Ensure no duplicate paths
+    if (!this.rpcMeta.changes.includes(path)) {
+      this.rpcMeta.changes.push(path);
+    }
+  }
+
+  set(path, value) {
+    const currentValue = _.get(this._data, path);
+    if (!_.isEqual(currentValue, value)) {
+      _.set(this._data, path, value);
+      this._addChange(path);
+    }
+  }
+
+  setData(newData) {
+    if (typeof newData !== 'object' || newData === null) {
+      throw new Error('setData expects an object');
+    }
+
+    Object.keys(newData).forEach(key => {
+      if (!_.isEqual(_.get(this._data, key), newData[key])) {
+        _.set(this._data, key, newData[key]);
+        this._addChange(key);
+      }
+    });
+  }
+
+  toRecord() {
+    return {
+      ...this._internalData,
+      dataJson: JSON.stringify(this._data),
+      rpcMeta: this.rpcMeta
+    };
+  }
+
+  clone() {
+    // Create a deep copy of the current object's data
+    const clonedData = _.cloneDeep(this._internalData);
+
+    // Reset unique identifiers to ensure a new ID is generated upon saving
+    delete clonedData.id;
+    delete clonedData.id_revision;
+
+    // Create a new instance of RbtUser with the cloned data
+    const clonedObject = new RbtUser(clonedData, this._axios, { isNew: true });
+
+    return clonedObject;
+  }
+
+  async save() {
+
+    try {
+      debugger;
+      const record = this.toRecord();
+      record.type = '<@iac.user>';
+      const response = await this._axios.post('/user_service/saveUser', [record]);
+
+      if (response.data.ok === false) {
+        throw new Error(response.data.message);
+      }
+      
+      this._internalData = response.data;
+      
+      this.id = response.data.id;
+      this.id_revision = response.data.id_revision;
+      this.type = response.data.type;
+
+      this.rpcMeta.isNew = false;
+      
+      return this;
+
+    } catch (e) {
+      console.log('RbtUser.save.error:');
+      console.log(e.response.data);
+      throw e;
+    }
+  }
+
+  //async delete() {
+  //  if (!this._internalData.type) {
+  //    throw new Error('Cannot delete object without type');
+  //  }
+//
+  //  try {
+  //    const record = this.toRecord();
+  //    const response = await this._axios.post('/object_service/deleteObject', [record]);
+//
+  //    if (response.data.ok === false) {
+  //      throw new Error(response.data.message);
+  //    }
+  //    
+  //    this._internalData = response.data;
+  //    return this;
+//
+  //  } catch (e) {
+  //    console.log('RbtUser.delete.error:');
+  //    console.log(e.response.data);
+  //    throw e;
+  //  }
+  //}
+
+}