miolo-cli 3.0.0-beta.23 → 3.0.0-beta.230

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miolo-cli",
-  "version": "3.0.0-beta.23",
+  "version": "3.0.0-beta.230",
   "description": "cli utils for miolo",
   "author": "Donato Lorenzo <donato@afialapis.com>",
   "contributors": [
@@ -17,32 +17,25 @@
   "license": "MIT",
   "type": "module",
   "exports": {
-    ".": {
-      "development": "./src/index.mjs", 
-      "import": "./dist/miolo-cli.mjs",
-      "default": "./dist/miolo-cli.umd.js"
-    }
+    ".": "./src/index.mjs"
   },
   "files": [
-    "dist",
-    "src"
+    "src",
+    "package.json"
   ],
   "scripts": {
-    "reset": "rm -fr package-lock.json npm-lock.yaml dist/* && npm i",
-    "clean": "rm -fr ./dist/*",
-    "bundle": "npx xeira bundle --target=browser --source_index=./src/index.mjs --bundle_folder=./dist --bundle_name=miolo-cli --bundle_extension=umd,mjs",
-    "dist": "npm run clean && npm run bundle"
+    "reset": "rm -fr package-lock.json npm-lock.yaml node_modules && npm i",
+    "lint": "biome check ./src --reporter=github",
+    "lint:fix": "biome check --write ./src --reporter=github",
+    "lint:types": "tsc -p jsconfig.json --noEmit",
+    "prepublishOnly": "npm run lint"
   },
   "dependencies": {
-    "socket.io-client": "^4.8.1"
+    "qs": "^6.15.3",
+    "socket.io-client": "^4.8.3",
+    "tinguir": "^0.0.7"
   },
-  "devDependencies": {
-    "node-fetch": "^3.3.2",
-    "xeira": "^1.2.3"
-  },
-  "eslintConfig": {
-    "extends": [
-      "../../node_modules/xeira/configs/eslint.cjs"
-    ]
+  "engines": {
+    "node": ">=24"
   }
-}
+}

package/src/catcher/index.mjs

@@ -1,9 +1,9 @@
-function init_catcher (catcher_url, fetcher) {
-  if (typeof window == "undefined") {
+function init_catcher(catcher_url, fetcher) {
+  if (typeof window === "undefined") {
     return
-  }  
+  }
 
-  if (window.miolo_listeners===true) {
+  if (window.miolo_listeners === true) {
     return
   }
 
@@ -23,53 +23,51 @@ function init_catcher (catcher_url, fetcher) {
   //    }
   //  }
 
-
   window.addEventListener("error", (event) => {
     // https://developer.mozilla.org/en-US/docs/Web/API/ErrorEvent
 
     try {
-      const params= {
-        'error': {
-          msg: event?.message || 'Client error',
+      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
+        path: window.location.pathname,
+        agent: "UserAgent" + navigator.userAgent
       }
 
       fetcher.post(catcher_url, params)
-    } catch(e) {
+    } 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',
+      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
+        path: window.location.pathname,
+        agent: "UserAgent" + navigator.userAgent
       }
 
       fetcher.post(catcher_url, params)
-    } catch(e) {
+    } catch (e) {
       console.error(e)
     }
-  }) 
+  })
 
   window.miolo_listeners = true
-
 }
 
-export {init_catcher}
+export { init_catcher }

package/src/fetcher/fetcher.mjs

@@ -1,214 +1,211 @@
-import {omit_nil, trim_left, json_to_query_string, parse_login_cookie} from './utils.mjs'
+import { json_to_query_string, null_to_undefined, omit_nil, trim_left } 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
+  constructor(config, socket = undefined) {
+    this.config = config
+    this.http_auth = undefined
+    this.socket = socket
   }
 
-  set_auth(auth) {
+  set_http_auth(auth) {
     if (auth) {
-      const {username, password}= auth
-      this.auth= {username, password}
+      const { username, password } = auth
+      this.http_auth = { username, password }
     }
   }
 
   get_headers() {
-    let headers = {}
+    const headers = {}
 
-    if (this.auth) {
-      let {username, password}= this.auth
-      username= username || ''
-      password= password || ''
+    if (this.socket?.id) {
+      headers["x-socket-id"] = this.socket.id
+    }
+
+    if (this.http_auth) {
+      let { username, password } = this.http_auth
+      username = username || ""
+      password = password || ""
 
       let sauth
       try {
-        sauth= 'Basic ' + Buffer.from(username + ":" + password).toString('base64')
-      } catch(_) {
-        sauth= 'Basic ' + btoa(username + ":" + password)
+        sauth = "Basic " + Buffer.from(username + ":" + password).toString("base64")
+      } catch (_) {
+        sauth = "Basic " + btoa(username + ":" + password)
       }
 
-      headers['Authorization']= sauth
-    }
-
-    if (this.cookie) {
-      headers['Cookie']= this.cookie
+      headers.Authorization = sauth
     }
 
     return headers
   }
 
-  _prepare_url (url) {
-    const endpoint = '/' + trim_left(url, '/')
-    
-    const {hostname, port, force_hostname} = this.config || {}
+  _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)
+  async _fetch(method, url, params, http_auth = undefined) {
+    this.set_http_auth(http_auth)
 
-    let request = {
+    const request = {
       method,
-      mode: 'cors',
-      credentials: 'include',
+      mode: "cors",
+      credentials: "include",
       headers: {
-        'content-type': 'application/json',
-        ...this.get_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 (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)
+        wurl += json_to_query_string(params)
       }
     }
-    
+
     const response = await fetch(wurl, request)
-    
+
+    if (response.ok === false) {
+      return {
+        ok: false,
+        status: response.status,
+        response,
+        error: response.statusText
+      }
+    }
+
     if (response.redirected) {
-      const isBrowser = typeof window == 'object'
+      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");
+        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...`)
+          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()
-  
+
+    if (response.headers.get("content-type").indexOf("json") >= 0) {
+      let resp = await response.json()
+      resp = null_to_undefined(resp)
+
       return {
-        data,
+        ...resp,
         status: response.status,
         response
       }
     }
-  
-    const data= await response.text()
+
+    const data = await response.text()
     return {
+      ok: true,
       data,
       status: response.status,
       response
     }
-
   }
-  
-  async get(url, params, auth= undefined) {
-    /* eslint no-unused-vars:0 */
+
+  async get(url, params, http_auth = undefined) {
     try {
-      const resp = await this._fetch('GET', url, omit_nil(params), auth)
+      const resp = await this._fetch("GET", url, omit_nil(params), http_auth)
       return resp
-    } catch(e) {
+    } catch (e) {
       if (this.config?.silent_fail !== true) {
         console.error(`Error on GET ${url}`)
         console.error(e)
       }
 
       return {
-        data: e,
-        status: -1,
+        ok: false,
+        error: e,
+        status: -1
       }
     }
   }
 
-  async post(url, data, auth= undefined) {
+  async post(url, data, http_auth = undefined) {
     try {
-      const resp = await this._fetch('POST', url, data, auth)
+      const resp = await this._fetch("POST", url, data, http_auth)
       return resp
-    } catch(e) {
+    } catch (e) {
       if (this.config?.silent_fail !== true) {
         console.error(`Error on POST ${url}`)
         console.error(e)
       }
 
       return {
-        data: e,
+        ok: false,
+        error: 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, http_auth = undefined) {
+    return await this.get(`${url}/read`, params, http_auth)
   }
 
-  async read(url, params, auth= undefined) {
-    const result = await this.get(`${url}/read`, params, auth)
-    return result.data
+  async key_list(url, params, http_auth = undefined) {
+    return await this.get(`${url}/key_list`, params, http_auth)
   }
 
-  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 name_list(url, params, http_auth = undefined) {
+    const resp = await this.key_list(url, params, http_auth)
+    if (resp?.data) {
+      resp.data = Object.values(resp.data)
+    }
+    return resp
   }
 
-  async find(url, id, auth= undefined) {
-    const result = await this.get(`${url}/find`, { id: id }, auth)
-    return result.data
+  async find(url, id, http_auth = undefined) {
+    return await this.get(`${url}/find`, { id: id }, http_auth)
   }
 
-  async distinct(url, field, params, auth= undefined) {
-    const nparams= {
+  async distinct(url, field, params, http_auth = undefined) {
+    const nparams = {
       ...params,
       distinct_field: field
     }
-    const result = await this.get(`${url}/distinct`, nparams, auth)
-    return result.data   
+    return await this.get(`${url}/distinct`, nparams, http_auth)
   }
 
-  async upsave(url, data, auth= undefined) {
-    let result
-    if (data.id == undefined) {
+  async upsave(url, data, http_auth = undefined) {
+    let resp
+    if (data.id === undefined) {
       delete data.id
-      result= await this.post(`${url}/save`, data, auth)
+      resp = await this.post(`${url}/save`, data, http_auth)
     } else {
-      result= await this.post(`${url}/update`, data, auth)
+      resp = await this.post(`${url}/update`, data, http_auth)
     }
-    
-    return result.data
-  }  
 
-  async remove(url, id, auth= undefined) {
+    return resp
+  }
+
+  async remove(url, id, http_auth = undefined) {
     const data = { id: id }
-    const result = await this.post(`${url}/delete`, data, auth)
-    return result.data
+    return await this.post(`${url}/delete`, data, http_auth)
   }
 }
 
-Fetcher.keyList= Fetcher.key_list
-Fetcher.nameList= Fetcher.name_list
+Fetcher.keyList = Fetcher.key_list
+Fetcher.nameList = Fetcher.name_list
 
 export { Fetcher }
-

package/src/fetcher/index.mjs

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

package/src/fetcher/utils.mjs

@@ -1,59 +1,60 @@
+import qs from "qs"
+
 /**
  * Transform an JSON object to a query string
  */
-const _parse_value= (value) => {
-  try {
-    return value.replace(/\+/g, '%2B')
-  } catch(e) {
-    return value
-  }
-}
+// 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 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 ''
+  if (!obj || Object.keys(obj).length === 0) return ""
+  return `?${qs.stringify(obj, { arrayFormat: "repeat" })}`
 }
 
 export function trim_left(str, what) {
-  return str.replace(new RegExp(`^${what || '\\s'}+`), '')
+  return str.replace(new RegExp(`^${what || "\\s"}+`), "")
 }
 
-
 export function omit_nil(obj) {
-  if (typeof obj !== 'object') return obj
+  if (typeof obj !== "object") return obj
   return Object.keys(obj).reduce((acc, v) => {
-    if (obj[v] !== undefined) acc[v] = obj[v]
+    if (obj[v] !== undefined) acc[v] = omit_nil(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
+export function null_to_undefined(value) {
+  if (Array.isArray(value)) {
+    return value.map(null_to_undefined)
+  } else if (value && typeof value === "object") {
+    const data = {}
+    for (const [key, val] of Object.entries(value)) {
+      data[key] = val === null ? undefined : null_to_undefined(val)
+    }
+    return data
   }
-}
+  return value
+}

package/src/index.mjs

@@ -1,30 +1,36 @@
-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
+import { init_catcher } from "./catcher/index.mjs"
+import { init_fetcher } from "./fetcher/index.mjs"
+import { init_logger } from "./logger/index.mjs"
+import { init_socket } from "./socket/index.mjs"
+
+export function miolo_client(context) {
+  const { config } = context
+  const logger = init_logger(config?.log_level || "warn")
+
+  let socket
+  if (config?.socket?.enabled === true) {
+    logger.verbose(`[miolo-cli] init_socket at ${config?.socket?.url || "default url"}`)
+    const url = config?.socket?.url
+    const options = config?.socket?.options
+    socket = init_socket(url, options)
+    logger.verbose(
+      `[miolo-cli] socket initiated at ${socket?.url || "default url"} with id ${socket?.id}`
+    )
+  }
 
-  const fetcher = init_fetcher(config)
+  logger.verbose(`[miolo-cli] init_fetcher`)
+  const fetcher = init_fetcher(config, socket)
 
   if (config?.catcher_url) {
-    init_catcher(config?.catcher_url, fetcher)  
+    logger.verbose(`[miolo-cli] init_catcher at ${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= {
+  const miolo_obj = {
+    logger,
     fetcher,
-    //socket
+    socket
   }
 
   return miolo_obj
 }
-
-export {miolo_client}

package/src/logger/Logger.mjs

@@ -0,0 +1,51 @@
+import { blue, cyan, gray, magenta, red, yellow } from "tinguir"
+
+const LEVELS = {
+  none: 0,
+  error: 1,
+  warn: 2,
+  info: 3,
+  verbose: 4,
+  debug: 5,
+  silly: 6
+}
+
+export default class Logger {
+  constructor(level) {
+    this.set_level(level)
+  }
+
+  set_level(level) {
+    this.level = LEVELS[level !== undefined ? level : "none"]
+  }
+
+  _log(color, lvl, msg) {
+    if (this.level >= LEVELS[lvl]) {
+      console.log(`[${lvl}] ${color(msg)}`)
+    }
+  }
+
+  silly(msg) {
+    this._log(gray, "silly", msg)
+  }
+
+  debug(msg) {
+    this._log(magenta, "debug", msg)
+  }
+
+  verbose(msg) {
+    this._log(cyan, "verbose", msg)
+  }
+
+  info(msg) {
+    this._log(blue, "info", msg)
+  }
+
+  warn(msg) {
+    this._log(yellow, "warn", msg)
+  }
+
+  error(msg) {
+    this._log(red, "error", msg)
+  }
+}