holepunch-hop 0.2.8 → 0.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "holepunch-hop",
-  "version": "0.2.8",
+  "version": "0.3.0",
   "description": "data interface to HOP",
   "main": "src/index.js",
   "type": "module",

package/src/adapters/sqliteDatabase.js

@@ -49,6 +49,29 @@ class SqliteAdapter extends EventEmitter {
     return newSqlite
   }
 
+    /**
+  * setup sqlite db and get tables and columns
+  * @method discoverColumns
+  *
+  */
+    discoverColumns = async function (table) {  
+      // columns in table
+      let header = []
+      const res = await new Promise((resolve, reject) => {
+        let sqlTableCols = `PRAGMA table_info('` + table + `')`
+        this.dataBase.all(sqlTableCols, [], (err, rows) => {
+          if (err) {
+      reject(err)
+          }
+          rows.forEach((row) => {
+            header.push(row)
+          })
+          resolve(header)
+        })
+    })
+      return res
+    }
+
   /**
   * setup sqlite db and get tables and columns
   * @method createDbConnection
@@ -88,28 +111,6 @@ class SqliteAdapter extends EventEmitter {
     return res
   }
 
-  /**
-  * setup sqlite db and get tables and columns
-  * @method discoverColumns
-  *
-  */
-  discoverColumns = async function (table) {  
-    // columns in table
-    let header = []
-    const res = await new Promise((resolve, reject) => {
-	    let sqlTableCols = `PRAGMA table_info('` + table + `')`
-	    this.dataBase.all(sqlTableCols, [], (err, rows) => {
-	      if (err) {
-		reject(err)
-	      }
-	      rows.forEach((row) => {
-		      header.push(row)
-	      })
-	      resolve(header)
-	    })
-	})
-    return res
-  }
 
   /**
   * query a table for data
@@ -117,11 +118,48 @@ class SqliteAdapter extends EventEmitter {
   *
   */
   queryTable = async function (table) {
+    console.log('HP--first SQL query')
+    console.log(table)
+    let tableName = table.context.deviceTable
+    // let devicetableName = table.context.devicetablename
+    let tableTimestamp = table.context.timestamp   // timecolumn
+    let deviceColumn = ''
+    if (table?.context?.deviceCol) {
+      deviceColumn = table?.context?.deviceCol?.name
+    } else {
+      deviceColumn = ''
+    }
+    let queryDevice = 0
+    if (table.context?.deviceID) {
+      queryDevice = table.context?.deviceID
+    } else {
+      queryDevice = 1 // table?.context?.device?._id
+    }
+    let queryLimit = true
+    let queryLevel = 1400
+    let blindTimestart = 0
+    let blindTimeend = 0
     // columns in table
     let data = []
     const res = await new Promise((resolve, reject) => {
-	    let sqlQuery = `SELECT * FROM MI_BAND_ACTIVITY_SAMPLE WHERE DEVICE_ID = 3 ORDER BY TIMESTAMP DESC LIMIT 1400` // AND TIMESTAMP BETWEEN 1627677840 AND 1627678380`
-
+	    let sqlQuery = `SELECT * FROM ` + tableName 
+      // now build filter of query based on input if any
+      if (deviceColumn.length > 0) {
+        sqlQuery += ` WHERE ` + deviceColumn + ` = ` + queryDevice 
+      }
+      if (tableTimestamp.length > 0) {
+        sqlQuery += ` ORDER BY TIMESTAMP DEC` // + tableTimestamp
+      }
+      if (blindTimestart) {
+        sqlQuery += ` AND TIMESTAMP BETWEEN ` + blindTimestart + ` AND ` + blindTimeend
+ 
+      }
+      // lastly set hard limit on length
+      if (queryLimit) {
+        sqlQuery += ` LIMIT ` + queryLevel
+      }
+      console.log('HP------formed ----------')
+      console.log(sqlQuery)
 	    this.dataBase.all(sqlQuery, [], (err, rows) => {
 	      if (err) {
 		reject(err)
@@ -135,12 +173,14 @@ class SqliteAdapter extends EventEmitter {
     return res
   }
 
+
   /**
   * query device table
   * @method deviceQuery
   *
   */
   deviceQuery = async function (table) {
+    console.log('HOLEP---adtpSQL--query device SQLite ad')
     let data = []
     const res = await new Promise((resolve, reject) => {
 	    let sqlQuery = `SELECT * FROM ` + table

package/src/bees.js

@@ -4,7 +4,7 @@
 *
 * @class HypBee
 * @package    HypBee
-* @copyright  Copyright (c) 2022 James Littlejohn
+* @copyright  Copyright (c) 2024 James Littlejohn
 * @license    http://www.gnu.org/licenses/old-licenses/gpl-3.0.html
 * @version    $Id$
 */
@@ -20,6 +20,7 @@ class HyperBee extends EventEmitter {
     this.store = store
     this.swarm = swarm
     this.liveBees = {}
+    this.confirmPubLibList = {}
   }
 
   /**
@@ -45,14 +46,12 @@ class HyperBee extends EventEmitter {
       valueEncoding: 'json' // same options as above
     })
     await this.dbPublicLibrary.ready()
-    beePubkeys.push({ store: 'pubilclibrary', pubkey: b4a.toString(core.key, 'hex')})
-    // console.log(this.dbPublicLibrary._feed)
+    beePubkeys.push({ store: 'publiclibrary', pubkey: b4a.toString(core.key, 'hex')})
     // allow other peer access to public library  (need to check for DDOS ie over asked)
     // join a topic
     const discovery = this.swarm.join(this.dbPublicLibrary.discoveryKey)
     // Only display the key once the Hyperbee has been announced to the DHT
     discovery.flushed().then(() => {
-      // console.log('bee key:', b4a.toString(core.key, 'hex'))
     })
 
 
@@ -113,7 +112,6 @@ class HyperBee extends EventEmitter {
    *
   */
   savePubliclibrary = async function (refContract) {
-    console.log(refContract)
     let beeSave = await this.dbPublicLibrary.put(refContract.data.hash, refContract.data.contract)
     // go query the key are return the info. to ensure data save asplanned.
     let saveCheck = await this.getPublicLibrary(refContract.data.hash)
@@ -343,6 +341,17 @@ class HyperBee extends EventEmitter {
     return nodeData
   }
 
+  /**
+   * filter peer library to get compute modules with a key
+   * @method getPeerLibComputeModules
+   *
+  */
+  getPeerLibComputeModules = async function () {
+    const moduleData = await this.dbPeerLibrary.createHistoryStream({ reverse: true, limit: 10 })
+    return moduleData
+  }
+
+
   /**
    * get all kbl entries
    * @method KBLentries
@@ -433,9 +442,9 @@ class HyperBee extends EventEmitter {
    * @method replicatePubliclibrary
    *
   */
-  replicatePubliclibrary = async function (keylib) {
+  replicatePubliclibrary = async function (dataIn) {
     // create or get the hypercore using the public key supplied as command-line argument
-    const coreRep = this.store.get({ key: b4a.from(keylib, 'hex') })
+    const coreRep = this.store.get({ key: b4a.from(dataIn.data.datastores, 'hex') })
 
     // create a hyperbee instance using the hypercore instance
     const beePlib = new Hyperbee(coreRep, {
@@ -454,23 +463,83 @@ class HyperBee extends EventEmitter {
 
     await coreRep.update()
 
+    // if provided with specific boarnxp key then just get the contract, extract module contracts and get those contracts and then inform the peer and save to their public library
+    const boardNXPcontract = await beePlib.get(dataIn.data.boardID)
+    let unString = JSON.parse(boardNXPcontract.value)
+    let moduleContracts = []
+    for (let mod of unString.modules) {
+      let modC = await beePlib.get(mod)
+      moduleContracts.push(modC)
+    }
+    // next reference contracts, then ref within refs i.e. packaging datatypes
+    let referenceContracts = []
+    for (let modRef of moduleContracts) {
+      let unString = JSON.parse(modRef.value)
+      if (unString.style === 'packaging') {
+        // get list of datatypes
+        for (let ref of unString.info.value.concept.tablestructure) {
+          if (ref?.refcontract) {
+          let refC = await beePlib.get(ref.refcontract)
+            referenceContracts.push(refC)
+          }
+        }
+      } else if (unString.style === 'compute') {
+        // console.log('compute TODO')
+        // console.log(unString)
+      } else if (unString.style === 'visualise') {
+        // console.log('visualise TODO')
+        // console.log(unString)
+      } else if (unString.style === 'question') {
+        let questRef = {}
+        questRef.key = unString.info.key
+        questRef.value = JSON.stringify(unString.info.value)
+        referenceContracts.push(questRef)
+      }
+    }
+    // notify and get confirmation to accept and save to public library
+    if (moduleContracts.length > 0) {
+      // keep hold of data ready to be confirmed
+      let holderConfirm = {}
+      holderConfirm.boardNXP = [boardNXPcontract]
+      holderConfirm.modules = moduleContracts
+      holderConfirm.refcontracts = referenceContracts
+      this.confirmPubLibList[dataIn.data.datastores] = holderConfirm
+      this.emit('publibbeebee-notification', dataIn.data)
+    }
+    // or
     // now ask for whole of public library
     /* read all of repliate connect bee and displays */
     const chathistoryData = beePlib.createReadStream() // { gt: 'a', lt: 'z' }) // anything >a and <z
     let chatData = []
     for await (const { key, value } of chathistoryData) {
-      chatData.push({ key, value })
+      if (key === dataIn.data.boardID) {
+       chatData.push({ key, value })
+      }
     }
-
     // now replicate with peer own public library in whole or per nxp
-    let savePublib = await this.updatePublicLibrary(beePlib)
+    /* let savePublib = await this.updatePublicLibrary(beePlib)
     let repMessage = {}
     repMessage.type = 'library'
     repMessage.action = 'replicate-publiclibrary'
     repMessage.task = 'replicate'
     repMessage.reftype = 'publiclibrary'
     repMessage.data = savePublib
-    return repMessage
+    return repMessage */
+  }
+
+
+  /**
+   * peer confirmed add to public library
+   * @method addConfrimPublicLibrary
+   *
+  */
+  addConfrimPublicLibrary = async function (data) {
+    // add board nxp
+    await this.updatePublicLibrary(this.confirmPubLibList[data.datastores].boardNXP)
+    // add modules
+    await this.updatePublicLibrary(this.confirmPubLibList[data.datastores].modules)
+    // add reference
+    await this.updatePublicLibrary(this.confirmPubLibList[data.datastores].refcontracts)
   }
 
   /**
@@ -478,17 +547,10 @@ class HyperBee extends EventEmitter {
    * @method updatePublicLibrary
    *
   */
-  updatePublicLibrary = async function (updateLib) {
-    /* read all of repliate connect bee and displays */
-    const chathistoryData = updateLib.createReadStream() // { gt: 'a', lt: 'z' }) // anything >a and <z
-    let libData = []
-    for await (const { key, value } of chathistoryData) {
-      libData.push({ key, value })
-    }
-    
+  updatePublicLibrary = async function (libContracts) {
     // save entries required
     const batch = this.dbPublicLibrary.batch()
-    for (const { key, value } of libData) {
+    for (const { key, value } of libContracts) {
       await batch.put(key, JSON.parse(value))
     }
     await batch.flush()
@@ -566,10 +628,8 @@ class HyperBee extends EventEmitter {
     let rs = beeResults.createReadStream() // anything >=a and <=d
 
     for await (const { key, value } of rs) {
-      // console.log(`${key} -> ${value}`)
       // need a save funnction in here
       if (key === 'bdb6a7db0b479d9b30406cd24f3cc2f315fd3ba0') {
-        // console.log(`${key} -> ${value}`)
         let dataR = {}
         dataR.hash = key
         dataR.data = value

package/src/drive.js

@@ -300,27 +300,37 @@ class HypDrive extends EventEmitter {
   *
   */
   SQLiteQuery = async function (dataInfo) {
+    console.log('HP--DRIVE--sqlite')
      let timestampCol = ''
     // is the sqliite database sill accive?
     // const stream = this.liveDataAPI.DriveFiles.listFilesFolder('sqlite/')
     let dbFile = await this.hyperdriveLocalfile('sqlite/' + dataInfo.file.file)
     let queryData = await this.AdapterSqlite.queryTable(dataInfo)
-    let contextKeys = Object.keys(queryData[0])
-    timestampCol = contextKeys[dataInfo.context.timestamp]
-    // now prepare into data and labels
-    let blindData = {}
-    let extractCol = []
-    let extractLabel = []
-    for (let rowi of queryData) {
-	extractCol.push(rowi[dataInfo.context.name.name])
-	// assume data column for now and parse to mills seconds
-	let testCH1 = chrono.parseDate(rowi[timestampCol])
-	let parseDate = testCH1 * 1000 // this.testDataExtact(testCH1)
-	extractLabel.push(parseDate)
+    if (queryData.length > 0) {
+      let contextKeys = Object.keys(queryData[0])
+      timestampCol = contextKeys[dataInfo.context.timestamp]
+      // now prepare into data and labels
+      let blindData = {}
+      let extractCol = []
+      let extractLabel = []
+      for (let rowi of queryData) {
+    extractCol.push(rowi[dataInfo.context.name.name])
+    // assume data column for now and parse to mills seconds
+    let testCH1 = chrono.parseDate(rowi[timestampCol])
+    let parseDate = testCH1 * 1000 // this.testDataExtact(testCH1)
+    extractLabel.push(parseDate)
+      }
+      blindData.data = extractCol
+      blindData.label = extractLabel
+      return blindData
+    } else {
+      console.log('no data for that query')
+      let blindData = {}
+      blindData.data = []
+      blindData.label = []
+      return blindData
     }
-    blindData.data = extractCol
-    blindData.label = extractLabel
-    return blindData
+
   }
 
 

package/src/fileParser.js

@@ -137,6 +137,26 @@ FileParser.prototype.webCSVparse = function (fData) {
   // this.convertJSON(o, ws, headerInfo, praser, 'web', fileNewName)
 }
 
+/**
+* TEMP blind json content
+* @method TEMPwebJSONparse
+*
+*/
+FileParser.prototype.TEMPwebJSONparse = function (fjData) {
+  console.log(fjData)
+  let extractLabel = []
+  let extractCol = []
+  for (let df of fjData.content) {
+    extractLabel.push(df[fjData.context.timestampname])
+    extractCol.push(df[fjData.context.name])
+  }
+  // extract out price and time
+  let extractedPair = {}
+  extractedPair.label = extractLabel
+  extractedPair.data = extractCol
+  return extractedPair
+}
+
 /**
 * TEMP blind csv content files from web
 * @method TEMPwebCSVparse

package/src/index.js

@@ -91,12 +91,27 @@ class HolepunchWorker extends EventEmitter {
     })
     // peer connection active
     this.Peers.on('peer-connect', (data) => {
-      this.Peers.writeTonetwork(data)
+      // if (this.Peers.peerHolder[data].data.boardID !== undefined) {
+      // any existing peers
+      let holderCheck = Object.keys(this.Peers.peerHolder)
+      if (holderCheck.length !== 0) {
+        this.Peers.writeToPublicLibrary(data)
+      } else {
+        this.Peers.writeTonetwork(data)
+      }
+
     })
     // data for beebee
     this.Peers.on('beebee-data', (data) => {
       this.emit('peer-topeer', data)
     })
+    // public library notification
+    this.Peers.on('publiclibrarynotification', (data) => {
+      this.BeeData.replicatePubliclibrary(data)
+    })
+    this.BeeData.on('publibbeebee-notification', (data) => {
+      this.emit('beebee-publib-notification', data)
+    })
     // new warm incoming peer
     this.Peers.on('connect-warm', (data) => {
       let peerId = {}
@@ -115,21 +130,33 @@ class HolepunchWorker extends EventEmitter {
   */
   networkPath = function (message) {
     if (message.action === 'share') {
-      if (message.task === 'peer-join') {
-        // has the peer joined already?
-        let peerMatch = false
-        for (let wpeer of this.warmPeers) {
-          if (wpeer.publickey = message.data.publickey) {
-            peerMatch = true
-          }
+      // has the peer joined already?
+      let peerMatch = false
+      for (let wpeer of this.warmPeers) {
+        if (wpeer.publickey = message.data.publickey) {
+          peerMatch = true
         }
+      }
+      
+      if (message.task === 'peer-join') {
         if (peerMatch === true) {
-          this.Peers.peerAlreadyJoin(message.data)
+          this.Peers.peerAlreadyJoinSetData(message.data)
           this.Peers.writeTonetwork(message.data.publickey)
         } else {
           this.warmPeers.push(message.data)
           this.Peers.peerJoin(message.data)
         }
+      } else if (message.task === 'peer-board') {
+        if (peerMatch === true) {
+         this.Peers.peerAlreadyJoinSetData(message.data)
+         this.Peers.writeToPublicLibrary(message.data.publickey)
+        } else {
+          this.warmPeers.push(message.data)
+          this.Peers.peerJoin(message.data)
+          // now set data and write to public library info.
+          this.Peers.peerAlreadyJoinSetData(message.data)
+          this.Peers.writeToPublicLibrary(message.data.publickey)
+        }
       } else if (message.task === 'peer-write') {
         this.emit('peer-write', message.data)
       } else if (message.task === 'topic') {

package/src/peers.js

@@ -18,7 +18,6 @@ class NetworkPeers extends EventEmitter {
 
   constructor(store, swarm) {
     super()
-    console.log('peer manager')
     this.hello = 'hyperpeers'
     this.store = store
     this.swarm = swarm
@@ -60,9 +59,6 @@ class NetworkPeers extends EventEmitter {
       this.emit('peer-connect', publicKeylive)
       // process network message
       conn.on('data', data =>
-        // console.log('recieve network message:', data.toString()),
-        // console.log(data.toString()),
-        // console.log('emit to be verified and acted upon appropriately'),
         // assess data
         this.assessData(publicKeylive, data)
       )
@@ -76,9 +72,7 @@ class NetworkPeers extends EventEmitter {
    *
   */
   assessData = function (peer, data) {
-    console.log('assess---data receive peer-----------')
     if (Buffer.isBuffer(data)) {
-      console.log('1 buffer')
       try {
         let dataShareIn = JSON.parse(data.toString())
         if (dataShareIn.type === 'chart') {
@@ -87,12 +81,13 @@ class NetworkPeers extends EventEmitter {
           // Need to replicate public library for contracts (repliate hyberbee)
           // Need to ask for data source e.g. file (replicate hyberdrive)
           // Lastly put together SafeFlowECS query to produce chart
+        } else if (dataShareIn.type === 'public-library') {
+          this.emit('publiclibrarynotification', dataShareIn)
         } else if (dataShareIn.type === 'peer') {
-          console.log('3 buffer')
         }
         console.log(a)
       } catch (e) {
-          return console.error('ignore')
+          return console.error('ignore err')
       }
     }
   }
@@ -118,6 +113,27 @@ class NetworkPeers extends EventEmitter {
     }
   }
 
+  /**
+   * write message connect public library
+   * @method writeToPublicLibrary
+   *
+  */
+  writeToPublicLibrary = function (publickey) {
+    // check this peer has asked for chart data
+    let connectTrue = publickey in this.peerConnect
+    let libraryTrue = publickey in this.peerHolder
+    if (connectTrue === true && libraryTrue === true) {
+      let libraryData = this.peerHolder[publickey]
+      let dataShare = {}
+      dataShare.data = libraryData.data
+      dataShare.type = 'public-library'
+      this.peerConnect[publickey].write(JSON.stringify(dataShare))
+    } else {
+      console.log('no board to write ie share with a peer')
+    }
+  }
+
+
 
   /**
    * join peer to peer private (server)
@@ -134,10 +150,10 @@ class NetworkPeers extends EventEmitter {
 
   /**
    * already joined but keep track context data
-   * @method peerAlreadyJoin
+   * @method peerAlreadyJoinSetData
    *
   */
-  peerAlreadyJoin = function (peerContext) {
+  peerAlreadyJoinSetData = function (peerContext) {
     this.peerHolder[peerContext.publickey] = peerContext
   }