miolo 2.0.0-beta.1 → 2.0.0-beta.2

package/dist/cli/miolo.cli.umd.js

@@ -1,5 +1,5 @@
 /**
- * miolo v2.0.0-beta.1
+ * miolo v2.0.0-beta.2
  *
  * https://www.afialapis.com/os/miolo
  *

package/dist/cli-react/miolo.cli-react.umd.js

@@ -1,5 +1,5 @@
 /**
- * miolo v2.0.0-beta.1
+ * miolo v2.0.0-beta.2
  *
  * https://www.afialapis.com/os/miolo
  *

package/dist/server/miolo.server.node.mjs

@@ -1,5 +1,5 @@
 /**
- * miolo v2.0.0-beta.1
+ * miolo v2.0.0-beta.2
  *
  * https://www.afialapis.com/os/miolo
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "miolo",
-  "version": "2.0.0-beta.1",
+  "version": "2.0.0-beta.2",
   "description": "all-in-one koa-based server",
   "author": "Donato Lorenzo <donato@afialapis.com>",
   "contributors": [
@@ -15,15 +15,9 @@
   },
   "homepage": "https://www.afialapis.com/os/miolo",
   "license": "MIT",
-  "XX_exports": {
-    "./server": {
-      "import": "./dist/server/miolo.server.node.mjs",
-      "default": "./dist/server/miolo.server.cjs"
-    }
-  },
   "exports": {
     "./server": {
-      "default": "./src/server/index.mjs"
+      "default": "./dist/server/miolo.server.node.mjs"
     },
     "./server-dev": {
       "default": "./src/server/server-dev.mjs"
@@ -38,31 +32,39 @@
     }
   },
   "files": [
+    "src",
     "logo",
     "dist"
   ],
   "scripts": {
-    "main:purge": "rm -fr node_modules package-lock.json npm-lock.yaml",
+    "reset": "rm -fr node_modules package-lock.json npm-lock.yaml && npm i",
     "cli-clean": "rm -fr ./dist/cli/* ",
-    "cli-bundle": "npx xeira bundle --target=browser --source_index=./src/cli/index.mjs --bundle_folder=./dist/cli --bundle_name=miolo.cli --bundle_node_polyfill=true",
+    "cli-bundle": "npx xeira bundle --target=browser --source_index=./src/cli/index.mjs --bundle_folder=./dist/cli --bundle_name=miolo.cli --bundle_node_polyfill=true --bundle_extension=umd",
     "cli-dist": "npm run cli-clean && npm run cli-bundle",
     "cli-react-clean": "rm -fr ./dist/cli-react/*",
-    "cli-react-bundle": "npx xeira bundle --target=browser --source_index=./src/cli-react/index.mjs --bundle_folder=./dist/cli-react --bundle_name=miolo.cli-react --bundle_node_polyfill=true",
+    "cli-react-bundle": "npx xeira bundle --target=browser --source_index=./src/cli-react/index.mjs --bundle_folder=./dist/cli-react --bundle_name=miolo.cli-react --bundle_node_polyfill=true --bundle_extension=umd",
     "cli-react-dist": "npm run cli-react-clean && npm run cli-react-bundle",
     "server-clean": "rm -fr ./dist/server/*",
     "server-bundle": "npx xeira bundle --target=node --source_index=./src/server/index.mjs --bundle_folder=./dist/server --bundle_name=miolo.server --bundle_extension=node.mjs",
     "server-dist": "npm run server-clean && npm run server-bundle",
+
+    "YY-server-dev-clean": "rm -fr ./dist/server-dev/*",
+    "YY-server-dev-bundle": "npx xeira bundle --target=node --source_index=./src/server/server-dev.mjs --bundle_folder=./dist/server-dev --bundle_name=miolo.server.dev --bundle_extension=node.mjs",
+    "YY-server-dev-dist": "npm run server-dev-clean && npm run server-dev-bundle",
+
     "dist": "npm run cli-dist && npm run cli-react-dist && npm run server-dist",
+    "site": "npx xeira site",
+    "test": "npx xeira test --files=./test/index.mjs",
+
+    "X_pre-publish": "npm run test && npm run dist && npm run site",
+    "pre-publish": "npm run dist && npm run site",    
+
+
     "xxx_demo-guest": "rm -fr ./demo/build/miolo-demo-guest* && node demo/run.cjs --guest",
     "xxx_demo-basic": "rm -fr ./demo/build/miolo-demo-basic* && node demo/run.cjs --basic",
     "xxx_demo-credentials": "rm -fr ./demo/build/miolo-demo-credentials* && node demo/run.cjs --credentials",
     "xxx_demo-credentials-debug": "rm -fr ./demo/build/miolo-demo-credentials* && DEBUG=winston* node demo/run.cjs --credentials",
     "xxx_demo": "npm run demo-credentials",
-    "site": "npx xeira site",
-    "test": "npx xeira test --files=./test/index.mjs",
-    "reset": "npm run main:purge && npm i",
-    "X_prepare": "npm run test && npm run dist && npm run site",
-    "prepare": "npm run dist && npm run site",
 
     "xxx_server-dist-esbuild": "npx esbuild ./src/server/index.mjs --bundle --platform=node --outfile=dist/server/server.mjs --format=esm --external:@babel/preset-typescript --external:lightningcss --external:tty",
 

package/src/cli/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/cli/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/cli/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/cli/fetcher/utils.mjs

@@ -0,0 +1,51 @@
+/**
+ * Transform an JSON object to a query string
+ */
+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, item))
+        } else if (value !== undefined && value !== null) {
+          uparams.append(key, 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/cli/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/cli/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
+}

package/src/cli-react/AppBrowser.jsx

@@ -0,0 +1,14 @@
+import React from 'react'
+import MioloContextProvider from './context/MioloContextProvider.jsx'
+
+const AppBrowser = ({ children }) => {
+  const context = typeof window !== 'undefined' && window.__CONTEXT ? window.__CONTEXT : {};
+
+  return (
+    <MioloContextProvider context={context}>
+      {children}
+    </MioloContextProvider>
+  )  
+}
+
+export default AppBrowser

package/src/cli-react/AppBrowser.mjs

@@ -0,0 +1,14 @@
+import React from 'react'
+import MioloContextProvider from './context/MioloContextProvider.mjs'
+
+const AppBrowser = ({ children }) => {
+  const context = typeof window !== 'undefined' && window.__CONTEXT ? window.__CONTEXT : {};
+
+  return React.createElement(
+    MioloContextProvider,
+    { context },
+    children
+  )
+}
+
+export default AppBrowser

package/src/cli-react/AppServer.jsx

@@ -0,0 +1,17 @@
+
+import React from 'react'
+import MioloContextProvider from './context/MioloContextProvider.jsx'
+
+
+const AppServer = ({context, children}) => {
+
+  return (
+    <MioloContextProvider 
+        context= {context || {}}>
+      {children}
+    </MioloContextProvider>
+  )
+}
+
+export default AppServer
+

package/src/cli-react/AppServer.mjs

@@ -0,0 +1,16 @@
+import React from 'react'
+import MioloContextProvider from './context/MioloContextProvider.mjs'
+
+const AppServer = ({ context, children }) => {
+
+  console.log('AppServerAppServerAppServerAppServerAppServerAppServer')
+  console.log(context)
+  
+  return React.createElement(
+    MioloContextProvider,
+    { context: context || {} },
+    children
+  )
+}
+
+export default AppServer

package/src/cli-react/context/MioloContext.mjs

@@ -0,0 +1,5 @@
+import React from 'react'
+
+const MioloContext = React.createContext()
+
+export default MioloContext

package/src/cli-react/context/MioloContextProvider.jsx

@@ -0,0 +1,87 @@
+import React , {useState, useEffect, useCallback} from 'react'
+import Context from './MioloContext.mjs'
+import { miolo_client } from '../../cli/index.mjs'
+import { useSsrDataOrReload } from '../ssr/useSsrDataOrReload.mjs'
+
+
+const MioloContextProvider = ({context, children}) => {
+  const [innerContext, setInnerContext]= useState(context)
+  const [mioloObj, setMioloObj]= useState(miolo_client(context))
+    
+  useEffect(() => {
+    setInnerContext(context)
+    setMioloObj(miolo_client(context))
+  }, [context])
+  
+  const login = useCallback(async (credentials) => {
+    const {fetcher} = mioloObj
+    const {config} = innerContext
+
+    const url = config.login_url || '/login'
+    const resp = await fetcher.login(url, credentials)
+
+    if (resp?.data) {
+      const nContext = {
+        ...innerContext,
+        ...resp?.data
+      }    
+
+      if (resp?.data?.authenticated) {
+        setInnerContext(nContext)
+      }
+
+      return resp?.data
+    }
+
+    return {}
+  }, [innerContext, mioloObj])
+
+  
+  const logout = useCallback(async () => {
+    const {fetcher} = mioloObj
+    const {config} = innerContext
+
+    const url = config.logout_url || '/logout'
+    const _resp = await fetcher.logout(url)
+    // resp.redirected= true
+
+    const nContext = {
+      ...innerContext,
+      user: undefined,
+      authenticated: false
+    }    
+
+    setInnerContext(nContext)
+    
+    return {
+      user: undefined,
+      authenticated: false
+    }
+  }, [innerContext, mioloObj])
+
+
+  const useSsrData = (name, defval, loader, modifier) => {
+    return useSsrDataOrReload(innerContext, mioloObj, name, defval, loader, modifier)
+  }  
+  
+  return (
+    <Context.Provider 
+      value={{
+        //context: innerContext, 
+        //setContext: setInnerContext,
+        //miolo: mioloObj,
+        user: innerContext.user,
+        authenticated: innerContext.authenticated,
+        fetcher: mioloObj.fetcher,
+        //socket: mioloObj.socket,
+        login,
+        logout,
+        useSsrData
+      }}>
+      {children}
+    </Context.Provider>
+  )
+}
+
+
+export default MioloContextProvider