roboto-js 1.0.0

package/client_test.js

@@ -0,0 +1,51 @@
+
+// use secrets
+const fs = require('fs');
+const creds = JSON.parse(fs.readFileSync('.secrets/roboto/roboto_svcs_credentials.live.json', 'utf-8'));
+process.env.ROBOTO_API_KEY = creds.roboto.accessKey;
+process.env.ROBOTO_API_KEY = creds.roboto.host;
+//
+
+const { RobotoApi } = require('./src/index.js');
+const roboto = RobotoApi.configure({ 
+	apiKey: process.env.ROBOTO_API_KEY,
+	baseUrl: process.env.ROBOTO_HOST
+});
+
+console.log('Starting RobotoAPI client library test..');
+
+
+async function main(){
+	//roboto.query({})
+	var user = await roboto.login({ email: null, password: null });
+
+	console.log('iac-session started:');
+	console.log(user);
+
+	debugger;
+
+	try{
+
+		var newSite = await roboto.create('<@doc_website.site>');
+		newSite.set('configs.label', "my-new-site2");
+		await newSite.save();
+
+	}
+	catch(e){
+		console.log('client-test.error');
+		console.log(e);
+	}
+
+
+//	var websites = await roboto.query('<@doc_website.site>', { where: 'id=s78ef2e99ab2ceae' });
+//
+//	//console.log(websites);
+//	//debugger;
+//
+//	for (let website of websites) {
+//	    console.log('Label: '+website.get('configs.label'));
+//	}
+//
+}
+
+main();

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "roboto-js",
+  "version": "1.0.0",
+  "description": "",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "axios": "^1.5.1",
+    "crypto-js": "^4.1.1"
+  }
+}

package/src/index.js

@@ -0,0 +1,38 @@
+
+import RbtApi from './rbt_api';
+import RbtObject from './rbt_object';
+
+export {
+    RbtApi,
+    RbtObject
+    //User,
+    //Site
+};
+
+export default class Roboto{
+
+  constructor() {
+
+    this.config = {
+      apiKey: process.env.NEXT_PUBLIC_ROBOTO_API_KEY,
+      baseUrl: 'https://' + (process.env.NEXT_PUBLIC_ROBOTO_HOST),
+    };
+
+    this.api = RbtApi.configure(this.config);
+
+  }
+
+  async login(params){
+    return this.api.login(params);
+  }
+
+  async create(params, data={}){
+    return this.api.create(params, data);
+  }
+
+  async query(params){
+    return this.api.query(params);
+  }
+
+}
+

package/src/rbt_api.js

@@ -0,0 +1,99 @@
+import axios from 'axios';
+import CryptoJS from 'crypto-js';
+import RbtObject from './rbt_object.js';
+import _ from 'lodash';
+
+export default class RbtApi {
+
+  constructor(axiosInstance) {
+    this.axios = axiosInstance;
+    this.iac_session = null;
+    this.authtoken = null;
+  }
+
+  static configure({ apiKey, baseUrl }) {
+    if (!RbtApi.instance) {
+      const axiosInstance = axios.create({
+        baseURL: baseUrl,
+        headers: {
+          accesskey: apiKey
+        }
+      });
+      RbtApi.instance = new RbtApi(axiosInstance);
+    }
+    return RbtApi.instance;
+  }
+
+  async login(params) {
+    try {
+      // create a md5 hash of the password using crypto-js
+      const hash_password = CryptoJS.MD5(params.password).toString(CryptoJS.enc.Hex);
+      const response = await this.axios.post('/user_service/loginUser', [{
+        email: params.email,
+        password: hash_password
+      }]);
+
+      if (response.data.ok === false) {
+        return this._handleError(response);
+      }
+
+      this.iac_session = response.data;
+      // update axios instance headers with authtoken
+      this.axios.defaults.headers.common['authtoken'] = response.data.authToken;
+      return response.data;
+    } catch (e) {
+
+      this._handleError(e);
+    }
+  }
+
+  async create(type, dataHash={}) {
+    try {
+      const params = {
+        type
+      };
+      const response = await this.axios.post('/object_service/createObject', [params.type]);
+      const record = response.data;
+
+      if(dataHash){
+        record.data = dataHash;
+      }
+      return new RbtObject(record, this.axios);
+    } catch (e) {
+      return this._handleError(e);
+    }
+  }
+
+  async query(type, params = {}) {
+    try {
+      params.type = type;
+      const response = await this.axios.post('/object_service/queryObjects', [params]);
+      if (response.data.ok === false) {
+        return this._handleError(response);
+      }
+
+      // Process items into RbtObject instances
+      if (Array.isArray(response.data.items)) {
+        response.data.items = response.data.items.map(record => new RbtObject(record, this.axios));
+      }
+      return response.data.items;
+    } catch (e) {
+      return this._handleError(e);
+    }
+  }
+
+  _handleError(err){
+
+    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);
+    }
+
+  }
+}

package/src/rbt_object.js

@@ -0,0 +1,75 @@
+import _ from 'lodash';
+
+export default class RbtObject {
+  
+  constructor(record, axiosInstance) {
+    this._axios = axiosInstance;
+    this._internalData = record;
+    if(record.data){
+      this._data = record.data;
+    }
+    else{
+      this._data = record.dataJson ? JSON.parse(record.dataJson) : {};
+    }
+  }
+
+  get(path) {
+    return _.get(this._data, path);
+  }
+
+  set(path, value) {
+    _.set(this._data, path, value);
+  }
+
+  toRecord() {
+    return {
+      ...this._internalData,
+      dataJson: JSON.stringify(this._data)
+    };
+  }
+
+  async save() {
+    if (!this._internalData.type) {
+      throw new Error('Cannot save object without type');
+    }
+
+    try {
+      const record = this.toRecord();
+      const response = await this._axios.post('/object_service/saveObject', [record]);
+
+      if (response.data.ok === false) {
+        throw new Error(response.data.message);
+      }
+      
+      this._internalData = response.data;
+      return this;
+
+    } catch (e) {
+      console.log('RbtObject.save.error:');
+      console.log(e.response.data);
+    }
+  }
+
+  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('RbtObject.delete.error:');
+      console.log(e.response.data);
+    }
+  }
+
+}