@es-labs/jslib 0.0.1

package/services/mq/README.md

@@ -0,0 +1,8 @@
+Need to improve on this...
+Need more research and study
+
+For express it is only to push job
+
+Also may need call to monitor and control jobs
+
+Need to have a seperate listener app

package/services/websocket.js

@@ -0,0 +1,139 @@
+// https://www.npmjs.com/package/ws
+// NOTE: if --forcedExit --detectOpenHandles in JEST test, will cause error
+// TODO: automated testing for websockets
+import WebSocket, { WebSocketServer } from 'ws'
+import https from 'https'
+
+// NOSONAR
+// function heartbeat() {
+//   clearTimeout(this.pingTimeout)
+//   // Use `WebSocket#terminate()` and not `WebSocket#close()`. Delay should be
+//   // equal to the interval at which your server sends out pings plus a
+//   // conservative assumption of the latency.
+//   this.pingTimeout = setTimeout(() => {
+//     this.terminate()
+//   }, 30000 + 1000)
+//   const client = new WebSocket('wss://echo.websocket.org/')
+//   client.on('open', heartbeat)
+//   client.on('ping', heartbeat)
+//   client.on('close', function clear() {
+//   clearTimeout(this.pingTimeout)
+// })
+// let WSServer = require('ws').Server
+// // Create web socket server on top of a regular http server
+// let wss = new WSServer({ server })
+// server.on('request', app)
+
+export default class Wss {
+  constructor(options = JSON.parse(process.env.WS_OPTIONS || null) || {}) {
+    if (!Wss._instance) {
+      Wss._instance = this
+      this._port = options.WS_PORT
+      this._keepAliveMs = options.WS_KEEEPALIVE_MS
+      this._wss = null
+      this._onClientConnect = (ws) => { }
+      this._onClientClose = (ws) => { }
+      this._onClientMessage = async (data, isBinary, ws, wss) => { // client incoming message
+        const message = isBinary ? data : data.toString()
+        // console.log('message', message)
+        try { // try-catch only detect immediate error, cannot detect if write failure    
+          if (wss) { // send to other clients except self
+            wss.clients.forEach((client) => {
+              if (client !== ws && client.readyState === WebSocket.OPEN) {
+                client.send(message) // send message to others 
+              }
+            })
+            // ws.send('something', function ack(error) { console.log }) // If error !defined, send has been completed, otherwise error object will indicate what failed.
+            ws.send(message) // echo back message...
+          }
+        } catch (e) {
+          console.log(e.toString())
+        }
+      }  
+    }
+    return Wss._instance
+  }
+  static getInstance() {
+    return this._instance
+  }
+  setOnClientMessage(onClientMessageFn) {
+    this._onClientMessage = onClientMessageFn
+  }
+  setOnClientConnect(onClientConnectFn) { //  what to do when client connects
+    this._onClientConnect = onClientConnectFn
+  }
+  setOnClientCLose(onClientCloseFn) { //  what to do when client closes
+    this._onClientClose = onClientCloseFn
+  }
+  
+  get() {
+    return this._instance
+  }
+
+  send(data) {
+    this._wss.clients.forEach((client) => {
+      if (client.readyState === WebSocket.OPEN) {
+        client.send(data)
+      }
+    })
+  }
+  
+  open(server=null, app=null) {
+    const { HTTPS_PRIVATE_KEY, HTTPS_CERTIFICATE } = process.env
+    let err
+    try {
+      if (!this._wss && this._port) {
+        if (HTTPS_CERTIFICATE) {
+          if (!server) server = https.createServer({
+            key: HTTPS_PRIVATE_KEY, cert: HTTPS_CERTIFICATE
+          }).listen(this._port) // use same port, create server because of graphql subscriptions
+          this._wss = new WebSocketServer({ server })
+        } else {
+          if (!server) this._wss = new WebSocketServer({ port: this._port }) // use seperate port
+          else this._wss = new WebSocketServer({ server })
+        }
+        if (app) server.on('request', app)
+  
+        console.log('WS API listening on port ' + this._port)
+        if (this._wss) {
+          this._wss.on('connection', (ws) => {
+            // console.log('ws client connected')
+            this._onClientConnect(ws) // what else to do when client connects
+            ws.isAlive = true
+            ws.on('pong', () => { ws.isAlive = true })
+            ws.on('close', () => this._onClientClose(ws))
+            ws.on('message', (data, isBinary) => this._onClientMessage(data, isBinary, ws, this._wss))
+          })
+          setInterval(() => { // set keep-alive
+            // console.log('WS Clients: ', this._wss.clients.size)
+            this._wss && this._wss.clients.forEach((ws) => {
+              if (!ws.isAlive) return ws.terminate() // force close
+              ws.isAlive = false
+              return ws.ping(() => {}) // NOSONAR
+            })
+          }, this._keepAliveMs)
+        }
+      } else {
+        console.log('NO WS Service To Open')
+      }
+    } catch (e) {
+      err = e.toString()
+    }
+    console.log('WS Open ' + (err ? err : 'Done'))
+    return this
+  }
+  
+  close () {
+    try { // close all connections
+      if (this._wss) {
+        this._wss.close()
+        // this._wss.clients.forEach(client => client.close(0, 'wss close() called')) // close gracefully
+        for (const client of this._wss.clients) client.terminate() // https://github.com/websockets/ws/releases/tag/8.0.0
+        this._wss = null //delete wss
+      }
+    } catch (e) {
+      console.error(e.toString())
+    }
+    console.log('WS API CLOSE OK')
+  } 
+}

package/t4t/README.md

@@ -0,0 +1 @@
+A simple table editor and form backend

package/traps.js

@@ -0,0 +1,20 @@
+export default (signalFn, exceptionFn) => {
+  let defaultExceptionFn = async (e, type) => {
+    console.log(type, e.toString())
+    // process.emit("SIGTERM") // process.exit(0), process.kill(process.pid, type)
+  }
+  if (!exceptionFn) exceptionFn = defaultExceptionFn
+  const exceptions = ['unhandledRejection', 'uncaughtException']
+  exceptions.forEach(type => process.on(type, (e) => exceptionFn(e, type)))
+  
+  let defaultSignalFn = async (type) => console.log(type)
+  if (!signalFn) signalFn = defaultSignalFn
+  const signals = ['SIGTERM', 'SIGINT', 'SIGUSR2'] // SIGINT now works on windows
+  // if (process.platform === 'win32') {
+  //   import('readline').then(readline => readline.createInterface({ input: process.stdin, output: process.stdout }).on('SIGINT', () => process.emit('SIGINT')))
+  // }
+  signals.forEach(type => process.once(type, async () => {
+    const exitCode = await signalFn(type)
+    return Number.isInteger(exitCode) ? process.exit(parseInt(exitCode)) : process.exit(-10001) // should terminate the application
+  }))
+}

package/utils/__tests__/aes.spec.js

@@ -0,0 +1,52 @@
+import assert from 'node:assert/strict';
+import { describe, it } from 'node:test';
+
+import { genIv, genKey, encryptText, decryptText } from '../aes.js';
+
+describe('utils/aes.js', () => {
+  const algorithm = 'aes256';
+  const password = 'test-password';
+  const plaintext = 'Hello, AES!';
+
+  it('should generate a valid IV (16 bytes)', () => {
+    const iv = genIv();
+    assert.ok(Buffer.isBuffer(iv));
+    assert.strictEqual(iv.length, 16);
+  });
+
+  it('should derive a 256 bit key from password', () => {
+    const key = genKey(algorithm, password);
+    assert.ok(Buffer.isBuffer(key));
+    assert.strictEqual(key.length, 32);
+  });
+
+  it('should derive a 256 bit key from password', () => {
+    const key = genKey('sha128', password);
+    assert.ok(Buffer.isBuffer(key));
+    assert.strictEqual(key.length, 32);
+  });
+
+  it('should encrypt and decrypt text correctly', () => {
+    const iv = genIv();
+    const key = genKey(algorithm, password);
+
+    const encrypted = encryptText(algorithm, key, iv, plaintext);
+    assert.ok(typeof encrypted === 'string');
+
+    const decrypted = decryptText(algorithm, key, iv, encrypted);
+    assert.strictEqual(decrypted, plaintext);
+  });
+});
+
+
+/*
+const test_aes = (data = 'test data', password = 'pw', algorithm = 'aes256') => {
+  const [iv, key] = [genIv(), genKey(algorithm, password)]
+  const encText = encryptText(algorithm, key, iv, data)
+  const decText = decryptText(algorithm, key, iv, encText)
+  console.log('Password:', password)
+  console.log('Key: ', key.toString(DEFAULT_ENCODING))
+  console.log('Plaintext: ' + decText)
+  console.log('Encrypted (aes256): ' + encText)
+}
+*/

package/utils/aes.js

@@ -0,0 +1,23 @@
+import crypto from 'crypto'
+const DEFAULT_ENCODING = 'base64' // 'binary'
+
+export const encryptText = (alg, key, iv, text, encoding = DEFAULT_ENCODING) => {
+  const cipher = crypto.createCipheriv(alg, key, iv)
+  return cipher.update(text, 'utf8', encoding) + cipher.final(encoding)
+}
+
+export const decryptText = (alg, key, iv, text, encoding = DEFAULT_ENCODING) => {
+  const decipher = crypto.createDecipheriv(alg, key, iv)
+  return decipher.update(text, encoding) + decipher.final()
+}
+
+export const genIv = () => new Buffer.alloc(16, crypto.pseudoRandomBytes(16))
+
+export const genKey = (algorithm, password) => {
+  const [size, algo] = algorithm.includes("256") ? [32, 'sha256'] :
+    // algorithm.includes("192") ? [32, 'sha192'] : // this is not support
+    algorithm.includes("128") ? [32, 'md5'] : []
+  const hash = crypto.createHash(algo)
+  hash.update(password)
+  return new Buffer.alloc(size, hash.digest('hex'),'hex')
+}

package/web/UI.md

@@ -0,0 +1,71 @@
+bulma
+bootstrap
+material UI - muicss
+
+DO NOT USE
+- material-components-web, semantic ui
+
+input
+- text (with regex)
+- number
+- date
+- time
+- datetime (local)
+- file
+- textarea
+  - replace <input> with <textarea>
+
+---
+
+Extended input
+
+- autocomplete / select (can use for selects also..., if multiple..., show tags list, delete from tags list?)
+  - single
+  - multiple
+  - allow new (always false if select)
+bwc-autocomplete (if multiple, use tags? remove tags when not needed) - tag
+bs-autocomplete - badge
+mui-autocomplete - chips
+
+---
+
+- link
+  - a[href]
+  - button
+
+
+## Input
+
+label: <label> innerText, additional classes
+input: <input> attrs: type, pattern, placeholder, additional classes
+helper: <p>
+
+
+{
+  tag:
+  attrs: []
+  // event:
+  children: [
+  ]
+}
+
+function formEl (node) {
+  const { tag, className, attrs, children } = node
+  const el = document.createElement(tag)
+  if (className) {
+    el.className = className
+  }
+  if (attrs) {
+    for (let key in attrs) {
+      el.setAttirbutes(key, attrs[key])
+    }
+  }
+  if (children) {
+    children.forEach(child => {
+      childEl = formEl(child)
+      el.appendChild(childEl)
+    })
+  }
+  return el
+}
+

package/web/bwc-autocomplete.js

@@ -0,0 +1,211 @@
+/*
+Autocomplete component using input and datalist.
+Only able to handle single selection due to nature of datalist not able to have click event
+
+attributes:
+- value (via v-model)
+- required
+- disabled
+- listid (needed if using more than 2 components on the same page)
+- input-class (style the input)
+
+properties:
+- items Array or String or Object
+
+methods:
+- setList(items) // should be private, called when items property changes
+
+events emitted:
+- @input (via v-model) - e.target.value
+- @search - e.detail String
+- @selected - e.detail String or Object or null
+
+if selected data is null (no match found, else match found)
+
+Usage with (VueJS):
+
+<bwc-autocomplete required :items="ac.items" v-model="ac.value" @search="(e) => autoComplete(e)" @selected=></bwc-autocomplete>
+
+const ac = reactive({
+  value: 'a',
+  items: ['aa9','aa5']
+})
+
+const autoComplete = (e) => {
+  const list = ['aa1', 'aa15', 'aa16', 'aa17', 'aa18', 'aa19', 'aa20', 'aa21', 'aa22', 'aa23']
+  const result = []
+  for (let i = 0; i < list.length; i++) {
+    if (list[i].includes(e.detail)) result.push(list[i])
+  }
+  ac.items = result
+}
+
+*/
+const template = document.createElement('template')
+template.innerHTML = /*html*/`
+<input type="text" list="json-datalist" placeholder="search..." autocomplete="off">
+<datalist id="json-datalist"></datalist>
+`
+
+class AutoComplete extends HTMLElement {
+  // local properties
+  #items = [] // private
+  selectedItem = null // public
+
+  constructor() {
+    super()
+    this.inputFn = this.inputFn.bind(this)
+  }
+
+  connectedCallback() {
+    this.appendChild(template.content.cloneNode(true))
+
+    // console.log('listid', this.listid)
+    this.querySelector('datalist').id = this.listid
+    this.querySelector('input').setAttribute('list', this.listid)
+
+    const el = this.querySelector('input')
+    el.addEventListener('input', this.inputFn)
+
+    el.onblur = (e) => {
+      const found = this.items.find(item => {
+        return typeof item === 'string' ? item === this.value : item.key === this.value || item.text === this.value
+      })
+      if (!found) { // not found
+        if (this.selectedItem) {
+          // console.log('not found but is selected')
+          this.selectedItem = null
+          this.dispatchEvent(new CustomEvent('selected', { detail: this.selectedItem }))
+        }
+      } else {
+        if (!this.selectedItem) {
+          // console.log('found but not selected')
+          this.selectedItem = found
+          this.dispatchEvent(new CustomEvent('selected', { detail: this.selectedItem }))
+        }
+      }
+    }
+    // console.log('setup stuff', this.required, this.disabled, this.inputClass)
+    el.value = this.value
+    el.className = this.inputClass || 'input' // default to bulma?
+
+    if (this.required) el.setAttribute('required', '')
+    else el.removeAttribute('required')
+    if (this.disabled) el.setAttribute('disabled', '')
+    else el.removeAttribute('disabled')
+
+    this.setList(this.items)
+  }
+
+  disconnectedCallback() {
+    const el = this.querySelector('input')
+    el.removeEventListener('input', this.inputFn)
+  }
+
+  attributeChangedCallback(name, oldVal, newVal) {
+    const el = this.querySelector('input')
+    switch (name) {
+      case 'value': {
+        if (el) el.value = newVal
+        this.dispatchEvent(new CustomEvent('input', { detail: newVal }))
+        break
+      }
+      case 'required': {
+        if (el) el.setAttribute('required', '')
+        break
+      }
+      case 'disabled': {
+        if (el) el.setAttribute('disabled', '')
+        break
+      }
+      case 'input-class': {
+        if (el) el.className = newVal
+        break
+      }
+      default:
+        break
+    }
+  }
+
+  static get observedAttributes() {
+    return ['value', 'required', 'listid', 'disabled', 'input-class']
+  }
+
+  get value() { return this.getAttribute('value') }
+  set value(val) { this.setAttribute('value', val) }
+
+  get required() { return this.hasAttribute('required') }
+  set required(val) {
+    if (val) {
+      this.setAttribute('required', '')
+    } else {
+      this.removeAttribute('required')
+    }
+  }
+
+  get listid() { return this.getAttribute('listid') }
+  set listid(val) { this.setAttribute('listid', val) }
+
+  get disabled() { return this.hasAttribute('disabled') }
+  set disabled(val) {
+    if (val) {
+      this.setAttribute('disabled', '')
+    } else {
+      this.removeAttribute('disabled')
+    }
+  }
+
+  get inputClass() { return this.getAttribute('input-class') }
+  set inputClass(val) { this.setAttribute('input-class', val) }
+
+  // properties
+  get items() {
+    return this.#items
+  }
+  set items(val) {
+    // console.log('set items', val.length)
+    this.#items = val
+    this.setList(val)
+  }
+
+  inputFn(e) { // whether clicked or typed
+    // console.log('inputFn', e.target.value, this.items.length)
+    const el = this.querySelector('input')
+    const prevItem = this.selectedItem
+    this.value = el.value
+
+    const found = this.items.find(item => {
+      return typeof item === 'string' ? item === this.value : item.key === this.value || item.text === this.value
+    })
+    if (!found) { // not found
+      // console.log('emit search')
+      this.selectedItem = null
+      this.dispatchEvent(new CustomEvent('search', { detail: this.value }))
+    } else {
+      this.selectedItem = found
+    }
+    // console.log('emit selected?', prevItem !== this.selectedItem, this.selectedItem)
+    if (prevItem !== this.selectedItem) {
+      this.dispatchEvent(new CustomEvent('selected', { detail: this.selectedItem }))
+    }
+  }
+
+  setList(_items) {
+    // console.log('items', _items, this.value)
+    const dd = this.querySelector('datalist')
+    if (!dd) return
+    while(dd.firstChild) {
+      dd.removeChild(dd.lastChild)
+    }
+    if (typeof _items !== 'object') return
+
+    _items.forEach((item) => {
+      const li = document.createElement('option')
+      li.innerHTML = typeof item === 'string' ? item : item.key
+      li.value = typeof item === 'string' ? item : item.text
+      dd.appendChild(li)
+    })
+  }
+}
+
+customElements.define('bwc-autocomplete', AutoComplete)