miolo-cli 3.0.0-beta.12 → 3.0.0-beta.14

package/dist/miolo-cli.mjs

@@ -1,5 +1,5 @@
 /**
- * miolo-cli v3.0.0-beta.12
+ * miolo-cli v3.0.0-beta.14
  *
  * https://www.afialapis.com/os/miolo
  *

package/dist/miolo-cli.umd.js

@@ -1,5 +1,5 @@
 /**
- * miolo-cli v3.0.0-beta.12
+ * miolo-cli v3.0.0-beta.14
  *
  * https://www.afialapis.com/os/miolo
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miolo-cli",
-  "version": "3.0.0-beta.12",
+  "version": "3.0.0-beta.14",
   "description": "cli utils for miolo",
   "author": "Donato Lorenzo <donato@afialapis.com>",
   "contributors": [
@@ -24,7 +24,8 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "scripts": {
     "reset": "rm -fr package-lock.json npm-lock.yaml dist/* && npm i",

package/src/catcher/index.mjs

@@ -0,0 +1,75 @@
+function init_catcher (catcher_url, fetcher) {
+  if (typeof window == "undefined") {
+    return
+  }  
+
+  if (window.miolo_listeners===true) {
+    return
+  }
+
+  //  window.onerror = function(msg, file, line, col, error) {
+  //    try {
+  //      const params= {
+  //        'error': {
+  //          msg, file, line, col, error
+  //        },
+  //        'path' : window.location.pathname,
+  //        'agent': 'UserAgent' + navigator.userAgent
+  //      }
+  //
+  //      fetcher.post(catcher_url, params)
+  //    } catch(e) {
+  //      console.error(e)
+  //    }
+  //  }
+
+
+  window.addEventListener("error", (event) => {
+    // https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
+
+    try {
+      const params= {
+        'error': {
+          msg: event?.message || 'Client error',
+          file: event?.filename,
+          line: event?.lineno,
+          col: event?.colno,
+          error: event?.error
+        },
+        'path' : window.location.pathname,
+        'agent': 'UserAgent' + navigator.userAgent
+      }
+
+      fetcher.post(catcher_url, params)
+    } catch(e) {
+      console.error(e)
+    }
+  }) 
+
+  window.addEventListener("unhandledrejection", (event) => {
+    // https://developer.mozilla.org/en-US/docs/Web/API/PromiseRejectionEvent
+
+    try {
+      const params= {
+        'warning': {
+          msg: event?.reason || 'Client Unhandled rejection',
+          file: undefined,
+          line: undefined,
+          col: undefined,
+          error: event?.reason
+        },
+        'path' : window.location.pathname,
+        'agent': 'UserAgent' + navigator.userAgent
+      }
+
+      fetcher.post(catcher_url, params)
+    } catch(e) {
+      console.error(e)
+    }
+  }) 
+
+  window.miolo_listeners = true
+
+}
+
+export {init_catcher}

package/src/fetcher/fetcher.mjs

@@ -0,0 +1,214 @@
+import {omit_nil, trim_left, json_to_query_string, parse_login_cookie} from './utils.mjs'
+
+class Fetcher {
+  /**
+   * @param {*} config {hostname, port, force_hostname, silent_fail: false}
+   */
+  constructor(config) {
+    this.config= config
+    this.auth = undefined
+    this.cookie = undefined
+  }
+
+  set_auth(auth) {
+    if (auth) {
+      const {username, password}= auth
+      this.auth= {username, password}
+    }
+  }
+
+  get_headers() {
+    let headers = {}
+
+    if (this.auth) {
+      let {username, password}= this.auth
+      username= username || ''
+      password= password || ''
+
+      let sauth
+      try {
+        sauth= 'Basic ' + Buffer.from(username + ":" + password).toString('base64')
+      } catch(_) {
+        sauth= 'Basic ' + btoa(username + ":" + password)
+      }
+
+      headers['Authorization']= sauth
+    }
+
+    if (this.cookie) {
+      headers['Cookie']= this.cookie
+    }
+
+    return headers
+  }
+
+  _prepare_url (url) {
+    const endpoint = '/' + trim_left(url, '/')
+    
+    const {hostname, port, force_hostname} = this.config || {}
+    if (hostname && force_hostname) {
+      return `http://${hostname}:${port}${endpoint}`
+    }
+    
+    return endpoint
+  }
+
+  async _fetch (method, url, params, auth= undefined) {
+    this.set_auth(auth)
+
+    let request = {
+      method,
+      mode: 'cors',
+      credentials: 'include',
+      headers: {
+        'content-type': 'application/json',
+        ...this.get_headers() || {}
+      }
+    }
+
+    let wurl = this._prepare_url(url)
+  
+    if (method === 'POST') {
+      request.body = JSON.stringify(params || {}, (k, v) => v === undefined ? null : v)
+    } else if (method === 'GET') {
+      if (params) {
+        wurl+= json_to_query_string(params)
+      }
+    }
+    
+    const response = await fetch(wurl, request)
+    
+    if (response.redirected) {
+      const isBrowser = typeof window == 'object'
+      if (isBrowser) {
+        // JSDOM does not support navigation,  so lets skip it for tests
+        const isTest = typeof navigator !== "undefined" &&
+                        navigator.userAgent.includes("Node.js");
+        if (!isTest) {
+          window.location.replace(response.url)
+          return Promise.resolve(response)
+        } else {
+          console.error(`Response for ${wurl} is a redirect to ${response.url}. But you are in a test environment, where redirects cannot be done. Unexpected results are coming...`)
+        }
+      }
+    }
+  
+    if (response.headers.get('content-type').indexOf('json') >= 0) {
+      const data= await response.json()
+  
+      return {
+        data,
+        status: response.status,
+        response
+      }
+    }
+  
+    const data= await response.text()
+    return {
+      data,
+      status: response.status,
+      response
+    }
+
+  }
+  
+  async get(url, params, auth= undefined) {
+    /* eslint no-unused-vars:0 */
+    try {
+      const resp = await this._fetch('GET', url, omit_nil(params), auth)
+      return resp
+    } catch(e) {
+      if (this.config?.silent_fail !== true) {
+        console.error(`Error on GET ${url}`)
+        console.error(e)
+      }
+
+      return {
+        data: e,
+        status: -1,
+      }
+    }
+  }
+
+  async post(url, data, auth= undefined) {
+    try {
+      const resp = await this._fetch('POST', url, data, auth)
+      return resp
+    } catch(e) {
+      if (this.config?.silent_fail !== true) {
+        console.error(`Error on POST ${url}`)
+        console.error(e)
+      }
+
+      return {
+        data: e,
+        status: -1
+      }
+    }
+  }  
+
+  async login(url, {username, password}) {
+    const res= await this._fetch('POST', url || '/login', {username, password})
+    this.cookie= parse_login_cookie(res.response)
+    return res
+  }
+
+  async logout(url) {
+    this.cookie= undefined
+    const res= await this._fetch('POST', url || '/logout', {})
+    return res  
+  }
+
+  async read(url, params, auth= undefined) {
+    const result = await this.get(`${url}/read`, params, auth)
+    return result.data
+  }
+
+  async key_list(url, params, auth= undefined) {
+    const result = await this.get(`${url}/key_list`, params, auth)
+    return result.data
+  }  
+
+  async name_list(url, params, auth= undefined) {
+    const result = await this.key_list(url, params, auth)
+    return Object.values(result)
+  }
+
+  async find(url, id, auth= undefined) {
+    const result = await this.get(`${url}/find`, { id: id }, auth)
+    return result.data
+  }
+
+  async distinct(url, field, params, auth= undefined) {
+    const nparams= {
+      ...params,
+      distinct_field: field
+    }
+    const result = await this.get(`${url}/distinct`, nparams, auth)
+    return result.data   
+  }
+
+  async upsave(url, data, auth= undefined) {
+    let result
+    if (data.id == undefined) {
+      delete data.id
+      result= await this.post(`${url}/save`, data, auth)
+    } else {
+      result= await this.post(`${url}/update`, data, auth)
+    }
+    
+    return result.data
+  }  
+
+  async remove(url, id, auth= undefined) {
+    const data = { id: id }
+    const result = await this.post(`${url}/delete`, data, auth)
+    return result.data
+  }
+}
+
+Fetcher.keyList= Fetcher.key_list
+Fetcher.nameList= Fetcher.name_list
+
+export { Fetcher }
+

package/src/fetcher/index.mjs

@@ -0,0 +1,7 @@
+import {Fetcher} from './fetcher.mjs'
+
+
+export function init_fetcher(config) {
+  const fetcher= new Fetcher(config)
+  return fetcher
+}

package/src/fetcher/utils.mjs

@@ -0,0 +1,59 @@
+/**
+ * Transform an JSON object to a query string
+ */
+const _parse_value= (value) => {
+  try {
+    return value.replace(/\+/g, '%2B')
+  } catch(e) {
+    return value
+  }
+}
+
+export function json_to_query_string(obj) {
+  if (obj && (Object.keys(obj).length>0)) {
+    const uparams = new URLSearchParams()
+    for (const key in obj) {
+      if (Object.hasOwn(obj, key)) {
+        const value = obj[key];
+        if (Array.isArray(value)) {
+          value.forEach(item => uparams.append(key, _parse_value(item)))
+        } else if (value !== undefined && value !== null) {
+          uparams.append(key, _parse_value(value))
+        }
+      }
+    }
+    return `?${uparams.toString()}`
+  }
+  return ''
+}
+
+export function trim_left(str, what) {
+  return str.replace(new RegExp(`^${what || '\\s'}+`), '')
+}
+
+
+export function omit_nil(obj) {
+  if (typeof obj !== 'object') return obj
+  return Object.keys(obj).reduce((acc, v) => {
+    if (obj[v] !== undefined) acc[v] = obj[v]
+    return acc
+  }, {})
+}
+
+
+export function parse_login_cookie(response) {
+  if (typeof window !== 'object') {
+    return undefined
+  }
+  try {
+    const raw = response.headers.raw()['set-cookie'];
+    return raw.map((entry) => {
+      const parts = entry.split(';');
+      const cookiePart = parts[0];
+      return cookiePart;
+    }).join(';');
+  } catch(e) {
+    console.log('[miolo-cli] Could not get the set-cookie after login')
+    return undefined
+  }
+}

package/src/index.mjs

@@ -0,0 +1,30 @@
+import {init_catcher} from './catcher/index.mjs'
+import {init_fetcher} from './fetcher/index.mjs'
+// import {init_socket} from './socket/index.mjs'
+
+function miolo_client(context) {
+
+  const {config} = context
+
+  const fetcher = init_fetcher(config)
+
+  if (config?.catcher_url) {
+    init_catcher(config?.catcher_url, fetcher)  
+  }
+
+//  let socket
+//  if (config?.socket?.enabled===true) {
+//    const domain = config?.socket?.domain
+//    const options = config?.socket?.options
+//    socket = init_socket(domain, options)  
+//  }
+
+  const miolo_obj= {
+    fetcher,
+    //socket
+  }
+
+  return miolo_obj
+}
+
+export {miolo_client}

package/src/socket/index.mjs

@@ -0,0 +1,6 @@
+import { io } from "socket.io-client";
+
+export function init_socket(domain, options) {
+  const socket = io(domain, options)
+  return socket
+}